使用关键字 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]
