人生苦短我使用GO——GO循环（经典练习题）

控制语句	描述
[break语句]	经常用于中断当前for循环或跳出switch语句
[continue语句]	前循环的剩余语句然后继续进行下一轮循环
[goto语句]	将控制转移到被标记的语句

无限循环

如果循环中条件语句永远不为false则会进行无限循环，可以通过 for循环语句中只设置一个条件表达式来执行无限循环:

例如：

package main

import(

	"fmt"
	"time"
)
func main() {

    i : = 0

    for true{

        fmt . Printf("%d\n"， i)
    i++

        time.sleep(time . Second)

for循环

for循环是一个循环控制结构，可以执行指定次数的循环。

for 循环有3种形式，只有其中的一种使用分号。

和C语言的for一样:

        for init; condition; post {}

和C的while一样:

for condition { }

和C的 for(;;)一样;

for { }

init:一般为赋值表达式，给控制变量赋初值; ·

condition:关系表达式或逻辑表达式，循环控制条件;

post:一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下: ·

1、先对表达式1赋初值; ·

2、判别赋值表达式init是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行post，进入第二次循环，再判别condition;否则判断condition的值为假，不满足条件，就终止for循环，执行循环体外语句。

for循环的range格式可以对slice、map、数组、字符串等进行迭代循环。

格式如下:

for key, value := rangeoldMap {

    nevMlap[key] = value
}

流程如下

示例：

package main

import "fmt"

func main() {
    num := [8]int{10, 20, 30, 40, 50}

    for a, b := range num {

        fmt.Print("key的值为", a, "   value的值为", b, "\n")
    }
}

运行结果

key的值为0   value的值为10
key的值为1   value的值为20
key的值为2   value的值为30
key的值为3   value的值为40
key的值为4   value的值为50
key的值为5   value的值为0
key的值为6   value的值为0
key的值为7   value的值为0

练习，求1-10得和

package main

import "fmt"

//一到10的和
func main() {

    b := 0
    for i := 0; i <= 10; i++ {
        b += i

    }
    fmt.Printf("1加到10的值为%d", b)
}



运行结果

1加到10得值为 55

For-each range循环

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

示例:

package main

import "fmt"

func main(){
//定义字符串类型数组

    names := []string{ "zhangsan", "lisi", "wangwu", "zhaoliu"}
                      
// a获取key b获取value

     for a, b := range names {
                fmt.Println(a,b)          
      }
}

结果
0 zhangsan
1 lisi
2 wangwu
3 zhaoliu

for循环嵌套

练习1：输出2-100之间的质数

方法一

package main

import (
	"fmt"
)

func main() {
	fmt.Println("1-100之间的质数为:")
	// i应直接从2开始
	for i := 2; i <= 100; i++ {
		for n := 2; n <= i; n++ {
			// 当走到最后n等于i 了，则说明下面的i%n==0始终没有成立。说是这个数是个质数。
			if n >= i {
				fmt.Printf(" %d", i)
			}
			// 当满足这个条件的时候就终止里面的循环，不用继续往下走了,因为它已经不是一个质数了。
			if i%n == 0 {
				break
			}
		}

	}

}

方法二（减少资源，因为只遍历一半即可）：

package main
import "fmt"

func main(){
/*定义局部变量*/

    var i, j int

    for i = 2; i< 100; i++ {

        for j = 2; j<=(i / j);j++ {

            if i%j==0{

                break// 如果发现因子，则不是素数}
}

            if j>(i/j){

                fmt.Printf("%d是素数\n", i)}

        }
}

输出结果都是

1-100之间的质数为:
 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

练习2：输出九九乘法表

package main

import "fmt"

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


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

break语句

break语句用于以下两方面: ·

用于循环语句中跳出循环，并开始执行循环之后的语句。

break在switch(开关语句)中在执行一条case后跳出语句的作用。

在多重循环中，可以用标号label标出想 break的循环。

流程图

示例大于15跳出循环

package main

import "fmt"
func main() {
    
    var number int =10

    for number < 20{

        fmt.Println(number)
        
        number++

        if number > 15 {

            fmt.Println("1:if语句")
            break

            
        }
    
        fmt.Println( "2:循环体内语句")
    }

    fmt.Println( "3:循环体外语句")
}

运行结果

10
2:循环体内语句
11
2:循环体内语句
12
2:循环体内语句
13
2:循环体内语句
14
2:循环体内语句
15
1:if语句
3:循环体外语句

break标记使用

package main

import "fmt"

func main() {
    fmt.Println("循环开始")
abc:
    for i := 1; i <= 5; i++ {
        fmt.Println("外层循环", i)
        for j := 10; j <= 20; j++ {
            fmt.Println("内层循环", j)
            if j > 15 {
                break abc

            }

        }

    }
    fmt.Println("循环结束")

}

运行结果

循环开始
外层循环 1
内层循环 10
内层循环 11
内层循环 12
内层循环 13
内层循环 14
内层循环 15
内层循环 16
循环结束

continue语句

continue不是跳出循环,而是跳过当前循环执行下一次循环语句。

for循环中，执行continue语句会触发for增量语句的执行。

在多重循环中，可以用标号label标出想 continue的循环。

流程图:

示例

package main
import "fmt"
func main( {
/*定义局部变量*/
    
    var a int = 10
/* for循环*/
    for a < 20 {

        if a == 13{
/*跳过此次循环*/
            a = a +1

            continue
}

        fmt. Printf("a的值为: %d\n", a)

        a++
)

运行结果

a的值为10
a的值为11
a的值为12
a的值为14
a的值为15
a的值为16
a的值为17
a的值为18
a的值为19

continue 标签

package main
import "fmt"
/*continue使用标记*/
func main() {

    fmt.Println("外层循环开始")
abc:

    for i :=1;i<= 5; i++ {

        fmt.Println("外层:",i) 
        for j := 10; j <20;j++ {

            fmt.Println("内层:",j)
            if j >15 {

                continue abc

            }

        }

    }
    fmt.Println("外层循环结束")
}

运行结果

外层循环开始
外层: 1
内层: 10
内层: 11
内层: 12
内层: 13
内层: 14
内层: 15
内层: 16
外层: 2
内层: 10
内层: 11
内层: 12
内层: 13
内层: 14
内层: 15
内层: 16
外层: 3
内层: 10
内层: 11
内层: 12
内层: 13
内层: 14
内层: 15
内层: 16
外层: 4
内层: 10
内层: 11
内层: 12
内层: 13
内层: 14
内层: 15
内层: 16
外层: 5
内层: 10
内层: 11
内层: 12
内层: 13
内层: 14
内层: 15
内层: 16
外层循环结束

goto语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。

流程图

//当不满足条件的时候标签会被透明无视，直接输出

package main

import "fmt"

/*标签在goto语句之前实现类似循环操作*/
/*标签在goto语句之后实现跳过语句步骤执行*/

func main() {
    i := 0

    fmt.Println(i)

    i++

    if i == 5 {
        goto HERE
    }

    fmt.Println("语句1")
    fmt.Println("语句2")

HERE:

    fmt.Println("语句3")
}

运行结果

0
语句1
语句2
语句3

当满足条件，就直接跳到标签处

package main

import "fmt"

/*标签在goto语句之前实现类似循环操作*/
/*标签在goto语句之后实现跳过语句步骤执行*/

func main() {
    i := 4

    fmt.Println(i)

    i++

    if i == 5 {
        goto HERE
    }

    fmt.Println("语句1")
    fmt.Println("语句2")

HERE:

    fmt.Println("语句3")
}

输出结果