Golang中for循環(huán)遍歷避坑指南

更新時間：2023年05月11日 14:04:17 作者：人艱不拆_zmc

這篇文章主要為大家詳細(xì)介紹了Golang中for循環(huán)遍歷會出現(xiàn)的一些小坑以及對應(yīng)的解決辦法，文中的示例代碼講解詳細(xì)，感興趣的可以了解一下

一、for循環(huán)

循環(huán):讓程序多次執(zhí)行相同的代碼塊

for循環(huán)是Go語言中唯一一個循環(huán)結(jié)構(gòu)

for循環(huán)經(jīng)典語法

先執(zhí)行表達(dá)式1
執(zhí)行表達(dá)式2判斷是否成立,如果成立執(zhí)行循環(huán)體
循環(huán)體執(zhí)行完成后,執(zhí)行表達(dá)式3
再次執(zhí)行表達(dá)式2,判斷是否成立.

for循環(huán)用的最多的地方就是遍歷數(shù)組或切片等

for 表達(dá)式1;表達(dá)式2;表達(dá)式3{
//循環(huán)體
}　

經(jīng)典for循環(huán)結(jié)構(gòu)中 , for關(guān)鍵字后面有三個表達(dá)式,且每個表達(dá)式都可以省略。

for i := 0; i < 5; i++ {
    fmt.Println(i)
}
//等價于
j := 0
for ; j < 5; {
    fmt.Println(j)
    j++
}

for關(guān)鍵字后面也可以只有一個表達(dá)式,表示如果條件成立執(zhí)行循環(huán)體代碼。

for i := 0; i < 5; i++ {
    fmt.Println(i)
}
//等價于
j := 0
for j < 5 {
    fmt.Println(j)
    j++
}

二、range語句

Golang range類似迭代器操作，可以對 slice、map、數(shù)組、字符串等進(jìn)行迭代循環(huán)。在字符串、數(shù)組和切片中它返回 (索引, 值) ，在map中返回 (鍵, 值)，但若當(dāng)只有一個返回值時，第一個參數(shù)是索引或鍵。

str := "abc"
for i, char := range str {
    fmt.Printf("%d => %s\n", i, string(char))
}
for i := range str { //只有一個返回值
    fmt.Printf("%d\n", i)
}
nums := []int{1, 2, 3}
for i, num := range nums {
    fmt.Printf("%d => %d\n", i, num)
}
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
    fmt.Printf("%s => %s\n", k, v)
}
for k := range kvs { //只有一個返回值
    fmt.Printf("%s\n", k)
}
// 輸出結(jié)果
// 0 => a
// 1 => b
// 2 => c
// 0
// 1
// 2
// 0 => 1
// 1 => 2
// 2 => 3
// a => apple
// b => banana
// a
// b

for循環(huán)尤其是range語句，在平時開發(fā)過程中頻繁使用，但很多開發(fā)者經(jīng)常會在以下場景中踩坑。

場景一，使用循環(huán)迭代器的變量

先來看一個明顯的錯誤：

func main() {
    var out []*int
    for i := 0; i < 3; i++ {
        // i := i
        out = append(out, &i)
    }
    fmt.Println("值:", *out[0], *out[1], *out[2])
    fmt.Println("地址:", out[0], out[1], out[2])
}
// 輸出結(jié)果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090

分析

out是一個整型指針數(shù)組變量，在for循環(huán)中，聲明了一個i變量，每次循環(huán)將i的地址追加到out切片中，但是每次追加的其實都是i變量，因此我們追加的是一個相同的地址，而該地址最終的值是3。

正確做法

解開代碼中的注釋// i := i，每次循環(huán)時都重新創(chuàng)建一個新的i變量。

注意，for循環(huán)表達(dá)式1定義的變量i相當(dāng)于循環(huán)體里面的全局變量，循環(huán)體里面定義的變量i相當(dāng)于循環(huán)體里面的局部變量，由于在代碼塊中同名局部變量會覆蓋同名的全局變量，所以此時在循環(huán)體邏輯里面，使用的i變量是循環(huán)體里面定義的局部變量i。

再看一個比較隱秘的錯誤：

func main() {
    a1 := []int{1, 2, 3}
    a2 := make([]*int, len(a1))
    for i, v := range a1 {
        a2[i] = &v
    }
    fmt.Println("值:", *a2[0], *a2[1], *a2[2])
    fmt.Println("地址:", a2[0], a2[1], a2[2])
}
// 輸出結(jié)果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090

分析

大多數(shù)人就是在range這里給變量賦值的時候踩坑，因為比較隱秘，其實情況和上面的一樣，range在遍歷值類型時，其中的v是一個局部變量，只會聲明初始化一次，之后每次循環(huán)時重新賦值覆蓋前面的，所以給a2[i]賦值的時候其實都是同一個地址&v，而v最終的值為a1最后一個元素的值，也就是3。

正確做法

①a2[i]賦值時傳遞原始指針，即a2[i] = &a1[i]

②創(chuàng)建臨時變量t := v；a2[i] = &t

③閉包(與②原理一樣)，func(v int) { a2[i] = &v }(v)

更為隱秘的還有：

func main() {
    var out [][]int
    for _, i := range [][1]int{{1}, {2}, {3}} {
        out = append(out, i[:])
    }
    fmt.Println("Values:", out)
}
// 輸出結(jié)果
// [[3] [3] [3]]

原理也是一樣的，不論遍歷多少次，i[:]總是被本次遍歷的值所覆蓋

場景二，在循環(huán)體內(nèi)使用goroutines

func main() {
    values := []int{1, 2, 3}
    wg := sync.WaitGroup{}
    for _, val := range values {
        wg.Add(1)
        go func() {
            fmt.Println(val)
            wg.Done()
        }()
    }
    wg.Wait()
}
// 輸出結(jié)果
// 3
// 3
// 3

分析

對于主協(xié)程來講，循環(huán)是很快就跑完的，而這個時候各個協(xié)程可能才開始跑，此時val的值已經(jīng)遍歷到最后一個了，所以各協(xié)程都輸出了3。（如果遍歷數(shù)據(jù)龐大，主協(xié)程遍歷耗時較久的話，goroutine的輸出會根據(jù)當(dāng)時候的val的值，所以每次的輸出結(jié)果不一定相同的。）

解決辦法

①使用臨時變量

for _, val := range values {
    wg.Add(1)
    val := val
    go func() {
        fmt.Println(val)
        wg.Done()
    }()
}

②使用閉包

for _, val := range values {
    wg.Add(1)
    go func(val int) {
        fmt.Println(val)
        wg.Done()
    }(val)
}

三、實戰(zhàn)

基于第一、第二小節(jié)內(nèi)容，接下來進(jìn)行一個Golang for循環(huán)實戰(zhàn)，代碼詳情請看注釋。

package main
 
import "fmt"
 
func main() {
    slic := []int{1, 2, 3}
    // len(cp) = 3, cap(cp) = 3
    cp := make([]*int, len(slic))
    for i, x := range slic {
        cp[i] = &slic[i]
        cp = append(cp, &x)
    }
 
    // 第一次循環(huán)
    // cp[0] = &slic[0]  *cp[0] = 1
    // 由于len=cap=3,append方法的作用是將元素追加到切片的末尾，即cp(len)位置，此時append便超過切片容量，切片進(jìn)行擴容，將容量擴容2倍（切片容器<1024時，擴容*2）。
    // append后相當(dāng)于 cp[3] = &x  此時x的值為1，len(cp)=4, cap(cp)=6
 
    // 第二次循環(huán)
    // cp[1] = &slic[1]  *cp[1] = 2
    // 再次append相當(dāng)于 cp[4] = &x 此時x的值為2，len(cp)=5, cap(cp)=6
 
    // 第三次循環(huán)
    // cp[2] = &slic[2]  *cp[2] = 3
    // 再次append相當(dāng)于 cp[5] = &x 此時x的值為3，len(cp)=6, cap(cp)=6
 
    // 至此循環(huán)完畢，cp中數(shù)據(jù)為  &slic[0]  &slic[1] &slic[2] &x  &x  &x
 
      println("len==", len(cp), "  cap==", cap(cp))
      for _, x := range cp {
        fmt.Print(*x, " ")
      }
}
 
/*  輸出結(jié)果
    len== 6   cap== 6
    1 2 3 3 3 3
*/

到此這篇關(guān)于Golang中for循環(huán)遍歷避坑指南的文章就介紹到這了,更多相關(guān)Golang for循環(huán)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: