一、for迴圈
迴圈:讓程式多次執行相同的程式碼塊
for迴圈是Go語言中唯一一個迴圈結構
for迴圈經典語法
先執行表示式1
執行表示式2判斷是否成立,如果成立執行迴圈體
迴圈體執行完成後,執行表示式3
再次執行表示式2,判斷是否成立.
for迴圈用的最多的地方就是遍歷陣列或切片等
for 表示式1;表示式2;表示式3{
//迴圈體
}
經典for迴圈結構中 , for關鍵字後面有三個表示式,且每個表示式都可以省略。
for i := 0; i < 5; i++ {
fmt.Println(i)
}
//等價於
j := 0
for ; j < 5; {
fmt.Println(j)
j++
}
for關鍵字後面也可以只有一個表示式,表示如果條件成立執行迴圈體程式碼。
for i := 0; i < 5; i++ {
fmt.Println(i)
}
//等價於
j := 0
for j < 5 {
fmt.Println(j)
j++
}
二、range語句
Golang range類似迭代器操作，可以對 slice、map、陣列、字串等進行迭代迴圈。在字串、陣列和切片中它返回 (索引, 值) ，在map中返回 (鍵, 值)，但若當只有一個返回值時，第一個引數是索引或鍵。
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)
}
// 輸出結果
// 0 => a
// 1 => b
// 2 => c
// 0
// 1
// 2
// 0 => 1
// 1 => 2
// 2 => 3
// a => apple
// b => banana
// a
// b
for迴圈尤其是range語句，在平時開發過程中頻繁使用，但很多開發者經常會在以下場景中踩坑。
場景一，使用迴圈迭代器的變數
先來看一個明顯的錯誤：
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])
}
// 輸出結果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090
分析
out是一個整型指標陣列變數，在for迴圈中，宣告瞭一個i變數，每次迴圈將i的地址追加到out切片中，但是每次追加的其實都是i變數，因此我們追加的是一個相同的地址，而該地址最終的值是3。
正確做法
解開程式碼中的註釋// i := i，每次迴圈時都重新建立一個新的i變數。
注意，for迴圈表示式1定義的變數i相當於迴圈體裡面的全域性變數，迴圈體裡面定義的變數i相當於迴圈體裡面的區域性變數，由於在程式碼塊中同名區域性變數會覆蓋同名的全域性變數，所以此時在迴圈體邏輯裡面，使用的i變數是迴圈體裡面定義的區域性變數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])
}
// 輸出結果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090
分析
大多數人就是在range這裡給變數賦值的時候踩坑，因為比較隱秘，其實情況和上面的一樣，range在遍歷值型別時，其中的v是一個區域性變數，只會宣告初始化一次，之後每次迴圈時重新賦值覆蓋前面的，所以給a2[i]賦值的時候其實都是同一個地址&v，而v最終的值為a1最後一個元素的值，也就是3。
正確做法
①a2[i]賦值時傳遞原始指標，即a2[i] = &a1[i]
②建立臨時變數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)
}
// 輸出結果
// [[3] [3] [3]]
原理也是一樣的，不論遍歷多少次，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()
}
// 輸出結果
// 3
// 3
// 3
分析
對於主協程來講，迴圈是很快就跑完的，而這個時候各個協程可能才開始跑，此時val的值已經遍歷到最後一個了，所以各協程都輸出了3。（如果遍歷資料龐大，主協程遍歷耗時較久的話，goroutine的輸出會根據當時候的val的值，所以每次的輸出結果不一定相同的。）
解決辦法
①使用臨時變數
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)
}
三、實戰
基於第一、第二小節內容，接下來進行一個Golang for迴圈實戰，程式碼詳情請看註釋。
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)
}
// 第一次迴圈
// cp[0] = &slic[0] *cp[0] = 1
// 由於len=cap=3,append方法的作用是將元素追加到切片的末尾，即cp(len)位置，此時append便超過切片容量，切片進行擴容，將容量擴容2倍（切片容器<1024時，擴容*2）。
// append後相當於 cp[3] = &x 此時x的值為1，len(cp)=4, cap(cp)=6
// 第二次迴圈
// cp[1] = &slic[1] *cp[1] = 2
// 再次append相當於 cp[4] = &x 此時x的值為2，len(cp)=5, cap(cp)=6
// 第三次迴圈
// cp[2] = &slic[2] *cp[2] = 3
// 再次append相當於 cp[5] = &x 此時x的值為3，len(cp)=6, cap(cp)=6
// 至此迴圈完畢，cp中資料為 &slic[0] &slic[1] &slic[2] &x &x &x
println("len==", len(cp), " cap==", cap(cp))
for _, x := range cp {
fmt.Print(*x, " ")
}
}
/* 輸出結果
len== 6 cap== 6
1 2 3 3 3 3
*/
參考：https://www.cnblogs.com/cheyunhua/p/15770777.html
參考：https://blog.csdn.net/qq_27870421/article/details/118485883