Golang|for

发布时间：2023/10/11

for 循环

循环在所有语句最基础的结构，在Go语言中也不例外，但是在Go语言中，只有一种循环结果，没有 do-while 结构的循环，while 结构的循环被 for {} 代替。
在Go语言中，for循环也因些变的更加的灵活，更加的好用。

跟据条件判断的 for 循环

无初始化

    func main() {
        i := 1
        for i < 5 {
            i++
            fmt.Println("i = ", i)
        }
    }

Go语言中，if 语句，for 语句，switch 语句后面的条件判断都不用加 ( ) ,直接写判断条件就可以，这也是Go语言简单的一点。

没有初始化的意思就是初始化定义在 for 循环外面，并且处境语句也不和条件判断在同一行。

有初始化

    func main() {
        for i := 10; i < 0; i-- {
            fmt.Println("i = ", i)
        }
    }

和无初始化的 for 循环相比，这一种更加的简洁，但是这两种结构也说不出谁好谁坏，都有自己的特定场景，比如无初始化的，它其中的变量 i 就可以在其它地方使用，但是有初始化的这个 for 循环不行，它只能在循环的作用域内使用。

无限循环

    func main() {
        i := 0
        for {
            fmt.Println("i = ", i)
            if i == 10{
                break	// 跳出循环结构
            }
            i++
        }
    }

在使用无限循环时，必须要注意的一点就是，一定要有结束条件，不然在运行的时候，一定会报错。

无限循环就是 for 没有任务条件，直接运行。

嵌套循环

嵌套循环就是在一个 for 循环里面，嵌套别一个 for 循环，最经典的就是冒泡排序了。

    func main() {
        arr := []int{5, 8, 9, 6, 7, 4, 3, 0, 2, 1}
        // 冒泡排序
        for i := 0; i < len(arr)-1; i++ {
            for j := 0; j < len(arr)-i-1; j++ {
                if arr[j] > arr[j+1] {  // 大于号，正序排列，小于号，倒序排例
                    arr[j], arr[j+1] = arr[j+1], arr[j]
                }
            }
        }
        fmt.Println(arr)
    }

for-range

    func main() {
        arr := []int{5, 8, 9, 6, 7, 4, 3, 0, 2, 1}
        for k, v := range arr {
            fmt.Printf("下标为：%d,值为：%d\n", k, v)
        }
        //下标为：0,值为：5
        //下标为：1,值为：8
        //下标为：2,值为：9
        //下标为：3,值为：6
        //下标为：4,值为：7
        //下标为：5,值为：4
        //下标为：6,值为：3
        //下标为：7,值为：0
        //下标为：8,值为：2
        //下标为：9,值为：1
    }

for-range 循环就是一种Go语言的语法糖，它其实和普通的 for 循环一样，就是方便了使用才出现的。

for 循环的控制语句

循环控制语句就是在循环中，控制循环的执行顺序，执行过程。最常用的有两个 break、continue 。

break

break 的作用是跳出本层循环，比如，在嵌套循环中，有两层循环，内层只有一个 break 语句，那么执行后，只会结束一层循环，剩下的继续执行。

    func main() {
        for i := 0; i < 5; i++ {
            for j := 0; j < 5; j++ {
                if j == 3 {
                    break // 跳出本层循环，进入到外层循环
                }
                fmt.Println("j = ", j)
            }
        }
    }

continue

continue 的作用是跳过本次循环，只要遇到 continue 后，它之后的所有语句都不执行了，循环体内直接执行完，执行下一次循环。


    func main() {
        for i := 0; i < 5; i++ {
            if i == 3 {
                continue
            }
            fmt.Println("i = ", i)
        }
        // 结果: 1,2,4
    }

在上面的例子中，当满足 if 条件时，直接跳过执行这一次的打印，直接开始了下一次的打印。

细节决定成败!
个人愚见，如有不对，恳请扶正!