GO语言 复合类型专题

 a := 3
 pa := &a // 用 `&` 对变量取内存地址
 fmt.Println("point", a, *pa) // 用 `*` 来访问指向的内存

 var a0 *int // 只声明没赋值的指针是nil
 if a0 == nil {
 fmt.Println("point", "it is nil point")
 }

type Test struct {
 a int
 b int
 }

test := Test{1, 2} // 定义结构体变量并初始化

t2 = Test{a: 3}  //指定赋值Test.a为3 Test.b隐式赋值0

t3 = Test{}    // .a .b都隐式赋值0

var (
  t1 = Test{8, 6}
  t2 = Test{a: 3} //指定赋值Test.a Test.b隐式赋值0
  t3 = Test{}   // .a .b都隐式赋值0
  pt4 = &Test{8, 6} // 指针
)

fmt.Println("struct", st0.a, st0.b) // 通过 . 运算来访问结构体成员

var st0 Test 
fmt.Println("struct", st0.a, st0.b) //输出：struct 0 0

 var strarr [2]string // 数组声明语法
 strarr[0] = "ready"
 strarr[1] = "go"

 intarr := [5]int{6, 8, 9, 10, 7} // 声明赋值同时完成

 intarr := [...]int{6, 8, 9, 10, 7} // 声明赋值同时完成

s0 := []int{1, 2, 3, 4, 5, 6} // 简短声明加赋值

var s []int    // 声明切片s
s = s0   // 用切片s0初始化切片s

var s00 []int = s0 // 用切片s0初始化切片s

// 切片的零值是nil 空切片长度和容量都是0
var nilslice []int
if nilslice == nil {
  fmt.Println("slice", "nilslice is nil ", len(nilslice), cap(nilslice))
}

// 内建函数make创建切片，指定切片长度和容量
// make 函数会分配一个元素为零值的数组并返回一个引用了它的切片
s2 := make([]int, 4, 6) //创建元素都是0的切片s2, 长度为4，容量为6 第三个参数可以省略
fmt.Println("slice", len(s2), cap(s2), s2)

s0 := [5]int{6, 8, 9, 10, 7} // 数组定义
var slice []int = intarr[1:4]  // 创建切片slice 包含数组子序列

fmt.Println("slice", s0[:], s0[0:], s0[:5], s0[0:5]) // 这四个切片相同

s2 := make([]int, 4, 6) //创建元素都是0的切片s2, 长度为4，容量为6 第三个参数可以省略
s22 := append(s2, 2)  // append每次都是在最后添加，所以此时，s21 s22指向同一个底层数组
fmt.Println(s21, s22)  // [0 0 0 0 2] [0 0 0 0 2]

 s24 := append(s2, 1, 2, 3)
 fmt.Println(s24, s22) // s24 [0 0 0 0 1 2 3] [0 0 0 0 2]

 s3 := [][]int{
 {1, 1, 1},
 {2, 2, 2},
 }
 fmt.Println(s3, s3[0], len(s3), cap(s3)) // 输出： [[1 1 1] [2 2 2]] [1 1 1] 2 2

 m0 := map[int]string{
 0: "0",
 1: "1",
 }

 m1 := make(map[int]string) // make 函数会返回给定类型的映射，并将其初始化备用
 if m1 != nil {
 fmt.Println("map", "m1 is not nil", m1) // m1 不是nil
 }
 m1[0] = "1"
 m1[1] = "2"

 var m map[int]string // 未初始化的m零值是nil映射
 if m == nil {
 fmt.Println("map", "m is nil", m)
 }
 //m[0] = "1" // 这句引发panic异常， 映射的零值为 nil 。nil映射既没有键，也不能添加键。

 v, st := m1[0] // v是元素值，下标对应的元素存在st=true 否则st=false
 _, st1 := m1[0] // _ 符号表示忽略第一个元素
 v1, _ := m1[0] // _ 符号表示忽略第二个元素 
 fmt.Println(v, st, v1, st1, m1[2]) // m1[2]不存在，返回元素string的零值「空字符」

delete(m1, 1) // 删除键是 1 的元素

s1 := []int{1, 2, 3, 4, 5, 6} 
for key, vaule := range s1 {
  fmt.Println("range", key, vaule)
}

for key := range s1 { // 只需要索引，忽略第二个变量即可
  fmt.Println("range", key)
}

for _, vaule := range s1 { // 只需要元素值，用'_'忽略索引
  fmt.Println("range", vaule)
}

m0 := map[int]string{
  0: "0",
  1: "1",
}
fmt.Println("map", m0)

for k, v := range m0 { // range遍历映射，返回key 和 vaule
  fmt.Println("map", "m0 key:", k, "vaule:", v)
}