Go 语言循环语句

最新推荐文章于 2024-07-06 12:55:27 发布

知己一语

最新推荐文章于 2024-07-06 12:55:27 发布

阅读量58

点赞数

文章标签： golang xcode 开发语言后端 macos

本文链接：https://blog.csdn.net/weixin_57839131/article/details/132999633

版权

Go 语言循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。

以下为大多编程语言循环程序的流程图：

Go 语言提供了以下几种类型循环处理语句：

循环类型	描述
for 循环	重复执行语句块
循环嵌套	在 for 循环中嵌套一个或多个 for 循环

for 循环

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

语法

Go 语言的 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 := range oldMap {
    newMap[key] = value
}

for 语句语法流程如下图所示：

示例

package main

import "fmt"

/*指定次数循环*/
func main() {
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
	}
}


/*
package main

import "fmt"

/* 效果相同*/
func main() {
	i := 1
	for i <= 10 {
		fmt.Println(i)
		i++
	}
}
*/

//计算1到10的数字之和
package main

import "fmt"

func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
                sum += i
        }
        fmt.Println(sum)
}

//输出结果:
55

/*
//求出1-10的和
package main

import "fmt"

func main() {
	i := 0
	result := 0
	for i <= 10 {
		result += i  //等效于result = result + i
		i++
	}
	fmt.Println(result)
}
*/

init 和 post 参数是可选的，我们可以直接省略它，类似 While 语句。

以下实例在 sum 小于 10 的时候计算 sum 自相加后的值：

package main

import "fmt"

func main() {
        sum := 1
        for ; sum <= 10; {
                sum += sum
        }
        fmt.Println(sum)

        // 这样写也可以，更像 While 语句形式
        for sum <= 10{
                sum += sum
        }
        fmt.Println(sum)
}

//输出结果:
16
16

//类似while做条件循环
package main

import "fmt"

func main() {
	doing := "yes"
	i := 1
	for doing == "yes" {
		fmt.Printf("循环yes第%d次\n", i)
		i++
		//当输出5句时停止输出
		if i > 5 {
			doing = "no"
		}
	}
}


//输出结果:
循环yes第1次
循环yes第2次
循环yes第3次
循环yes第4次
循环yes第5次

//求出0-100的偶数和


//方法一，基于步长
package main

import "fmt"

func main() {
	result := 0、
  //i 从0 开始，每次加2， 则所有的数都是偶数
	for i := 0; i <= 100; i += 2 {
		result += i
	}
  /* 方法二，使用取余为0 
  	for i := 0; i <= 100; {
		if i%2 == 0 {
			result += i
		}
		i++
	}
  */
	fmt.Println(result)
}

//输出结果:
2550

无限循环

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

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}

示例

package main

import (
	"fmt"
	"time"
)

/*无限循环*/
func main() {
	i := 0
	//for 后面表达式什么都不写，默认是true
	for  {
		fmt.Println(i)
		i++
		time.Sleep(time.Second)
	}
}

//无限循环
package main

import "fmt"

func main() {
        sum := 0
        for {
            sum++ // 无限循环下去
        }
        fmt.Println(sum) // 无法输出
}

要停止无限循环，可以在命令窗口按下ctrl-c 。

For-each range 循环

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

package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

//输出结果:
0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

//使用循环和 range 获取列表的下标及列表元素
package main

import (
	"fmt"
)

/*range使用*/
func main() {
	//定义数组
	numbers := []int{10, 20, 30, 40, 50}
	// a 为数组下标， b 为元素值.
	for a, b := range numbers {
		fmt.Println("key:", a, "values:", b)
	}
	fmt.Println("-----")
	//如果只想要元素值，可以使用空白标识符_
	for _, b := range numbers {
		fmt.Println("values:", b)
	}
	fmt.Println("-----")
	//当定义8个长度的数组，但是只有5个数字时,以数据默认值填充(int默认值0)
	numbers2 := [8]int{10, 20, 30, 40, 50}
	for x, y := range numbers2 {
		fmt.Println("key:", x, "values:", y)
	}
}


//输出结果:
key: 0 values: 10
key: 1 values: 20
key: 2 values: 30
key: 3 values: 40
key: 4 values: 50
-----
values: 10
values: 20
values: 30
values: 40
values: 50
-----
key: 0 values: 10
key: 1 values: 20
key: 2 values: 30
key: 3 values: 40
key: 4 values: 50
key: 5 values: 0
key: 6 values: 0
key: 7 values: 0

Go 语言循环嵌套

Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。

语法

以下为 Go 语言嵌套循环的格式：

for [condition | ( init; condition; increment ) | Range]
{
  for [condition | ( init; condition; increment ) | Range]
  {
   statement(s);
  }
  statement(s);
}

//获取2-100的素数，素数个数，素数和
//获得100以内素数的和，素数就是除了1和其本身，没有其他的因数
// 将要确认的数，从2开始取余，直到取余到其前面一个数，都没有值为0，这就说明都除不尽，这个数就是素数

package main

import "fmt"

func main() {
	//定义两个变量，num 用来计算素数个数，sum用来计算素数的和
	num, sum := 0, 0
	// 控制第一个数(被除数),从2 -100
	for i := 2; i <= 100; i++ {
		//定义一个变量，初始值为0.如果被除数没有其他因数，则此变量值为0.被除数每有一个其他的因数，则此变量值+1
		result := 0
		//内层循环控制除数。从2开始，一直到被除数前面一位
		for j := 2; j <= i-1; j++ {
			//如果取余值为0，则说明被除数有其他因数。每有一个其他因数，则将变量result的值+1
			if i%j == 0 {
				result++
			}
		}
		//当result 值为0，说明该数没有其他因数，是素数。
		if result == 0 {
			sum += i //等效于sum = sum +i
			num++    // 等效于num = num +1
			fmt.Printf("%d是素数\n", i)
		}
	}
	fmt.Printf("素数一共有:%d个\n素数和为:%d\n", num, sum)
}

//输出结果:
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是素数
素数一共有:25个
素数和为:1060

//使用循环嵌套输出2到100间的素数
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);
      }
   }  
}

//输出结果:
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  是素数

//打印 九九乘法表

package main

import "fmt"

func main() {
	// 外层循环决定行，控制一个乘数,从1 到 9 ,每次外层循环，乘数加1
	for i := 1; i <= 9; i++ {
		//内层循环决定列，控制另一个乘数。每次循环，外层循环控制的乘数不变，内层循环控制乘数改变，从1开始，最大到外层循环控制的乘数为止
		for j := 1; j <= i; j++ {

			fmt.Printf("%d*%d=%d  ", j, i, i*j)
		}
		//每次外层循环完毕，进行换行
		fmt.Println("")
	}
}

循环控制语句

循环控制语句可以控制循环体内语句的执行过程。

GO 语言支持以下几种循环控制语句：

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

Go 语言 break 语句

Go 语言中 break 语句用于以下两方面：

用于循环语句中跳出循环，并开始执行循环之后的语句。
break 在 switch(开关语句)中在执行一条 case 后跳出语句的作用。
在多重循环中，可以用标号 label 标出想 break 的循环。

语法

break 语法格式如下：

break;

break 语句流程图如下：

//在变量 a 大于15 的时候，跳出循环
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* for 循环 */
   for a < 20 {
      fmt.Printf("a 的值为 : %d\n", a);
      a++;
      if a > 15 {
         /* 使用 break 语句跳出循环 */
         break;
      }
   }
}

//输出结果:
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15

package main

import "fmt"

func main() {
	var number int = 10
	for number < 20 {
		fmt.Println(number)
		number++
		if number > 15 {
			break
			fmt.Println("1if语句")
		}
		fmt.Println("2循环体内语句")
	}
	fmt.Println("3循环体外语句")
}

//输出结果:
10
2循环体内语句
11
2循环体内语句
12
2循环体内语句
13
2循环体内语句
14
2循环体内语句
15
3循环体外语句

//演示多种循环，使用标记和不使用标记的区别
package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- break ----")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                        fmt.Printf("i2: %d\n", i2)
                        break
                }
        }

    // 使用标记
    fmt.Println("---- break label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                break re  //直接就退出了最外层，就类似于shell 的break2，跳出多层循环
            }
        }
}

//标签效果等效于doing开关
/*
package main

import "fmt"

//break-标记
func main() {
	fmt.Println("最外层循环开始")
	doing := false //跳出外层循环开关
	for i := 1; i <= 5; i++ {
		fmt.Println("外层:", i)
		for j := 10; j < 20; j++ {
			fmt.Println("内层", j)
			if j > 15 {
				doing = true
				break
			}
		}
		//满足条件，退出外层循环
		if doing {
			break //退出外层循环
		}
	}
	fmt.Println("外层循环结束")
}

*/

//输出结果:
---- break ----
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
---- break label ----
i: 1
i2: 11

Go 语言 continue 语句

Go 语言的 continue 语句有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

continue 结束本次循环，进入下一次循环

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

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

语法

continue 语法格式如下：

continue;

continue 语句流程图如下：

//在变量a 等于15的时候跳过本次循环，执行下一次循环
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* for 循环 */
   for a < 20 {
      if a == 15 {
         /* 跳过此次循环 */
         a = a + 1;
         continue;
      }
      fmt.Printf("a 的值为 : %d\n", a);
      a++;    
   }  
}

//输出结果:
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

//演示使用标记和不使用标记的区别
package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }
}

//输出结果:
---- continue ---- 
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
---- continue label ----
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11

Go 语言 goto 语句

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

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

但是，在成程序流程的混乱，使理解和调试程序都产生困难。

语法

goto 语法格式如下：

goto label;
..
.
label: statement;

goto 语句流程图如下：

package main

import "fmt"

func main() {
	i := 0
HERE:
	fmt.Println(i)
	i++
	if i == 5 {
    //return作为程序出口，避免死循环
		return
	}
	goto HERE
}

//输出结果:
0
1
2
3
4

//在变量啊等于15 时跳过本次循环，并回到循环的开始语句Loop 处
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++    
   }  
}

//输出结果:
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

//打印九九乘法表
package main 

import "fmt"

func main() {
    //print9x()
    gotoTag()
}

//嵌套for循环打印九九乘法表
func print9x() {
    for m := 1; m < 10; m++ {
        for n := 1; n <= m; n++ {
      fmt.Printf("%dx%d=%d ",n,m,m*n)
        }
        fmt.Println("")
    }
}

//for循环配合goto打印九九乘法表
func gotoTag() {
    for m := 1; m < 10; m++ {
    n := 1
    LOOP: if n <= m {
        fmt.Printf("%dx%d=%d ",n,m,m*n)
        n++
        goto LOOP
    } else {
        fmt.Println("")
    }
    n++
    }
}

知己一语

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go 语言循环语句

Go 语言循环语句在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。以下为大多编程语言循环程序的流程图：Go 语言提供了以下几种类型循环处理语句：循环类型描述for 循环重复执行语句块循环嵌套在 for 循环中嵌套一个或多个 for 循环for 循环for 循环是一个循环控制结构，可以执行指定次数的循环。语法Go...
复制链接

扫一扫