Go学习笔记(持续更中，参考go编程基础，go边看边练)

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

使用 "`" 定义不做转义处理的原始字符串，支持跨行。

s := `a
b
x00
c`
println(s)

输出结果：
a
b 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]