zoukankan      html  css  js  c++  java
  • go循环遍历小坑

    for语句

    1. for 赋值表达式; 关系表达式或逻辑表达式; 赋值表达式 { }
    for i := 0; i < 10; i++ {
    }
    
    1. for 关系表达式或逻辑表达式 { }
    n := 10
    for n > 0 {
        n--
    }
    
    1. for { }
    for {
    	fmt.Println("hello world")
    }
    // 等价于
    // for true {
    // 	fmt.Println("hello world")
    // }
    

    range语句

    Golang range类似迭代器操作,可以对 slice、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变量。


    再看一个比较隐秘的错误:

    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。

    正确做法

    package main

    import "fmt"

    func main() {
    slic:= []int{1,2,3}
    cp:=make([]*int,len(slic))
    for i,x:=range slic {
    cp[i]=&slic[i]
    cp=append(cp, &x)


    }
    fmt.Println(*cp[1])


    }

    a2[i]赋值时传递原始指针,即a2[i] = &a1[i]
    ②创建临时变量t := va2[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)
    }
  • 相关阅读:
    CF1066D Boxes Packing
    luogu P2508 [HAOI2008]圆上的整点
    luogu P2502 [HAOI2006]旅行
    luogu P2511 [HAOI2008]木棍分割
    luogu P4161 [SCOI2009]游戏
    luogu P4160 [SCOI2009]生日快乐
    windows2012系统IE浏览器无法打开加载flashplayer内容
    kvm虚拟机相关
    esxI开启虚拟化
    Termux 详细安装
  • 原文地址:https://www.cnblogs.com/cheyunhua/p/15770777.html
Copyright © 2011-2022 走看看