go_循环语句

循环关键字

标识符	含义
for	一般循环
break	跳出当前循环
continue	跳过此次循环进入下一次循环
goto	使用位置变化达成循环

一般循环的三种形式

for i := 0; i < 10; i++ {
    循环体
}

1. 循环的次数是 n，而循环结束以后，i 的值是 n；
2. 循环的控制变量i是选择从0开始，还是从1开始是判断 i<n 还是 i<=n，对循环的次数，循环结束后变量的值都有影响；
3. 使用分号分隔，无括号。

for i := 0; i < 10; i++ {
    fmt.Printf("我执行了%d次\n", i)
}

for a < 10 {
    循环体
}

for 条件表达式 ，条件成立时执行循环体

num := 0
for num < 10 {
    num++
    fmt.Printf("我在执行第%d次\n", num)
}

for {
    循环体
}

无限循环

j := 0
for {
    j++
    fmt.Printf("执行%d次\n", j)
    if j == 10 {
        break
    }
}

嵌套循环

package main

import "fmt"

func main() {
    for i := 1; i < 10; i++ {
    	for j := 1; j <= i; j++ {
    		fmt.Printf("%d x %d = %d", j, i, i*j)
    		if i*j > 9 {
    			fmt.Printf(" ")
    		} else {
    			fmt.Printf("  ")
    		}
    	}
    	fmt.Println("")
    }
}

1 x 1 = 1  
1 x 2 = 2  2 x 2 = 4  
1 x 3 = 3  2 x 3 = 6  3 x 3 = 9  
1 x 4 = 4  2 x 4 = 8  3 x 4 = 12 4 x 4 = 16 
1 x 5 = 5  2 x 5 = 10 3 x 5 = 15 4 x 5 = 20 5 x 5 = 25 
1 x 6 = 6  2 x 6 = 12 3 x 6 = 18 4 x 6 = 24 5 x 6 = 30 6 x 6 = 36 
1 x 7 = 7  2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 
1 x 8 = 8  2 x 8 = 16 3 x 8 = 24 4 x 8 = 32 5 x 8 = 40 6 x 8 = 48 7 x 8 = 56 8 x 8 = 64 
1 x 9 = 9  2 x 9 = 18 3 x 9 = 27 4 x 9 = 36 5 x 9 = 45 6 x 9 = 54 7 x 9 = 63 8 x 9 = 72 9 x 9 = 81

break 标签

package main

import "fmt"

func main() {
    var i, j, k int
	loop0:
    for i = 1; i < 10; i++ {
    	loop1:
    	for j = 10; j < 20; j++ {
    		for k = 20; k < 30; k++ {
    			if i == 5 {
                    break loop1
                }
                if j == 15 {
                    break loop0
                }
                if k == 25 {
                    break
                }
    		}
    	}
    }
    fmt.Printf("i=%d, j=%d, k=%d\n", i, j, k) 		
}

i=1, j=10, k=25

1. 标签格式：变量名 + :
2. 标签命名后就一定要使用
3. break只能跳出最近的循环，添加标签则可以跳出标记的循环

循环的其他形式

for-range

range是Golang提供的一种迭代遍历手段，可操作的类型有数组、切片、字符串、Map、channel等，实际使用频率非常高。
这些数据类型在后续会讲到。

for 值1, 值2 := range 变量 {
   ...
}

for 值1 := range 变量 {
   ...
}

for range 变量 {
   ...
}

1. 不同数据类型值1， 值2不同，值2是具体的数值，值1是标记，有索引的值1为索引，有键值的值1就是键值；
2. 值2可以不取，只取值1；
3. 取值2不取值1，可用 “_” 代替，省去取变量的名字；
4. 值1、值2都不取，则只表示循环次数，数据中包含几个数就循环几次。

package main

import "fmt"

func main() {
    s := "hello"
    for index, value := range s {
        // fmt.Println(index, string(value))
        fmt.Printf("index=%d, value=%c\n", index, value)
    }
    // 只取值1
    for index := range s {
        fmt.Printf("index=%d\n", index)
    }
    // 想使用值2,值1则使用默认的_存值，表示无用的变量(其实是有值的)
    for _, value := range s {
        fmt.Printf("value=%c\n", value)
    }
    // 只借用循环次数
    i := 0
    for range s {
        i++
        fmt.Printf("我循环了 %d 次\n", i)
    }
}

index=0, value=h
index=1, value=e
index=2, value=l
index=3, value=l
index=4, value=o
index=0
index=1
index=2
index=3
index=4
value=h
value=e
value=l
value=l
value=o
我循环了 1 次
我循环了 2 次
我循环了 3 次
我循环了 4 次
我循环了 5 次

goto

goto 需要搭配标签使用，表示可跳转到标签处，打破代码从上往下执行的顺序，破坏代码的结构性，不建议使用

package main

import "fmt"

func main() {
    var i int = 0
    loop:
    i++
    fmt.Println("我是i， i=", i)
    if i < 5 {
        goto loop
    }
    fmt.Println("终于执行我啦。。。")
}

我是i， i= 1
我是i， i= 2
我是i， i= 3
我是i， i= 4
我是i， i= 5
终于执行我啦。。。