问道Golang，6月龄必知必会(二)
网上也有很多gohper总结了一些笔记，我再提炼精简一下，挂在脑图树上便于记忆。
值类型包括：所有integer、所有float、bool、string、数组和structure
引用类型包括：指针、slice、map、chan、interface
1. map需要先先初始化，才能使用
issue：定义、不初始化使用，运行时panic; solution：make关键字初始化或者使用map字面量
m := make(map[string]float64, 5)
m["pi"] = 3.14
mm := map[string]float64{"pi": 3.14, "pi1": 4.14} // map字面量slice不需要初始化就可以被append.
var ss []intss = append(ss, 1, 2, 3)fmt.Println(ss) // [1,2,3]
2. map中取得不存在的键，会返回零值，
issue：
func main() {
x := map[string]string{"one":"a","three":"c"}
if v := x["two"]; v == "" { // 不存在该键值对，也能返回零值“”
fmt.Println("true")
}
}solution: 使用map取值的参数2 bool值来判断
func main() {
x := map[string]string{"one":"a","two":"","three":"c"}
if _,ok := x["two"]; !ok {
fmt.Println("no entry")
}
}3. array作为函数实参， array内容不受函数内影响
issue：golang array 是值类型，形参是实参的内存拷贝
package main
import "fmt"
func changeFunc(arr [3]int) {
arr[0] = 222
}
func main() {
var arr [3]int = [3]int{1, 2, 3}
changeFunc(arr)
for i, item := range arr {
fmt.Printf("index : %d, item: %d \n\r", i, item)
}
}solution：实参从array改成引用类型的 slice。
slice切片的实质是SliceHeader 结构体，值传递slice时，正好将底层数组指针拷贝。
type SliceHeader struct {Data uintptr // 底层数组的指针Len intCap int}
4. 变量遮蔽
issue: 块内声明的变量会遮蔽上层的同名变量n
func main() {
n := 0
if true {
n := 1
n++
}
fmt.Println(n) // 0
}solution: 不要使用同名遮蔽变量，使用 n=1
5. 不可修改的字符串
issue：同大多数语言一样，golang的string是不可变的
func main() {
s := "hello"
s[0] = 'H'
}
# command-line-arguments
.\main.go:8:2: cannot assign to s[0] (value of type byte)solution: 尝试通过byte/rune 中转
s := "hello"
buf := []rune(s)
buf[0] = 'H'
ss := string(buf)
fmt.Println(ss) // Hello6. strings.TrimRight 并非剔除右侧后缀
issue: strings.TrimRight实际是将cutset字符串拆成字符，然后原字符串从右向左，直到遇到没有在cutset中国出现的字符。
fmt.Println(strings.TrimRight("ABBA", "BA")) // ""
fmt.Println(strings.TrimRight("ABBAABABCABAB", "BA")) // "ABBAABABC"solution：常规的移除后缀使用 strings.TrimSuffix
7. copy函数：最小化拷贝
issue: 内置函数Copyreturns the number of elements copied, which will be the minimum of len(src) and len(dst).
src := []int{1, 2, 3}
var dst []int // 此时len(dst) =0
copy(dst, src)
fmt.Println(dst) // []solution: 初始化足够空间的dst
src := []int{1, 2, 3}
var dst []int = make([]int, 3)
copy(dst, src)
fmt.Println(dst) // [1,2,3]或者使用append方法
src := []int{1, 2, 3}
var dst1 []int
dst1 = append(dst1, src...)
fmt.Println(dst1) // [1,2,3]或者使用append方法
src := []int{1, 2, 3}
var dst1 []int
dst1 = append(dst1, src...)
fmt.Println(dst1) // [1,2,3]append方法既可以加元素，也可以加切片，真是活见久。 // slice = append(slice, elem1, elem2) // slice = append(slice, anotherSlice...)
8. range slice不是随机，range map是随机的
issue：
func main() {
ss := []int{11, 4, 5, 2, 7}
for i, item := range ss {
fmt.Printf(" %d : %d \r\n", i, item)
}
mm := map[string]int{"11": 11, "4": 4, "5": 5, "2": 2, "7": 7}
for i, m := range mm {
fmt.Printf(" %s : %d \r\n", i, m)
}
}
输出：
0 : 11
1 : 4
2 : 5
3 : 2
4 : 7 // slice
4 : 4 // map
5 : 5
2 : 2
7 : 7
11 : 119. 让人困惑的for-range 循环
golang中除了经典的三段式for循环外，还有帮助快速遍历 slice array map channel的 for range循环。
issue1：for range中操作迭代变量，原切片竟然没影响。
func main() {
ss := []int{1, 1, 1}
for _, x := range ss {
x = x + 1
}
fmt.Println(ss) // [1,1,1]
}solution：操作索引值
func main() {
ss := []int{1, 1, 1}
for i,_ := range ss {
ss[i] += 1
}
fmt.Println(ss) // [2,2,2]
}issue2：这也是一个有意思的case, 迭代体内对于[修改array元素值]无意识, 对于[修改slice元素值]有意识， 活见久。
func main() {
aa := [2]int{0, 0}
for _, x := range aa {
fmt.Println(x) // print 0,0
aa[1] = 8
}
fmt.Println(aa) // print [0,8]
}solution：将array换成slice
ss := []int{0, 0}
for _, x := range ss {
fmt.Println(x) // print 0,8
ss[1] = 8
}
fmt.Println(ss) // print [0,8]以上问题的关键是：
所有的 range 循环，Go 语言都会在编译期将原切片或者数组赋值给一个新变量 ha，在赋值的过程中就发生了拷贝，而我们又通过 len 关键字预先获取了切片的长度，所以在循环中追加新的元素也不会改变循环执行的次数，这也就解释了上面提到的现象。
而遇到这种同时遍历索引和元素的 range 循环时，Go 语言会额外创建一个新的 v2 变量存储切片中的元素，循环中使用的这个变量 v2 会在每一次迭代被重新赋值而覆盖，赋值时也会触发拷贝。
ha := a
hv1 := 0
hn := len(ha)
v1 := hv1
v2 := nil
for ; hv1 < hn; hv1++ {
tmp := ha[hv1]
v1, v2 = hv1, tmp
...
}C#中没有这么多诡异的情况。
C#数组是定长数组，一旦被创建，数组大小就无法改变；
span 带有底层数组指针和长度，但是长度也是只读，是类型安全、内存安全的滑块。
10. nil值比较[1]
issue: golang中：一个接口等于另一个接口，前提是它们的类型和动态值相同。这同样适用于nil值。
func Foo() error {
var err *os.PathError = nil
fmt.Println(err == nil) // print true
return err
}
func main() {
err := Foo()
fmt.Println(err) // print: <nil>
fmt.Println(err == nil) // print: false
}solution：强转为同一类型
fmt.Println(err == (*os.PathError)(nil)) // print: true或者显式返回nil error
func returnsError() error {
if bad() {
return ErrBad
}
return nil
}在底层，接口被实现为两个元素，一个类型T和一个值V，V是一个具体的值，比如int、结构体或指针，而不是接口本身，它的类型是T， 上面的错误示例中：err 具备了T=*MyError, V=nil 的实现，故与nil不等。
只要记住，如果接口中存储了任何具体的值，该接口将不会为nil.
最后再提供几张图，供大家参考，也许上面的坑位能柳暗花明。
(1)
[4]int在内存中的表示形式只是按顺序排列的四个整数值。
(2)
s = make([]byte,5)
切片[2]是数组片段的描述符,它由指向数组的指针、片段的长度和它的容量(片段的最大长度)组成。
当我们对s进一步切片： s =s[2,4]
C# span是指向一段连续内存的类型安全的、内存安全的视图，也有数组指针和长度length，不过他的length是只读定长的，也不会有扩容的动作。
(3)
m := make(map[string]string)
m是指向Map Header数据结构的指针，Map Header包含了关于map[3]的所有元信息:
- • map中当前的条目数
- • map中的桶数总是等于2的幂，因此存储log(桶)以保持较小的值
- • 指向连续内存位置的桶数组的指针
- • 创建不同的map的哈希种子是随机
https://phati-sawant.medium.com/internals-of-map-in-golang-33db6e25b3f8
引用链接
[1] nil值比较: https://golang.org/doc/faq#nil_error
[2] 切片: https://go.dev/blog/slices-intro
[3] map: https://go.dev/blog/maps