Go语言（golang）常见问题总结（二）

1.main包的唯一性

传统语言中对主入口的要求是main函数，如c++/java等，只需要保证这点即可，但是在go中还需要保证main包的唯一性。

如下，在一个main包定义如下函数

package main

import "fmt"

func func1(){
    fmt.Println("test func1")
}

然后在另一个main包的main函数中如下调用

package main

import "fmt"

func main(){
    //尝试1-尝试调用同目录下另一个main包中的函数
    //func1()
}

报错如下：

common_point\test_main1.go:63:2: undefined: func1

可以看到，两个main包实际上是相互不可见的，对于自己来说都是唯一的。需要提下的是，实际项目中，可以同一目录下包含多个main包，只要不相互调用，go build/run xxx指明对应main包文件编译运行即可，这样处理的目的在于使项目结构都清晰，同时兼容一个项目存在多个入口的情况。

2.如何跳出for select 循环

通常在for循环中，使用break可以跳出循环，但是注意在go语言中，for select配合时，break并不能跳出循环。

如下代码：

func testSelectFor(chExit chan bool){
    for  {
        select {
        case v, ok := <-chExit:
            if !ok {
                fmt.Println("close channel 1", v)
                break
            }

            fmt.Println("ch1 val =", v)
        }

    }

    fmt.Println("exit testSelectFor")
}

如下调用:

//尝试2 select for 跳出循环
c := make(chan bool)
go testSelectFor(c)

c <- true
c <- false
close(c)

time.Sleep(time.Duration(2) * time.Second)

运行结果如下，可以看到break无法跳出循环：

...
close channel 1 false
close channel 1 false
close channel 1 false
close channel 1 false
...

为了解决这个问题，需要设置标签，break 标签或goto 便签即可跳出循环，如下两种方法均可。

扫描二维码关注公众号，回复： 11393013 查看本文章

func testSelectFor2(chExit chan bool){
    EXIT:
    for  {
        select {
        case v, ok := <-chExit:
            if !ok {
                fmt.Println("close channel 2", v)
                break EXIT//goto EXIT2
            }

            fmt.Println("ch2 val =", v)
        }
    }

    //EXIT2:
    fmt.Println("exit testSelectFor2")
}

同样调用，输出结果如下：

ch2 val = true
ch2 val = false
close channel 2 false
exit testSelectFor2

3.如何在切片中查找

go中使用sort.searchXXX方法在排序好的切片中查找指定的方法，但是其返回结果很奇怪，返回是对应的查找元素不存在时待插入的位置下标(元素插入在返回下标前)。如下调用：

    //尝试3 search查找返回值
    s := []string{"ab", "ac", "ac", "bb", "bb", "ee"}
    fmt.Println("s=", s)

    fmt.Println(sort.SearchStrings(s, "aa"))
    fmt.Println(sort.SearchStrings(s, "ac"))
    fmt.Println(sort.SearchStrings(s, "ad"))
    fmt.Println(sort.SearchStrings(s, "ff"))

返回结果如下：

s= [ab ac ac bb bb ee]
0
1
3
6

可以看到，单独根据返回值没法判断对应元素是否存在，封装如下函数：

func IsExist(s []string, t string) (int, bool) {
    iIndex := sort.SearchStrings(s, t)
    bExist := iIndex!=len(s) && s[iIndex]==t

    return iIndex, bExist
}

这里用返回的下标取值再和原来值对比下，即可判断对应元素是否存在。

fmt.Println(IsExist(s, "aa"))
    fmt.Println(IsExist(s, "ac"))
    fmt.Println(IsExist(s, "ad"))
    fmt.Println(IsExist(s, "ff"))
    
    /*out
    0 false
    1 true
    3 false
    6 false*/

4.如何初始化带嵌套结构的结构体

go的哲学是组合优于继承，使用struct嵌套即可完成组合，内嵌的结构体属性就像外层结构的属性即可，可以直接调用；但是注意初始化外层结构体时必须指定内嵌结构体名称的结构体初始化，如下看到s1方式报错，s2方式正确。

type stPeople struct {
    Gender bool
    Name string
}

type stStudent struct {
    stPeople
    Class int
}

//尝试4 嵌套结构的初始化表达式
//var s1 = stStudent{false, "JimWen", 3}
var s2 = stStudent{stPeople{false, "JimWen"}, 3}
fmt.Println(s2.Gender, s2.Name, s2.Class)

5.切片和数组

go中没有特别复杂的数据结构，核心就是数组(array)和map，切片(slice)是基于数组的。很多人容易混淆array和slice的关系，这里着重说下两者的联系和区别以及应用场合。

先看二者的初始化方法,如下：

    //slice和数组初始化方法
    var a0 [5]int
    a1 := [5]int{}
    a2 := [5]int{1,2,3}
    a3 := [...]int{1,2,3}
    a4 := [5]int{1,2,3,4,5}
    fmt.Println(a0, a1, a2, a3, a4)

    var s0 []int
    s1 := a4[0:3]
    s2 := []int{1,2,3}
    s3 := make([]int, 2, 3)
    fmt.Println(s0==nil, s1, s2, s3)

输出如下

[0 0 0 0 0] [0 0 0 0 0] [1 2 3 0 0] [1 2 3] [1 2 3 4 5]
true [1 2 3] [1 2 3] [0 0]

可以看到，array可以如下初始化：

1.单独声明长度，会自动填充0值，如 var a0 [5]int

2.也可以初始化时赋值，末尾没有填满的填充0值，如a2 := [5]int{1,2,3}

3.如果不指定长度还可以自动计算，如a3 := [...]int{1,2,3}

而slice不关联数组是即为nil(如var s0 []int)，称为nil切片。slice要想不为空，必须和数组关联，有如下几种方法：

1.引用已有数组，如s1 := a4[0:3]

2.初始化表达式赋值，会默认生成底层数组，然后引用它，如s2 := []int{1,2,3}

3.使用make生成底层数组，数组填充0值，然后引用它，如s3 := make([]int, 2, 3)

除了引用数组的情况，slice和array初始化很容易区别，array必须指定长度(具体数字或...)，而slice不指定长度。

前面说了slice必须关联数组，实际上看下二者的内存结构就都明白了，如下：

array在内存中是连续的块，而slice底层也是数组，只不过加了一个头，分别包含数组起始地址、slice长度、slice容量，数组起始地址和slice长度决定了slice引用的数组范围，slice容量决定了append操作时是否开辟新的底层数组。

如下操作：

    //slice以数组为基准
    v0 := [4]int{-10, 20, 30, 40}
    s := v0[1:3]
    fmt.Println(v0, s, &v0[1], &s[0])

    //s[3] = 10 panic

    s = append(s, 80)
    fmt.Println(v0, s, &v0[1], &s[0])

    s = append(s, 90)
    fmt.Println(v0, s, &v0[1], &s[0])

结果：

[-10 20 30 40] [20 30] 0xc04200a488 0xc04200a488
[-10 20 30 80] [20 30 80] 0xc04200a488 0xc04200a488
[-10 20 30 80] [20 30 80 90] 0xc04200a488 0xc042008330

一开始s指向v0的第一个元素，包含两个元素，slice长度为2，slice容量剩余数组元素长度3。打印结果可以看到，此时s-0和v0-1是同一个元素，即slice是指向已有array的。

然后append一个80，此时可以看到底层数组也发生了改变，这是因为slice的容量为3，当前数组还够用，所以直接用了当前数组，此时s-0和v0-1是同一个元素，即slice还是指向已有array的。

然后再append一个90，此时可以看到此时s-0和v0-1不再是同一个元素，即slice指向了新的底层数组，因为原有数组已经不够用了，所以新生成数组。

一定要注意此处的逻辑，否则很容易不小心修改了底层数组或想修改底层数组而生成了新数组。

那么为什么要同时又数组和切片呢，在我看来，数组是为了提供一种底层C数组的能力，而切片相当于一种容器迭代器，可以很方便的实现动态语言的易操作特性，同时结合二者可以实现高性能和易用性兼得。

明白了这些，看下如下问题，如下给函数changeValue1传递一个数组，修改数组元素值，然后打印，发现并没有变化。实际上go中变量赋值都是拷贝，要想实现改变可以使用数组指针changeValue2或切片changeValue3，他们依然是拷贝，只不过拷贝的是地址，但是指向的依然是底层数组，所以能够成功改变数组元素值，这样就保证了go中逻辑的一致性。

//数组
func changeValue1(v [5]int)  {
    v[0] = 100
}

//数组指针
func changeValue2(v *[5]int)  {
    (*v)[0] = 100
}

//切片
func changeValue3(v []int)  {
    v[0] = 100
}

// 传递数组参数
v1 := [5]int{-10, 20, 30, 40, 50}
changeValue1(v1)

v2 := [5]int{-10, 20, 30, 40, 50}
changeValue2(&v2)

v3 := [5]int{-10, 20, 30, 40, 50}
changeValue3(v3[0:])

fmt.Println(v1, v2, v3)

//输出
[-10 20 30 40 50] [100 20 30 40 50] [100 20 30 40 50]

同样需要注意的是for range遍历切片的时候，返回的是拷贝，要想改变对应的元素值必须使用索引来改变原来的值，如下：

    //for range 对数组/切片为拷贝
    v4 := [5]int{-10, 20, 30, 40, 50}
    for _,v := range v4{
        v = v*2 //不会改变原来值
    }
    for k,v := range v4{
        fmt.Println(k,v)
    }

    for k,v := range v4{
        v4[k] = v*2 //改变原来值
    }
    for k,v := range v4{
        fmt.Println(k,v)
    }

6.map结构查找是否存在键值

在其他语言中，键值不存在直接应用会报异常，但是在go语言中会返回一个0值，因此可以如下两种方法判断键值是否存在：

package main

import "fmt"

func main(){
    m := map[int]string{1:"aaa", 2:"bbb", 3:"ccc", 4:"ddd", 5:"eee"}
    fmt.Println(m)

    v0, exist0 := m[5]
    if exist0{
        fmt.Println("exist key 5", v0)
    } else{
        fmt.Println("not exist key 5")
    }

    v1 := m[5]
    if v1!=""{
        fmt.Println("exist key 5", v0)
    } else{
        fmt.Println("not exist key 5")
    }
}

7、数组是值传递

在函数调用参数中, 数组是值传递, 无法通过修改数组类型的参数返回结果.

func main() {  
    x := [3]int{1, 2, 3}

    func(arr [3]int) {
        arr[0] = 7
        fmt.Println(arr)
    }(x)

    fmt.Println(x)
}

必要时需要使用切片（地址传递）.

8、map遍历是顺序不固定

map是一种hash表实现, 每次遍历的顺序都可能不一样.

func main() {
    m := map[string]string{
        "1": "1",
        "2": "2",
        "3": "3",
    }

    for k, v := range m {
        println(k, v)
    }
}

9、recover必须在defer函数中运行

recover捕获的是祖父级调用时的异常, 直接调用时无效:

func main() {  
    recover()
    panic(1)
}

直接defer调用也是无效:

func main() {  
    defer recover()
    panic(1)
}

defer调用时多层嵌套依然无效:

func main() {  
    defer func() {
        func() { recover() }()
    }()
    panic(1)
}

必须在defer函数中直接调用才有效:

func main() {  
    defer func() {
        recover()
    }()
    panic(1)
}