使用关键字 var 定义变量，自动初始化为零值。如果提供初始化值，可省略变量类型。
在函数内部，可用更简略的 := 方式定义变量。空白符号_

package main
import "fmt"
func test() {
    data, _, i := [3]int{0, 1, 2}, 2, 0  //函数内部:=定义变量数组data[0]，data[1],data[2]并赋值0,1，2，且i=0
    i, data[i] = 2, 100 // (data[0] = 100),(i = 0) -> (i = 2) | 从右往左赋值
    fmt.Println(i, data[i], data[0])
}
func main() {
    test()
}

输出结果：
2 2 100
有关指针详见go语言的指针*和&

&符号的意思是对变量取地址，如：变量a的地址是&a
*符号的意思是对指针取值，如:*(&a)，就是a变量所在地址的值，等于a

package main
import "fmt"
func main() {
    s := "abc"
    fmt.Println(&s) //s的地址
    s, y := "hello", 20 // 重新赋值（地址还是它）: 与前 s 在同一层次的代码块中，且有新的变量被定义。
    fmt.Println(&s, y)  // 通常函数多返回值 err 会被重复使用。
    {
        s, z := 1000, 30 // 定义新同名变量（新地址存放新变量）: 不在同一层次代码块。
        fmt.Println(&s, z)
    }
}

输出结果：
0xc0000461f0
0xc0000461f0 20
0xc000014110 30

package main
import (
    "fmt"
)
func main() {
    var a int = 1      
    var b *int = &a      //*b=*&a=a, b=&a(a的地址)
    var c **int = &b     //定义**c=**&b=*b=*&a=a,*c=b=&a,c=&b(b的地址)，&c(c的地址)
    var x int = *b       //x=*b=a
    fmt.Println("a = ",a)
    fmt.Println("&a = ",&a)
    fmt.Println("*b = ",*b)
    fmt.Println("b = ",b)
    fmt.Println("&b = ",&b)
    fmt.Println("**c = ",**c)
    fmt.Println("c = ",c)
    fmt.Println("&c = ",&c)
    fmt.Println("x = ",x)
    x, y := 1, 2
    ar := [...]*int{&x, &y}  //指针数组(是数组)
    fmt.Println(ar)
}

输出结果：
a = 1
&a = 0xc0000140d8
*b = 1
b = 0xc0000140d8
&b = 0xc000006028
**c = 1
c = 0xc000006028
&c = 0xc000006030
x = 1
[0xc00001c0d8 0xc00001c0f0]
枚举
关键字 iota 定义常量组中从 0 开始按行计数的自增枚举值。如果 iota 自增被打断，须显式恢复。

const (
    A = iota // 0
    B        // 1
    C = "c"  // c
    D        // c，与上⼀一⾏行相同。
    E = iota // 4，显式恢复。注意计数包含了 C、D 两⾏行。
    F        // 5
)

使用 “" 定义不做转义处理的原始字符串，支持跨行。 ```go s :=a
b\r\n\x00
c`
println(s)
“`
输出结果：
a
b\r\n\x00
c
要修改字符串，可先将其转换成 []rune 或 []byte，完成后再转换为 string。无论哪种转换，都会重新分配内存，并复制字节数组。

package main
import "fmt"
func main() {
    s := "ab" +
        "cd"
    bs := []byte(s)
    bs[3] = 'D'
    fmt.Println(string(bs))
    u := "电脑"

    us := []rune(u)  //中文rune
    us[1] = '话'
    fmt.Println(string(us))
}

输出结果：
abcD
电话
用 for 循环遍历字符串时，也有 byte 和 rune 两种方式。

package main
import "fmt"
func main() {
    s := "abc汉字"
    for i := 0; i < len(s); i++ { // byte
        fmt.Printf("%c,", s[i])
    }
    fmt.Println()
    for _, r := range s { // rune
        fmt.Printf("%c,", r)
    }
}

输出结果：
a,b,c,æ,±,‰,å,­,—,
a,b,c,汉,字,

switch对应着case。语句对语句，

import (
    "fmt"
)
func main() {
    switch a := 1; {
    case a >= 0:
        fmt.Println("a>=0")
        fallthrough
    case a >= 1:
        fmt.Println("a>=1")
    default:
        fmt.Println("Defalut")
    }
}

输出结果：
a>=0
a>=1
跳转语句goto(调整执行位置)、continue(跳出当前循环)、break(退出)配合标签可用于多层循环的跳出

指向数组的指针(new关键字创建的数组返回的也是指向数组的指针)和指针数组

a := [...]int{9: 4}
fmt.Println(a)
var p *[10]int = &a  //指向数组的指针(是指针)
fmt.Println(p)
n := new([10]int)
fmt.Println(n)
/*
x, y := 1, 2
ar := [...]*int{&x, &y}  //指针数组(是数组)
fmt.Println(ar)   //输出[0xc00001c0d8 0xc00001c0f0]
*/

输出结果：
[0 0 0 0 0 0 0 0 0 4]
&[0 0 0 0 0 0 0 0 0 4]
&[0 0 0 0 0 0 0 0 0 0]