GO 循环语句

最新推荐文章于 2023-11-07 16:02:07 发布

Zlwriii

最新推荐文章于 2023-11-07 16:02:07 发布

阅读量891

点赞数

文章标签： golang 开发语言

本文链接：https://blog.csdn.net/m0_59439550/article/details/123609249

版权

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

流程如下：

以下几种类型循环处理语句：

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

循环控制语句

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

以下几种控制语句：

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

1、for 循环

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

for 后面表达式如果不写，默认是true。

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

##第一种方式
package main

import "fmt"

func main() {

	for i := 1; i <= 5; i++ {
		fmt.Println(i)
	}
}

//输出结果为：
1
2
3
4
5

##第二种方式
package main

import "fmt"

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

//输出结果为：
1
2
3
4
5

##第三种方式
package main

import "fmt"

//类似while做条件循环
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次

2、循环嵌套

Go 语言允许用户在循环内使用循环。

语法格式

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

使用循环嵌套来输出 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  是素数

打印99乘法表：

package main

import "fmt"

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

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

3、break 语句

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

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

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

流程如下图

示例：

package main

import "fmt"

func main() {
	var a int = 10
	for a < 20 {
		fmt.Printf("a: %v\n", a)
		a++
		if a > 15 {
			break
		}
	}
}

//执行结果为：
a: 10
a: 11
a: 12
a: 13
a: 14
a: 15

使用标记和不使用标记的区别：

package main

import "fmt"

func main() {
	//不适用标记
	fmt.Println("----break----")
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %v\n", i)
		for a := 11; a <= 13; a++ {
			fmt.Printf("a: %v\n", a)
			break
		}
	}
	//使用标记
	fmt.Println("----break label----")
fla:
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %v\n", i)
		for a := 11; a <= 13; a++ {
			fmt.Printf("a: %v\n", a)
			break fla
		}
	}
}
  
//输出结果为：
----break----
i: 1
a: 11
i: 2
a: 11
i: 3
a: 11
----break label----
i: 1
a: 11

4、continue 语句

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

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

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

流程如下图

示例：

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

package main

import "fmt"

func main() {
	var a int = 10
	for a < 20 {
		if a == 15 {
			a = a + 1
			continue
		}
		fmt.Printf("a: %v\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 a := 11; a <= 13; a++ {
			fmt.Printf("a: %d\n", a)
			continue
		}
	}

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

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

5、goto 语句

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

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

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

语法格式

goto label;
..
.
label: statement;

goto流程图

在这里插入图片描述

示例：

在变量 a 等于 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

goto 语句打印九九乘法表

package main

import "fmt"

//for循环配合goto打印九九乘法表
func main() {
	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++
	}
}

//输出结果为：
1x1=1 
1x2=2 2x2=4 
1x3=3 2x3=6 3x3=9 
1x4=4 2x4=8 3x4=12 4x4=16 
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

Zlwriii

关注

0
点赞
踩
0

收藏

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

目录1、for 循环2、循环嵌套3、break 语句4、continue 语句5、goto 语句在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。流程如下：以下几种类型循环处理语句：循环类型描述 [for 循环] 重复执行语句块 [循环嵌套] 在 for 循环中嵌套一个或多个 for 循环循环控制语句循环控制语句可以控制循环体内语句的执行过程。以下几种控制语句：控制语句描述 [
复制链接

扫一扫