1. init函数

init初始化package，这是Go的一个重要特性。

2.main函数

main函数是Go程序的主函数，结构如下

func main() {
//函数体
}

3.下划线

“_”是一种特殊标识符，用来忽略结果

4.变量和常量

Go中的变量需要声明方可使用，且所有已经声明的变量必须被用到。

变量声明格式： var 变量名 变量类型 下面为例子：

var name string

批量声明例子如下：

var {

name string

age int

}

常量声明例子如下：

const pi = 3.14

4.基本类型

• 整型
• 浮点型
• 复数
• 布尔值
• 字符串

5.数组Array

1. 数组：是同一种数据类型的固定长度的序列。
2. 数组定义：var a [len]int，比如：var a [5]int，数组长度必须是常量，且是类型的组成部分。一旦定义，长度不能变。
3. 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。
4. 数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1

for i := 0; i < len(a); i++ {

}

for index, v := range a {

}

5. 访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic
6. 数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。 7.支持 "=="、"!=" 操作符，因为内存总是被初始化过的。 8.指针数组 [n]*T，数组指针 *[n]T

**数组初始化**
package main
 
import (
    "fmt"
)
 
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}
 
func main() {
    a := [3]int{1, 2}           // 未初始化元素值为 0。
    b := [...]int{1, 2, 3, 4}   // 通过初始化值确定数组长度。
    c := [5]int{2: 100, 4: 200} // 使用引号初始化元素。
    d := [...]struct {
        name string
        age  uint8
    }{
        {"user1", 10}, // 可省略元素类型。
        {"user2", 20}, // 别忘了最后一行的逗号。
    }
    fmt.Println(arr0, arr1, arr2, str)
    fmt.Println(a, b, c, d)
}

**多维数组**
package main
 
import (
    "fmt"
)
 
var arr0 [5][3]int
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
 
func main() {
    a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
    b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。
    fmt.Println(arr0, arr1)
    fmt.Println(a, b)
}

**多维数组遍历**
 package main
 ​
 import (
     "fmt"
 )
 ​
 func main() {
 ​
     var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
 ​
     for k1, v1 := range f {
         for k2, v2 := range v1 {
             fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
         }
         fmt.Println()
     }
 }