Golang basic test

1. Numbers, strings, constants

package main
import "fmt"
func main(){
    
    
	fmt.Println("----数字----")
	//uint8(别名"byte",0-255), uint16, uint32, uint64
	var a uint8 = 255
	var b byte = 255
	n1 := a + b
	//int8(-128-127), int16, int32(别名"rune"), int(默认,不能与int32互用),int64
	var c rune = 10
	var d int32 = 10
	n2 := c + d 
	//float32, float64(默认)
	var n3 = 3.14
	fmt.Println(n1)//254
	fmt.Printf("%T %T %T \n", n1, n2, n3)


	fmt.Println("----字符串----")
	str := "hallo "
	str += "world"//使用“+”拼接字符串
	//不能直接更改单个字符，拆成字节切片，修改后转回字符串
	s := []byte(str)
	fmt.Println(s)
	s[1] = 'e'
	str = string(s)
	fmt.Println(str)
	//字符串可以切割
	str = "I like the " + str[6:]
	fmt.Println(str)


	fmt.Println("----常量----")
	//特殊常量iota,在 const关键字出现时将被重置为 0,const 中每新增一行常量声明将使 iota 计数一次
	const (
		A = iota
		B
		C string = "C"
		D
		E = iota
	)
	const F = iota
	fmt.Println(A, B, C, D, E, F)
}

Second, the pointer

package main
import "fmt"
func main() {
    
    
   var a int = 4
   //一个指针变量通常缩写为ptr,空指针为nil
   var ptr *int
   fmt.Println(ptr == nil)
   ptr = &a
   fmt.Printf("ptr类型为%T\n", ptr)
   fmt.Println("ptr值为", ptr)
   fmt.Printf("*ptr值为%d\n", *ptr)
}

Three, arrays and slices

package main
import (
	"fmt"
)
func main() {
    
    
	fmt.Println("----数组----")
	//数组是具有相同唯一类型的一组已编号且长度固定的数据项序列
	arr1 := [3]byte{
    
    'a','b'}
	//也可以自行统计[...]byte{'a','b'}，但此时固定长度为2，则不能进行下边赋值
	arr1[2] = 'c'
	//二维数组
	arr2 := [2][2]int{
    
    {
    
    1,2},{
    
    3}}
	arr2[1][1] = 4
	fmt.Println(arr1, arr2)


	fmt.Println("----切片----")
	//切片("动态数组",引用类型),与数组相比切片的长度是不固定的，可以追加元素
	//像一个结构体，包含了指针，长度，最大长度
	slice1 := []int{
    
    1,2}
	slice2 := append(slice1, 3)
	slice3 := slice2[1:]
	fmt.Println(slice1,slice2,slice3)
	fmt.Println(cap(slice1))
	//使用make形式,第二个参数代表初始化2个默认成员，第三个参数表示最大成员数（可省略）。
	slice4 := make([]int, 2, 3)//2个成员
	slice5 := append(slice4, 67373)//3个成员，地址和slice4相同
	slice6 := append(slice5, 67373)//超出，重新分配地址
	fmt.Println(len(slice4),cap(slice4),slice4,slice5)
	fmt.Printf("%p %p %p \n",slice4,slice5, slice6)
	//未指定长度的切片等于nil
	var slice7 []int
	fmt.Println(slice7 == nil)
}

Four, Map collection

package main
import "fmt"
func main() {
    
    
	//初始化,也可以使用make
	m1 := map[string]int{
    
    "a": 1}
	//添加键
	key := "b"
	m1[key] = 2
	//map为引用类型，m1和m2同一个地址
	m2 := m1
	m2["c"] = 3
	fmt.Println(m1)
	//遍历
	for key, val := range m1 {
    
    
		fmt.Printf("key=%s,val=%d\n", key, val)
	}
	//删除
	delete(m1, "c")
	fmt.Println(m2)
}

Five, Struct structure

package main
import "fmt"
type Human struct{
    
    
	Name string
	Age int
}
//组合，相当于类继承
type Student struct{
    
    
	Human
	Number int
}
func main(){
    
    
	me := Student{
    
    
		Human : Human{
    
     Name: "abc"},
		Number: 67373,//换行结束时此处必须有逗号
	}
	//两种形式皆可获得，未赋值Age数字类型默认为0
	me.Age = 1
	me.Human.Age = 2
	fmt.Println(me)
	
	// 可以使用 new 去创建，但是返回的是指针类型
	you := new(Student)
	you.Number = 18 //指针类型不能.属性，这里做了语法糖，其实是(*you).Number 
	fmt.Printf("%T\n", you)

	//匿名结构体，临时使用
	his := struct{
    
    
		name string
		age uint8
	}{
    
    "his", 34} // 可以不指定key，值列表形式
	fmt.Println(his)

}

Six, function

package main
import "fmt"

//多个返回值
func fn1(c int) (d int,e int){
    
    
	d,e = c + 1, c + 2
	return 
}
func fn2(c int) (int, int){
    
    
	return c + 1, c + 2
}
//不定参数生成反转数组
func fn3(arg ...int) []int{
    
    
	length := len(arg)
	s := make([]int, length)
	for i := 0; i < length; i++ {
    
    
		s[i] = arg[length - i - 1]
	}
	return s
}

// 专有函数,也就是方法，作用于特定类型，需要有接收者
// 举例先声明一个结构体
type Me struct{
    
    
	name string
}
// 这里的变量名应使用结构体首字母小写，不要用this或者self
func (m *Me) say () {
    
    
	fmt.Println("我是" + m.name)
}

func main() {
    
    
	c := 1
	//多返回值
	d,e := fn1(c)
	f,g := fn2(c)
	fmt.Println(d, e, f, g)
	//不定参数
	s := fn3(1,2,3,4)
	fmt.Println(s)
	//say不能直接调用
	me := Me{
    
    "张三"}//new(Me)
	me.say()
}

Seven, interface

package main
import "fmt"
func main() {
    
    
	//空接口可以传任何类型
	type Element interface{
    
    }
	//一个空接口类型的切片的值可以是任意类型
	list := []Element{
    
    1,"Hello",'e'}
	fmt.Println(list)
	//断言类型
	val,ok := list[0].(int)
	fmt.Println(val,ok)
	
	//使用接口类型
	var phone Phone = new(Huawei)//这里必须取址,等同&Huawei{}
	phone.call()
}

//定义接口
type Phone interface {
    
    
	call()
}
//定义结构体
type Huawei struct {
    
    

}
//接口实现方法
func (huawei *Huawei) call() {
    
    
	fmt.Println("我用华为打电话")
}

Eight, concurrent goruntine

package main 
import (
	"fmt"
	"runtime"
)
func main() {
    
    
	fmt.Printf("CPU数量%d \n",runtime.NumCPU())
	runtime.GOMAXPROCS(3)//设置可以并行计算的CPU核数，返回之前的值

	for i := 0; i < 10; i++ {
    
    
		fmt.Println(i)//固定顺序，被gorutine穿插
		go func(i int){
    
    
			fmt.Printf("goruntine%d\n", i)
		}(i)//输出的数量不固定，顺序不固定
	}
}

Nine, chan channel

package main
import (
    "fmt"
	"time"
)
//通道可以声明接收或者发送类型
// type Sender chan<- int
// type Receiver <-chan int
func main() {
    
    
	//默认非缓存阻塞的，即第二个参数默认0.
	//设置缓存数量，可以直接写入，（再直接写入会报错），其后的可以通过goruntine写入
	c := make(chan int, 2)
	c <- 1
	c <- 2
	go func(c chan<- int) {
    
    
		for i := 3; i < 6; i++ {
    
    
			c <- i
			fmt.Println("发送",i)
		}
		close(c)
	}(c)
	//1,2可以直接读取，goruntine不一定这时候有没有发送，所以此时等待，接收到便读取，直到close
	for i := range c {
    
    
		fmt.Println("接收", i)
	}
	// 让main函数执行结束的时间延迟1秒，
	// 以使上面两个代码块有机会被执行。
	time.Sleep(time.Second)
}