1、“ ` ”(反引号)的使用：

使⽤ "`" 定义不做转义处理的原始字符串，⽀持跨⾏。（正则表达式此处不涉及）

s := `a
brnx00
c`
println(s)

输出：

a
brnx00
c

2 for循环：

不要期望编译器能理解你的想法，在初始化语句中计算出全部结果是个好主意。

str:="hello jiangzhou"
	// 1）局部变量，for结束，变量释放；2）避免多次调用len()函数 多次调用如：i<len(str)
	for i,n:=0, len(str);i<n;i++{
		fmt.Printf("%c",str[i])
	}

3 Range

类似迭代器操作，返回 (索引, 值) 或 (键, 值)。

4、变参

变参本质上就是 slice。只能有⼀个，且必须是最后⼀个。
 

func test(s string, n ...int) string {
	var x int
	for _, i := range n {
		x += i
	}
	// 参数格式化  fmt.Printf()：打印
	//参数格式化：fmt.Sprintf(s, x) 返回string
	return fmt.Sprintf(s, x)
}
func main() {
	println(test("sum: %d", 1, 2, 3))
}

输出：sum: 6

使⽤ slice 对象做变参时，必须展开。

func main() {
s := []int{1, 2, 3}
println(test("sum: %d", s...))
}

5、defer使用
延迟调⽤参数在注册时求值或复制，可⽤指针或闭包 "延迟" 读取。
 

func main() {
	x,y:=10,20
	//先加载匿名函数，复制x的值给i，等到main函数结束之前，运行
	defer func(i int){
		fmt.Println("defer:",i,y)  // i:复制之前的x值，y：应用变量y的值
	}(x)  
	x+=10
	y+=20
	fmt.Println("x=",x,"y=",y)
}

运行结果：

x= 20 y= 40
defer: 10 40

6、map

1)注意事项1

引⽤类型，哈希表。键必须是⽀持相等运算符 (==、 !=) 类型，⽐如 number、 string、pointer、 array、 struct，以及对应的 interface。值可以是任意类型，没有限制。

预先给 make 函数⼀个合理元素数量参数，有助于提升性能。因为事先申请⼀⼤块内存，可避免后续操作时频繁扩张。

不能保证迭代返回次序，通常是随机结果，具体和版本实现有关。
2）注意事项2：

从 map 中取回的是⼀个 value 临时复制品，对其成员的修改是没有任何意义的。

使用指针：

7、struct

值类型，赋值和传参会复制全部内容。可⽤ "_" 定义补位字段，⽀持指向⾃⾝类型的指针成员。
 

type user struct {
	_ int //补位字段
	id int
	data *byte
	next *user  //指向自身类型的指针

}
func main()  {
	u:=user{1,124,nil,nil}
	fmt.Println(u)
}

运行效果：{0 124 <nil> <nil>}

8、⾯向对象

⾯向对象三⼤特征⾥， Go 仅⽀持封装，尽管匿名字段的内存布局和⾏为类似继承。没有class 关键字，没有继承、多态等等。

type User struct {
	id   int
	name string
}
type Manager struct {
	User
	title string
}

func main() {
	m := Manager{User{001, "jiangzhou"}, "Go语言"}
	var u User = m.User  //同类型拷⻉
	fmt.Printf("m的地址：%pn m.User的地址：%pn u的地址：%p",&m,&m.User,&u)
}

结构体的地址与首字段的地址相同。