資源來自於如下連結:
開啟之後他是長這個樣子的:
逐個理解並操作之後,篩選出如下31個GOLANG的坑,與大家分享分享
1.左大括號不能單獨放一行 {
在其他大多數語言中,{
的位置你自行決定。Go比較特別,遵守分號注入規則(automatic semicolon injection):編譯器會在每行程式碼尾部特定分隔符後加;來分隔多條語句,比如會在 )
後加分號:
// 錯誤示例
func main()
{
println("www.topgoer.com是個不錯的go語言中文文件")
}
// 等效於
func main(); // 無函式體
{
println("hello world")
}
// 正確示例
func main() {
println("Golang新手可能會踩的50個坑")
}
上述錯誤示例編譯報錯如下:
2.不能使用簡短宣告來設定欄位的值
struct 的變數欄位不能使用:=
來賦值以使用預定義的變數來避免解決:
// 錯誤示例
package main
import "fmt"
type info struct {
result int
}
func work() (int, error) {
return 3, nil
}
func main() {
var data info
data.result, err := work() // error: non-name data.result on left side of :=
if err != nil{
fmt.Println(err)
return
}
fmt.Printf("info: %+v\n", data)
}
// 正確示例
func work() (int, error) {
return 3, nil
}
func main() {
tmp, err := work() // error: non-name data.result on left side of :=
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("info: %+v\n", tmp)
}
上述錯誤示例 錯誤提示如下:
3.不小心覆蓋了變數
對從動態語言轉過來的開發者來說,簡短宣告很好用,這可能會讓人誤會:=
是一個賦值操作符。如果你在新的程式碼塊中像下邊這樣誤用了:=
,編譯不會報錯,但是變數不會按你的預期工作:
func main() {
x := 1
println(x) // 1
{
println(x) // 1
x := 2
println(x) // 2 // 新的 x 變數的作用域只在程式碼塊內部
}
println(x) // 1
}
這是 Go 開發者常犯的錯,而且不易被發現。可使用 vet工具來診斷這種變數覆蓋,Go 預設不做覆蓋檢查,新增 -shadow 選項來啟用:
> go tool vet -shadow main.go
main.go:9: declaration of "x" shadows declaration at main.go:5
注意 vet 不會報告全部被覆蓋的變數,可以使用 go-nyet 來做進一步的檢測:
> $GOPATH/bin/go-nyet main.go
main.go:10:3:Shadowing variable `x`
4.顯式型別的變數無法使用 nil 來初始化
nil 是 一下 6 種 型別變數的預設初始值。但宣告時不指定型別,編譯器也無法推斷出變數的具體型別。
interface
function
pointer
map
slice
channel
// 錯誤示例
func main() {
var x = nil // error: use of untyped nil
_ = x
}
// 正確示例
func main() {
var x interface{} = nil
_ = x
}
5.直接使用值為 nil 的 slice、map
允許對值為 nil 的 slice 新增元素
因為切片是實現方式是類似於c++ 的 vector,動態擴充套件記憶體的
對值為 nil 的 map新增元素則會造成執行時 panic
map的初始化必須分配好記憶體,否則直接報錯
// map 錯誤示例
func main() {
var m map[string]int
m["one"] = 1 // error: panic: assignment to entry in nil map
// m := make(map[string]int)// map 的正確宣告,分配了實際的記憶體
}
// slice 正確示例
func main() {
var s []int
s = append(s, 1)
}
func main() {
//m := map[string]int{}
m := make(map[string]int, 1)
m["one"] = 1
}
6.map 容量
在建立 map 型別的變數時可以指定容量,但不能像 slice 一樣使用 cap() 來檢測分配空間的大小:
// 錯誤示例
func main() {
m := make(map[string]int, 99)
println(cap(m)) // error: invalid argument m1 (type map[string]int) for cap
}
按照官方文件 cap函式引數中可以放如下型別:
- array
- pointer
- sliice
- channel
7.string 型別的變數值不能為 nil
對那些喜歡用 nil 初始化字串的人來說,這就是坑:
初始化字串為空,可以用var 直接定義即可,預設就是空 “”
// 錯誤示例
func main() {
var s string = nil // cannot use nil as type string in assignment
if s == nil { // invalid operation: s == nil (mismatched types string and nil)
s = "default"
}
}
// 正確示例
func main() {
var s string // 字串型別的零值是空串 ""
if s == "" {
s = "default"
}
}
能初始化為 nil 的型別有如下6種,上述也有提到過
- 指標
- 通道
- 函式
- 介面
- map
- 切片
8.Array 型別的值作為函式引數
在 C/C++ 中,陣列(名)是指標。將陣列作為引數傳進函式時,相當於傳遞了陣列記憶體地址的引用,在函式內部會改變該陣列的值。
在 Go 中,陣列是值。作為引數傳進函式時,傳遞的是陣列的原始值拷貝,此時在函式內部是無法更新該陣列的:
// 陣列使用值拷貝傳參
func main() {
x := [3]int{3,4,5}
func(arr [3]int) {
arr[0] = 8
fmt.Println(arr) // [8 4 5]
}(x)
fmt.Println(x) // [3 4 5] // 並不是你以為的 [8 4 5]
}
如果想修改引數中的原有陣列的值,有如下2種方式:
- 直接傳遞指向這個陣列的指標型別
// 傳址會修改原資料
func main() {
x := [3]int{3,4,5}
func(arr *[3]int) {
(*arr)[0] = 8
fmt.Println(arr) // &[8 4 5]
}(&x)
fmt.Println(x) // [8 4 5]
}
直接使用 slice:即使函式內部得到的是 slice 的值拷貝,但依舊會更新 slice 的原始資料(底層 array)
因為slice是引用的方式傳遞
// 會修改 slice 的底層 array,從而修改 slice
func main() {
x := []int{1, 2, 3}
func(arr []int) {
arr[0] = 7
fmt.Println(x) // [8 4 5]
}(x)
fmt.Println(x) // [8 4 5]
}
golang中分為值型別和引用型別
值型別分別有
int系列、float系列、bool、string、陣列和結構體
引用型別有:
指標、slice切片、管道channel、介面interface、map、函式等
值型別的特點是
變數直接儲存值,記憶體通常在棧中分配
引用型別的特點是
變數儲存的是一個地址,這個地址對應的空間裡才是真正儲存的值,記憶體通常在堆中分配
9.訪問 map 中不存在的 key
和其他程式語言類似,如果訪問了 map 中不存在的 key 則希望能返回 nil,
Go 則會返回元素對應資料型別的零值,比如 nil、’’ 、false 和 0,取值操作總有值返回,故不能通過取出來的值來判斷 key 是不是在 map 中。
- 對於值型別:布林型別為
false
, 數值型別為0
,字串為""
- 陣列和結構會遞迴初始化其元素或欄位
- 其初始值取決於元素型別或欄位
- 對於引用型別: 均為
nil
,包括指標 pointer,函式 function,介面 interface,切片 slice,管道 channel,對映 map。
檢查 key 是否存在可以用 map 直接訪問,檢查返回的第二個引數即可:
// 錯誤的 key 檢測方式
func main() {
x := map[string]string{"one": "2", "two": "", "three": "3"}
if v := x["two"]; v == "" {
fmt.Println("key two is no entry") // 鍵 two 存不存在都會返回的空字串
}
}
// 正確示例
func main() {
x := map[string]string{"one": "2", "two": "", "three": "3"}
if _, ok := x["two"]; !ok {
fmt.Println("key two is no entry")
}
}
10.string 型別的值是常量,不可更改,可以使用rune來轉換
嘗試使用索引遍歷字串,來更新字串中的個別字元,是不允許的,因為 string 型別的值是常量
解決方式分為英文字串,和中文字串2種
英文字串
string 型別的值是隻讀的二進位制 byte slice,將 string 轉為 []byte 修改後,再轉為 string 即可
// 修改字串的錯誤示例
func main() {
x := "text"
x[0] = "T" // error: cannot assign to x[0]
fmt.Println(x)
}
// 修改示例
func main() {
x := "text"
xBytes := []byte(x)
xBytes[0] = 'T' // 注意此時的 T 是 rune 型別
x = string(xBytes)
fmt.Println(x) // Text
}
中文字串
一個 UTF8 編碼的字元可能會佔多個位元組,比如漢字就需要
3~4
個位元組來儲存,此時需要使用如下做法,使用 rune slice將 string 轉為 rune slice(此時 1 個 rune 可能佔多個 byte),直接更新 rune 中的字元
func main() {
x := "text"
xRunes := []rune(x)
xRunes[0] = '你'
x = string(xRunes)
fmt.Println(x) // 你ext
}
11.string 與索引操作符
對字串用索引訪問返回的不是字元,而是一個 byte 值。
如果需要使用 for range
迭代訪問字串中的字元(unicode code point / rune
),標準庫中有 "unicode/utf8"
包來做 UTF8
的相關解碼編碼。另外 utf8string
也有像 func (s *String) At(i int) rune
等很方便的庫函式。
12.字串並不都是 UTF8 文字
string 的值不必是 UTF8 文字,可以包含任意的值。只有字串是文字字面值時才是 UTF8 文字,字串可以通過轉義來包含其他資料。
判斷字串是否是 UTF8 文字,可使用 “unicode/utf8” 包中的 ValidString() 函式:
func main() {
str1 := "ABC"
fmt.Println(utf8.ValidString(str1)) // true
str2 := "A\xfeC"
fmt.Println(utf8.ValidString(str2)) // false
str3 := "A\\xfeC"
fmt.Println(utf8.ValidString(str3)) // true // 把轉義字元轉義成字面值
}
13.字串的長度
在 Go 中:
使用len函式計算字串的長度,實際上是計算byte的數量
func main() {
char := "♥"
fmt.Println(len(char)) // 3
}
如果要得到字串的字元數,可使用 “unicode/utf8” 包中的 RuneCountInString(str string) (n int)
func main() {
char := "♥"
fmt.Println(utf8.RuneCountInString(char)) // 1
}
注意: RuneCountInString 並不總是返回我們看到的字元數,因為有的字元會佔用 2 個 rune:
func main() {
char := "é"
fmt.Println(len(char)) // 3
fmt.Println(utf8.RuneCountInString(char)) // 2
fmt.Println("cafe\u0301") // café // 法文的 cafe,實際上是兩個 rune 的組合
}
14.range 迭代 string 得到的值
range 得到的索引是字元值(Unicode point / rune)第一個位元組的位置,與其他程式語言不同,這個索引並不直接是字元在字串中的位置。
注意一個字元可能佔多個 rune,比如法文單詞café
中的é
。操作特殊字元可使用norm
包。
for range 迭代會嘗試將 string 翻譯為 UTF8
文字,對任何無效的碼點都直接使用0XFFFD rune(�)
UNicode 替代字元來表示。如果 string 中有任何非 UTF8 的資料,應將 string 儲存為 byte slice 再進行操作。
func main() {
data := "A\xfe\x02\xff\x04"
for _, v := range data {
fmt.Printf("%#x ", v) // 0x41 0xfffd 0x2 0xfffd 0x4 // 錯誤
}
for _, v := range []byte(data) {
fmt.Printf("%#x ", v) // 0x41 0xfe 0x2 0xff 0x4 // 正確
}
}
15.switch 中的 fallthrough 語句
switch 語句中的 case 程式碼塊會預設帶上 break,但可以使用 fallthrough 來強制執行下一個 case 程式碼塊。
func main() {
isSpace := func(char byte) bool {
switch char {
case ' ': // 空格符會直接 break,返回 false // 和其他語言不一樣
// fallthrough // 返回 true
case '\t':
return true
}
return false
}
fmt.Println(isSpace('\t')) // true
fmt.Println(isSpace(' ')) // false
}
不過你可以在 case 程式碼塊末尾使用 fallthrough,強制執行下一個 case 程式碼塊。
16.按位取反
Go 重用^
XOR 操作符來按位取反:
// 錯誤的取反操作
func main() {
fmt.Println(~2) // bitwise complement operator is ^
}
// 正確示例
func main() {
var d uint8 = 2
fmt.Printf("%08b\n", d) // 00000010
fmt.Printf("%08b\n", ^d) // 11111101
}
同時 ^
也是按位異或(XOR)操作符。
一個操作符能重用兩次,是因為一元的 NOT 操作 NOT 0x02,與二元的 XOR 操作 0x22 XOR 0xff 是一致的。
Go 也有特殊的操作符 AND NOT ,&^
操作符,不同位才取1。
func main() {
var a uint8 = 0x82
var b uint8 = 0x02
fmt.Printf("%08b [A]\n", a)
fmt.Printf("%08b [B]\n", b)
fmt.Printf("%08b (NOT B)\n", ^b)
fmt.Printf("%08b ^ %08b = %08b [B XOR 0xff]\n", b, 0xff, b^0xff)
fmt.Printf("%08b ^ %08b = %08b [A XOR B]\n", a, b, a^b)
fmt.Printf("%08b & %08b = %08b [A AND B]\n", a, b, a&b)
fmt.Printf("%08b &^%08b = %08b [A 'AND NOT' B]\n", a, b, a&^b)
fmt.Printf("%08b&(^%08b)= %08b [A AND (NOT B)]\n", a, b, a&(^b))
}
10000010 [A]
00000010 [B]
11111101 (NOT B)
00000010 ^ 11111111 = 11111101 [B XOR 0xff]
10000010 ^ 00000010 = 10000000 [A XOR B]
10000010 & 00000010 = 00000010 [A AND B]
10000010 &^00000010 = 10000000 [A 'AND NOT' B]
10000010&(^00000010)= 10000000 [A AND (NOT B)]
17.運算子的優先順序
除了位清除(bit clear)操作符,Go 也有很多和其他語言一樣的位操作符,但是優先順序會有一些差別
func main() {
fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n", 0x2&0x2+0x4) // & 優先 +
//prints: 0x2 & 0x2 + 0x4 -> 0x6
//Go: (0x2 & 0x2) + 0x4
//C++: 0x2 & (0x2 + 0x4) -> 0x2
fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n", 0x2+0x2<<0x1) // << 優先 +
//prints: 0x2 + 0x2 << 0x1 -> 0x6
//Go: 0x2 + (0x2 << 0x1)
//C++: (0x2 + 0x2) << 0x1 -> 0x8
fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n", 0xf|0x2^0x2) // | 優先 ^
//prints: 0xf | 0x2 ^ 0x2 -> 0xd
//Go: (0xf | 0x2) ^ 0x2
//C++: 0xf | (0x2 ^ 0x2) -> 0xf
}
優先順序列表:
Precedence Operator
5 * / % << >> & &^
4 + - | ^
3 == != < <= > >=
2 &&
1 ||
18.不匯出的 struct 欄位無法被 encode
在GOLANG中
以小寫字母開頭的欄位成員是無法被外部直接訪問的
以大寫字母開頭的欄位成員 外部可以直接訪問
所以 struct 在進行json、xml
等格式的 encode 操作時,若需要正常使用,那麼要將成員開頭字母要大寫,否則這些私有欄位會被忽略,匯出時得到零值
package main
import (
"encoding/json"
"fmt"
)
type MyInfo struct {
Name string
age int
}
func main() {
in := MyInfo{"小魔童", 18}
fmt.Printf("%#v\n", in) // main.MyData{Name:"小魔童", age:18}
encoded, _ := json.Marshal(in)
fmt.Println(string(encoded)) // {Name:"小魔童"} // 私有欄位 age 被忽略了
var out MyInfo
json.Unmarshal(encoded, &out)
fmt.Printf("%#v\n", out) // main.MyData{Name:"小魔童", age:0}
}
19.向已關閉的 channel 傳送資料會造成 panic
從已關閉的
channel
接收資料是安全的,接收狀態值 ok 是 false 時表明 channel 中已沒有資料可以接收了從有緩衝的
channel
中接收資料,快取的資料獲取完再沒有資料可取時,狀態值也是 false向已關閉的
channel
中傳送資料會造成 panic
func main() {
ch := make(chan int)
for i := 0; i < 3; i++ {
go func(idx int) {
fmt.Println("i == ", idx)
select {
case ch <- (idx + 1) * 2:
fmt.Println(idx, "Send result")
}
}(i)
}
fmt.Println("Result: ", <-ch)
close(ch)
fmt.Println("-----close ch----")
time.Sleep(3 * time.Second)
}
針對上面的問題也有解決方式
可使用一個廢棄 channel done 來告訴剩餘的 goroutine 無需再向 ch 傳送資料。此時 <- done 的結果是 {}:
func main() {
ch := make(chan int)
done := make(chan struct{})
for i := 0; i < 3; i++ {
go func(idx int) {
fmt.Println("i == ", idx)
select {
case ch <- (idx + 1) * 2:
fmt.Println(idx, "Send result")
case <-done:
fmt.Println(idx, "Exiting")
}
}(i)
}
fmt.Println("Result: ", <-ch)
close(done)
fmt.Println("-----close done----")
time.Sleep(3 * time.Second)
}
20.若函式 receiver 傳參是傳值方式,則無法修改引數的原有值
方法receiver
的引數與一般函式的引數類似:如果宣告為值,那方法體得到的是一份引數的值拷貝,此時對引數的任何修改都不會對原有值產生影響。
除非 receiver 引數是 map 或 slice 型別的變數,並且是以指標方式更新 map 中的欄位、slice 中的元素的,才會更新原有值:
type data struct {
num int
key *string
items map[string]bool
}
func (this *data) pointerFunc() {
this.num = 7
}
func (this data) valueFunc() {
this.num = 8
*this.key = "valueFunc.key"
this.items["valueFunc"] = true
}
func main() {
key := "key1"
d := data{1, &key, make(map[string]bool)}
fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items)
d.pointerFunc() // 修改 num 的值為 7
fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items)
d.valueFunc() // 修改 key 和 items 的值
fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items)
}
valueFunc 函式中,data傳的是值,是一個拷貝,並且
- num 傳的是一個拷貝,因此原值沒有被改變
- key 是傳的指標,因此原值會被改變
- items是map ,是屬於引用傳遞,因此也會被改變
pointerFunc 函式中, data是傳地址,因此 num原值可以被改變
21.關閉 HTTP 的響應體
使用 HTTP 標準庫發起請求、獲取響應時,即使你不從響應中讀取任何資料或響應為空,都需要手動關閉響應體,關於http請求和響應部分有如下坑
請求http響應,關閉響應體的位置錯誤
如下程式碼能正確發起請求,但是一旦請求失敗,變數 resp 值為 nil,造成 panic
因為 resp 為nil , resp.Body.Close() 會是 從 nil 中 去body 然後 close,無法從空的地址中讀取一段記憶體,因此會panic
// 請求失敗造成 panic
func main() {
resp, err := http.Get("https://api.ipify.org?format=json")
defer resp.Body.Close() // resp 可能為 nil,不能讀取 Body
if err != nil {
fmt.Println(err)
return
}
body, err := ioutil.ReadAll(resp.Body)
checkError(err)
fmt.Println(string(body))
}
func checkError(err error) {
if err != nil{
log.Fatalln(err)
}
}
正確的做法為
先檢查 HTTP 響應錯誤為 nil,再呼叫 resp.Body.Close() 來關閉響應體:
// 大多數情況正確的示例
func main() {
resp, err := http.Get("https://api.ipify.org?format=json")
checkError(err)
defer resp.Body.Close() // 絕大多數情況下的正確關閉方式
body, err := ioutil.ReadAll(resp.Body)
checkError(err)
fmt.Println(string(body))
}
- 還會有一種重定向錯誤的情況,http請求返回的 resp 和 err 都不為空, 那麼如何處理,有2種方式
1、 可以直接在處理 HTTP 響應錯誤的程式碼塊中,直接關閉非 nil 的響應體。
2、 手動呼叫 defer 來關閉響應體:
// 正確示例
func main() {
resp, err := http.Get("http://www.baidu.com")
// 關閉 resp.Body 的正確姿勢
if resp != nil {
defer resp.Body.Close()
}
checkError(err)
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
checkError(err)
fmt.Println(string(body))
}
resp.Body.Close() 早先版本的實現是讀取響應體的資料之後丟棄,保證了 keep-alive 的 HTTP 連線能重用處理不止一個請求。
但 Go 的最新版本將讀取並丟棄資料的任務交給了使用者,如果你不處理,HTTP 連線可能會直接關閉而非重用,參考在 Go 1.5 版本文件。
如果程式大量重用 HTTP 長連線,你可能要在處理響應的邏輯程式碼中加入:
_, err = io.Copy(ioutil.Discard, resp.Body) // 手動丟棄讀取完畢的資料
如果你需要完整讀取響應,上邊的程式碼是需要寫的。比如在解碼 API 的 JSON 響應資料:
json.NewDecoder(resp.Body).Decode(&data)
22.關閉 HTTP 連線
一些支援HTTP1.1 或 HTTP1.0
配置了 connection: keep-alive
選項的伺服器會保持一段時間的長連線。但標準庫"net/http"
的連線預設只在伺服器主動要求關閉時才斷開,所以你的程式可能會消耗完 socket 描述符。解決辦法有 2 個,請求結束後:
- 直接設定請求變數的 Close 欄位值為 true,每次請求結束後就會主動關閉連線。
- 設定
Header
請求頭部選項Connection: close
,然後伺服器返回的響應頭部也會有這個選項,此時HTTP
標準庫會主動斷開連線。
// 主動關閉連線
func main() {
req, err := http.NewRequest("GET", "http://golang.org", nil)
checkError(err)
req.Close = true
//req.Header.Add("Connection", "close") // 等效的關閉方式
resp, err := http.DefaultClient.Do(req)
if resp != nil {
defer resp.Body.Close()
}
checkError(err)
body, err := ioutil.ReadAll(resp.Body)
checkError(err)
fmt.Println(string(body))
}
23.struct、array、slice 和 map 的值比較
可以使用相等運算子==
來比較結構體變數,前提是兩個結構體的成員都是可比較的型別:
type data struct {
num int
fp float32
complex complex64
str string
char rune
yes bool
events <-chan string
handler interface{}
ref *byte
raw [10]byte
}
func main() {
v1 := data{}
v2 := data{}
fmt.Println("v1 == v2: ", v1 == v2) // true
}
如果兩個結構體中有任意成員是不可比較的,將會造成編譯錯誤。注意陣列成員只有在陣列元素可比較時候才可比較。
type data struct {
num int
checks [10]func() bool // 無法比較
doIt func() bool // 無法比較
m map[string]string // 無法比較
bytes []byte // 無法比較
}
func main() {
v1 := data{}
v2 := data{}
fmt.Println("v1 == v2: ", v1 == v2)
}
invalid operation: v1 == v2 (struct containing [10]func() bool cannot be compared)
Go
提供了一些庫函式來比較那些無法使用==
比較的變數,比如使用 "reflect"
包的DeepEqual()
:
// 比較相等運算子無法比較的元素
func main() {
v1 := data{}
v2 := data{}
fmt.Println("v1 == v2: ", reflect.DeepEqual(v1, v2)) // true
m1 := map[string]string{"one": "a", "two": "b"}
m2 := map[string]string{"two": "b", "one": "a"}
fmt.Println("v1 == v2: ", reflect.DeepEqual(m1, m2)) // true
s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
// 注意兩個 slice 相等,值和順序必須一致
fmt.Println("v1 == v2: ", reflect.DeepEqual(s1, s2)) // true
}
這種比較方式可能比較慢,根據你的程式需求來使用。DeepEqual()
還有其他用法:
func main() {
var b1 []byte = nil
b2 := []byte{}
fmt.Println("b1 == b2: ", reflect.DeepEqual(b1, b2)) // false
}
注意:
DeepEqual()
並不總適合於比較slice
func main() {
var str = "one"
var in interface{} = "one"
fmt.Println("str == in: ", reflect.DeepEqual(str, in)) // true
v1 := []string{"one", "two"}
v2 := []string{"two", "one"}
fmt.Println("v1 == v2: ", reflect.DeepEqual(v1, v2)) // false
data := map[string]interface{}{
"code": 200,
"value": []string{"one", "two"},
}
encoded, _ := json.Marshal(data)
var decoded map[string]interface{}
json.Unmarshal(encoded, &decoded)
fmt.Println("data == decoded: ", reflect.DeepEqual(data, decoded)) // false
}
如果要大小寫不敏感來比較 byte 或 string 中的英文文字,可以使用 “bytes” 或 “strings” 包的 ToUpper() 和 ToLower() 函式。比較其他語言的 byte 或 string,應使用 bytes.EqualFold() 和 strings.EqualFold()
如果 byte slice 中含有驗證使用者身份的資料(密文雜湊、token 等),不應再使用 reflect.DeepEqual()、bytes.Equal()、 bytes.Compare()。這三個函式容易對程式造成 timing attacks,此時應使用 “crypto/subtle” 包中的 subtle.ConstantTimeCompare() 等函式
- reflect.DeepEqual() 認為空 slice 與 nil slice 並不相等,但注意 byte.Equal() 會認為二者相等:
func main() {
var b1 []byte = nil
b2 := []byte{}
// b1 與 b2 長度相等、有相同的位元組序
// nil 與 slice 在位元組上是相同的
fmt.Println("b1 == b2: ", bytes.Equal(b1, b2)) // true
}
24.從 panic 中恢復
在一個 defer 延遲執行的函式中呼叫 recover() ,它便能捕捉 / 中斷 panic
// 錯誤的 recover 呼叫示例
func main() {
recover() // 什麼都不會捕捉
panic("not good") // 發生 panic,主程式退出
recover() // 不會被執行
println("ok")
}
// 正確的 recover 呼叫示例
func main() {
defer func() {
fmt.Println("recovered: ", recover())
}()
panic("not good")
}
從上邊可以看出,recover() 僅在 defer 執行的函式中呼叫才會生效。
25.在 range 迭代 slice、array、map 時通過更新引用來更新元素
在 range 迭代中,得到的值其實是元素的一份值拷貝,更新拷貝並不會更改原來的元素,即是拷貝的地址並不是原有元素的地址:
func main() {
data := []int{1, 2, 3}
for _, v := range data {
v *= 10 // data 中原有元素是不會被修改的
}
fmt.Println("data: ", data) // data: [1 2 3]
}
如果要修改原有元素的值,應該使用索引直接訪問:
func main() {
data := []int{1, 2, 3}
for i, v := range data {
data[i] = v * 10
}
fmt.Println("data: ", data) // data: [10 20 30]
}
如果你的集合儲存的是指向值的指標,需稍作修改。依舊需要使用索引訪問元素,不過可以使用 range 出來的元素直接更新原有值:
func main() {
data := []*struct{ num int }{{1}, {2}, {3},}
for _, v := range data {
v.num *= 10 // 直接使用指標更新
}
fmt.Println(data[0], data[1], data[2]) // &{10} &{20} &{30}
}
26.舊 slice
當你從一個已存在的 slice 建立新 slice 時,二者的資料指向相同的底層陣列。如果你的程式使用這個特性,那需要注意 “舊”(stale) slice 問題。
某些情況下,向一個 slice 中追加元素而它指向的底層陣列容量不足時
將會重新分配一個新陣列來儲存資料。而其他 slice 還指向原來的舊底層陣列。
// 超過容量將重新分配陣列來拷貝值、重新儲存
func main() {
s1 := []int{1, 2, 3}
fmt.Println(len(s1), cap(s1), s1) // 3 3 [1 2 3 ]
s2 := s1[1:]
fmt.Println(len(s2), cap(s2), s2) // 2 2 [2 3]
for i := range s2 {
s2[i] += 20
}
// 此時的 s1 與 s2 是指向同一個底層陣列的
fmt.Println(s1) // [1 22 23]
fmt.Println(s2) // [22 23]
s2 = append(s2, 4) // 向容量為 2 的 s2 中再追加元素,此時將分配新陣列來存
for i := range s2 {
s2[i] += 10
}
fmt.Println(s1) // [1 22 23] // 此時的 s1 不再更新,為舊資料
fmt.Println(s2) // [32 33 14]
}
27.跳出 for-switch 和 for-select 程式碼塊
沒有指定標籤的 break 只會跳出 switch/select 語句,若不能使用 return 語句跳出的話,可為 break 跳出標籤指定的程式碼塊:
// break 配合 label 跳出指定程式碼塊
func main() {
loop:
for {
switch {
case true:
fmt.Println("breaking out...")
//break // 死迴圈,一直列印 breaking out...
break loop
}
}
fmt.Println("out...")
}
goto 雖然也能跳轉到指定位置,但依舊會再次進入 for-switch,死迴圈。
28.defer 函式的引數值
對 defer 延遲執行的函式,它的引數會在宣告時候就會求出具體值,而不是在執行時才求值:
// 在 defer 函式中引數會提前求值
func main() {
var i = 1
defer fmt.Println("result: ", func() int { return i * 2 }())
i++
}
29.defer 函式的執行時機
對 defer 延遲執行的函式,會在呼叫它的函式結束時執行,而不是在呼叫它的語句塊結束時執行,注意區分開。
比如在一個長時間執行的函式裡,內部 for 迴圈中使用 defer 來清理每次迭代產生的資源呼叫,就需要將defer放到一個匿名函式中才不會有問題
// 目錄遍歷正常
func main() {
// ...
for _, target := range targets {
func() {
f, err := os.Open(target)
if err != nil {
fmt.Println("bad target:", target, "error:", err)
return // 在匿名函式內使用 return 代替 break 即可
}
defer f.Close() // 匿名函式執行結束,呼叫關閉檔案資源
// 使用 f 資源
}()
}
}
30.更新 map 欄位的值
map 中的元素是不可定址的
如果 map 一個欄位的值是 struct 型別,則無法直接更新該 struct 的單個欄位
// 無法直接更新 struct 的欄位值
type data struct {
name string
}
func main() {
m := map[string]data{
"x": {"Tom"},
}
m["x"].name = "Jerry"
}
cannot assign to struct field m[“x”].name in map
- slice 的元素可定址:
type data struct {
name string
}
func main() {
s := []data{{"Tom"}}
s[0].name = "Jerry"
fmt.Println(s) // [{Jerry}]
}
當然還是有更新 map 中 struct 元素的欄位值的方法,有如下 2 個:
使用區域性變數
最值直接用賦值的方式來進行處理
// 提取整個 struct 到區域性變數中,修改欄位值後再整個賦值
type data struct {
name string
}
func main() {
m := map[string]data{
"x": {"Tom"},
}
r := m["x"]
r.name = "Jerry"
m["x"] = r
fmt.Println(m) // map[x:{Jerry}]
}
使用指向元素的 map 指標
使用的直接就是指標,無須定址
func main() {
m := map[string]*data{
"x": {"Tom"},
}
m["x"].name = "Jerry" // 直接修改 m["x"] 中的欄位
fmt.Println(m["x"]) // &{Jerry}
}
但是要注意下邊這種誤用:
出現如下問題是以內 m[“z”] 並沒有給他開闢響應的 data 結構體的記憶體,因此會出現記憶體洩露的問題
func main() {
m := map[string]*data{
"x": {"Tom"},
}
m["z"].name = "what???"
fmt.Println(m["x"])
}
panic: runtime error: invalid memory address or nil pointer dereference
31.nil interface 和 nil interface 值
雖然 interface 看起來像指標型別,但它不是。interface 型別的變數只有在型別和值均為 nil 時才為 nil
如果你的 interface 變數的值是跟隨其他變數變化的,與 nil 比較相等時小心:
func main() {
var data *byte
var in interface{}
fmt.Println(data, data == nil) // <nil> true
fmt.Println(in, in == nil) // <nil> true
in = data
fmt.Println(in, in == nil) // <nil> false // data 值為 nil,但 in 值不為 nil
}
如果你的函式返回值型別是 interface,更要小心這個坑:
// 錯誤示例
func main() {
doIt := func(arg int) interface{} {
var result *struct{} = nil
if arg > 0 {
result = &struct{}{}
}
return result
}
if res := doIt(-1); res != nil {
fmt.Println("Good result: ", res) // Good result: <nil>
fmt.Printf("%T\n", res) // *struct {} // res 不是 nil,它的值為 nil
fmt.Printf("%v\n", res) // <nil>
}
}
// 正確示例
func main() {
doIt := func(arg int) interface{} {
var result *struct{} = nil
if arg > 0 {
result = &struct{}{}
} else {
return nil // 明確指明返回 nil
}
return result
}
if res := doIt(-1); res != nil {
fmt.Println("Good result: ", res)
} else {
fmt.Println("Bad result: ", res) // Bad result: <nil>
}
}
以上為本期全部內容,如有疑問可以在評論區或後臺提出你的疑問,我們一起交流,一起成長。
好傢伙要是文章對你還有點作用的話,請幫忙點個關注,分享到你的朋友圈,分享技術,分享快樂
技術是開放的,我們的心態,更應是開放的。擁抱變化,向陽而生,努力向前行。
作者:小魔童哪吒
本作品採用《CC 協議》,轉載必須註明作者和本文連結