Why your golang sucks：每个人都会踩的GO的五十个坑（11-20）

傷城~ 2022-06-02 03:24 126阅读 0赞

# Why your golang sucks：每个人都会踩的GO的五十个坑 （11-20） #

> 本文翻译自 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New Golang Devs
> 
> Go语言是一个简单却蕴含深意的语言。但是，即便号称是最简单的C语言，都能总结出一本《C陷阱与缺陷》，更何况Go语言呢。Go语言中的许多坑其实并不是因为Go自身的问题。一些错误你再别的语言中也会犯，例如作用域，一些错误就是对因为 Go 语言的特性不了解而导致的，例如 range。

## 11.字符串赋值为 nil ##

级别：新手入门级

go的string类型变量无法赋值为nil，也无法与nil进行比较操作。string对应的空值是”“

nil类似于C/C++中的NULL，另外，Objective C和JAVA的String是可以赋值为NULL的。

错误代码：

package main
    
    func main() {  
        var x string = nil //error
    
        if x == nil { //error
            x = "default"
        }
    }

错误信息：

# command-line-arguments
    ./50demo.go:28: cannot use nil as type string in assignment
    ./50demo.go:30: invalid operation: x == nil (mismatched types string and nil)

修正代码:

package main
    
    func main() {  
        var x string //defaults to "" (zero value)
    
        if x == "" {
            x = "default"
        }
    }

## 12.数组被当做函数入参进行传递 ##

级别：新手入门级

在C/C++中，入参如果是一个数组的话，那么实际上传递的是这个数组的指针，在函数内对该指针进行修改，是可以修改到原本数组的内容。

在GO语言中，数组Array作为函数入参是传该数组的一个拷贝，在函数内对数组成员进行修改并不会影响原有数组；切片Slice作为入参则会传指针那么数组对你而言就是指针，对切片进行修改会影响原有的切片成员。

PS：

a [3]int，这是一个数组
    b []int，这是一个切片  
    需要明辨数组和切片的区别

package main
    
    import "fmt"
    
    func main() {  
        x := [3]int{1,2,3}
    
        func(arr [3]int) {
            arr[0] = 7
            fmt.Println(arr) //prints [7 2 3]
        }(x)
    
        fmt.Println(x) //prints [1 2 3] (not ok if you need [7 2 3])
    }

如果需要修改原数组的数据，则需要使用数组指针。

package main
    
    import "fmt"
    
    func main() {  
        x := [3]int{1,2,3}
    
        func(arr *[3]int) {
            (*arr)[0] = 7
            fmt.Println(arr) //prints &[7 2 3]
        }(&x)
    
        fmt.Println(x) //prints [7 2 3]
    }

或者可以使用 Slice，

package main
    
    import "fmt"
    
    func main() {  
        x := []int{1,2,3}
    
        func(arr []int) {
            arr[0] = 7
            fmt.Println(arr) //prints [7 2 3]
        }(x)
    
        fmt.Println(x) //prints [7 2 3]
    }

## 13.使用 Slice 和 Array 的 range ##

级别：新手入门级

如果你对别的语言中的 for in 和 foreach 熟悉的话，那么 Go 中的 range 使用方法完全不一样。

GO语言中的range每次会返回两个值，第一个值是在 Slice 或 Array 中的编号，第二个是对应的数据的值。

错误代码：

package main
    
    import "fmt"
    
    func main() {  
        x := []string{
       "a","b","c"}
    
        for v := range x { //因为只有一个值接收，虽然编译会通过，但是这个v是下标值，也可以理解为index
            fmt.Println(v) //prints 0, 1, 2
        }
    }

修正代码：

package main
    
    import "fmt"
    
    func main() {  
        x := []string{
       "a","b","c"}
    
        for _, v := range x {
            fmt.Println(v) //prints a, b, c
        }
    }

## 14.Slice 和 Array 维度是一维 ##

级别：新手入门级

Go 看上去支持多维的 Array 和 Slice，但是其实不然。尽管可以创建 Array 的 Array，也可以创建 Slice 的 Slice。**对于依赖多维 Array 的计算密集型的程序，无论是从性能还是复杂程度，Go 都不是最佳选择。**

当然，如果你选择创建嵌套的 Array 与嵌套的 Slice，那么你就得自己负责进行索引、进行下表检查、以及 Array 增长时的内存分配。嵌套 Slice 分为两种，Slice 中嵌套独立的 Slice，或者 Slice 中嵌套共享数据的 Slice。

使用嵌套的独立 Slice 创建多维的 Array 需要两步。第一步，创建外围 Slice，然后分配每个内部的 Slice。内部的 Slice 是独立的，可以对每个单独的内部 Slice 进行缩放。

package main
    
    func main() {  
        x := 2
        y := 4
    
        table := make([][]int,x)
        for i:= range table {
            table[i] = make([]int,y)
        }
    }

使用嵌套、共享数据的 Slice 创建多维 Array 需要三步。第一，创建数据“容器”，第二部，创建外围 Slice，第三部，对内部的 Slice 进行初始化。

package main
    
    import "fmt"
    
    func main() {  
        h, w := 2, 4
    
        raw := make([]int,h*w)
        for i := range raw {
            raw[i] = i
        }
        fmt.Println(raw,&raw[4])
        //prints: [0 1 2 3 4 5 6 7] <ptr_addr_x>
    
        table := make([][]int,h)
        for i:= range table {
            table[i] = raw[i*w:i*w + w]
        }
    
        fmt.Println(table,&table[1][0])
        //prints: [[0 1 2 3] [4 5 6 7]] <ptr_addr_x>
    }

Go 语言也有对于支持多维 Array 和 Slice 的需求，不过不要期待太多。Go 语言官方将这些需求分在“低优先级”组中。

## 15.访问不存在的 Map Key ##

级别：新手入门级

先看第一种写法，通过查询某一个值，看其是否是空值来判断map中该key值是否存在。这个写法在如果该key值在map下对应的值时空值（nil、0或者”“）的时候，也会认为该key不存在，但实际上该key存在。

错误代码：

package main
    
    import "fmt"
    
    func main() {  
        x := map[string]string{
       "one":"a","two":"","three":"c"}
    
        if v := x["two"]; v == "" { //incorrect
            fmt.Println("no entry")
        }
    
        if v := x["four"]; v == "" { //incorrect
            fmt.Println("no entry")
        }
    }
    
    no entry
    no entry

检测对应的“零值”可以用于确定map中的记录是否存在，但这并不总是可行。

**检测给定map中的记录是否存在的最可信的方法是，通过map的访问操作，检查第二个返回的值。**

修正代码：

package main
    
    import "fmt"
    
    func main() {  
        x := map[string]string{
       "one":"a","two":"","three":"c"}
    
        if _,ok := x["two"]; !ok {
            fmt.Println("no entry")
        }
    
        if _,ok := x["four"]; !ok {
            fmt.Println("no entry") // will print "no entry"
        }
    }

## 16.String 不可变 ##

级别：新手入门级

对于 String 中单个字符的操作会导致编译失败。如果想要对 String 操作的话，应当使用\[\]byte，而不是将它转换为 String 类型。

错误信息：

package main
    
    import "fmt"
    
    func main() { x := "text" x[0] = 'T' fmt.Println(x) }

错误信息：

# command-line-arguments
    ./50demo.go:30: cannot assign to x[0]

修正代码：

package main
    
    import "fmt"
    
    func main() {  
        x := "text"
        xbytes := []byte(x)
        xbytes[0] = 'T'
    
        fmt.Println(string(xbytes)) //prints Text
    }

需要注意的是：**这并不是在文字string中更新字符的正确方式，因为给定的字符可能会存储在多个byte中。**如果你确实需要更新一个文字string，先把它转换为一个rune slice（\[\]rune）。即使使用rune slice，单个字符也可能会占据多个rune，比如当你的字符有特定的重音符号时就是这种情况。这种复杂又模糊的“字符”本质是Go字符串使用byte序列表示的原因。

我们将会在下面提到。

### string不可变的好处 ###

1.  只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的，那么String interning将不能实现(String interning是指对不同的字符串仅仅只保存一个，即不会保存多个相同的字符串)，因为这样的话，如果变量改变了它的值，那么其它指向这个值的变量的值也会一起改变。
2.  如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
3.  因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
4.  类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。
5.  因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

## 17.String 与 Byte Slice 的转换 ##

级别：新手入门级

当你把一个字符串转换为\[\]byte（或者反之）时，你就得到了一个原始数据的完整拷贝。这和其他语言中cast操作不同，也和新的slice变量指向原始\[\]byte使用的相同数组时的重新slice操作不同。

Go在\[\]byte到string和string到\[\]byte的转换中确实使用了一些优化来避免额外的内存分配（当然在golang的todo列表中有更多的优化还需要做）。

举个例子

一个优化是避免了当\[\]byte keys用于在map\[string\]集合中查询时的额外内存分配:

`m[string(key)]`

另一个优化避免了字符串转换为\[\]byte后在for range语句中的额外内存分配：

`for i,v := range []byte(str) {...}`

## 18.String 与下标 ##

级别：新手入门级

对字符串的索引操作是返回一个byte值，而不是一个字符char（和其他语言中的做法一样）。

package main
    import "fmt"
    func main() {  
        x := "text"
        fmt.Println(x[0]) //print 116
        fmt.Printf("%T",x[0]) //prints uint8
    }

如果你需要访问特定编码的字符串中的“字符”（unicode编码的points/runes），使用for range。官方的“unicode/utf8”包和实验中的utf8string包（golang.org/x/exp/utf8string）也可以用。utf8string包中包含了一个很方便的At()方法。把字符串转换为rune的切片也是一个选项。

## 19.String并不一定存储的是UTF8格式字符 ##

级别：新手入门级

String 类型不一定是 UTF8 编码，String 中也可以包含自定义的文字/字节。只有需要将字符串显示出来的时候才需要用 UTF8 格式，其他情况下可以随便用转义来表示任意字符。

可以使用 unicode/utf8 包中的 ValidString() 方法判断是否是 UTF8 类型的文本。

package main
    
    import (  
        "fmt"
        "unicode/utf8"
    )
    
    func main() {  
        data1 := "ABC"
        fmt.Println(utf8.ValidString(data1)) //prints: true
    
        data2 := "A\xfeC"
        fmt.Println(utf8.ValidString(data2)) //prints: false
    }

## 20.String 的长度 ##

级别：新手入门级

Python 代码：

data = u'♥'  
    print(len(data)) #prints: 1

转换成类似的 Go 代码如下：

package main
    
    import "fmt"
    
    func main() {  
        data := "♥"
        fmt.Println(len(data)) //prints: 3
    }

Go 的 len() 方法和 Python 的并不相同，和 Python 的 len 方法等价的 Go 方法是 RuneCountInString。

package main
    
    import (  
        "fmt"
        "unicode/utf8"
    )
    
    func main() {  
        data := "♥"
        fmt.Println(utf8.RuneCountInString(data)) //prints: 1
    }

当然有些情况（例如法语）的情况，RuneCountInString 也并不能完全返回字符数目，因为有些字符是使用多个rune的方式进行存储的。

package main
    
    import (  
        "fmt"
        "unicode/utf8"
    )
    
    func main() {  
        data := "é"
        fmt.Println(len(data))                    //prints: 3
        fmt.Println(utf8.RuneCountInString(data)) //prints: 2
    }