Go 循环语句

简介: 一、概述二、Go 语言 for 循环三、循环嵌套四、break 语句五、 continue 语句六、goto 语句

一、概述


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

循环程序的流程图:

 

2387990-20220318221402618-1222232812.png


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


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


1. 循环控制语句


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


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


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


2. 无限循环


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

示例

package main
import (
 "fmt"
 "time"
)
func main() {
 i := 0
 for true {   //for后面true为可选,若不加,默认为true
  fmt.Printf("i: %v\n", i)
  i++
  time.Sleep(time.Second)
 }
}

//输出结果如下

i: 0

i: 1

i: 2

i: 3

i: 4

i: 5

i: 6

i: 7

....

....

....

 

二、Go 语言 for 循环



1. 语法


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

语法:

//Go 语言的 For 循环有 3 种形式,只有其中的一种使用分号

//和 C 语言的 for 一样:

for init; condition; post { }



//和 C 的 while 一样:

for condition { }



//和 C 的 for(;;) 一样:

for { }

  • init: 一般为赋值表达式,给控制变量赋初值
  • condition: 关系表达式或逻辑表达式,循环控制条件
  • post:一般为赋值表达式,给控制变量增量或减量。

 

2. for语句执行过程


① 先对表达式 1 赋初值;

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

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

格式如下:

for key, value := range oldMap {

   newMap[key] = value

}

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


2387773-20220320212843886-1018491603.png


3. 示例


计算 1 到 10 的数字之和

package main
import "fmt"
func main() {
 sum := 0
 for i := 0; i <= 10; i++ {
  sum += i
 }
 fmt.Printf("sum: %v\n", sum)
}


//输出结果为:

55


//int 和 post 参数是可选的,我们可以直接省略他,类型while语句
package main
import "fmt"
func main() {
 sum := 0
 i := 1
 for i <= 10 {
  sum += i
  i++
 }
 fmt.Printf("sum: %v\n", sum)
}
计算0-100间偶数的和
//求出0-100的偶数和
package main
import "fmt"
func main() {
 a := 0
 for i := 1; i <= 100; i++ {
  if i%2 == 0 {
   a += i
  }
 }
 fmt.Printf("a: %v\n", a)
}


//输出结果如下

2550



//方法二
package main
import "fmt"
func main() {
 sum := 0
 for i := 0; i <= 100; i += 2 {
  sum += i
 }
 fmt.Printf("sum: %v\n", sum)
}


4. For-each range 循环


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

示例

//循环数组
package main
import "fmt"
func main() {
 names := []int{20, 30, 40, 50, 60}
 //a获取key,b获取value
 for a, b := range names {
  fmt.Print("key:", a, "  value:", b, "\n")
 }
}

//输出结果如下

key:0  value:20

key:1  value:30

key:2  value:40

key:3  value:50

key:4  value:60



//使用空白标识符直接获取value
package main
import "fmt"
func main() {
 names := []int{20, 30, 40, 50, 60}
 //a获取key,b获取value
 for _, b := range names {
  fmt.Print("value:", b, "\n")
 }
}

//输出结果

value:20

value:30

value:40

value:50

value:60



 

 

三、循环嵌套



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


1. 语法


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

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


2. 示例


以下实例使用循环嵌套来输出 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



四、break 语句


1. 语法


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

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

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

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

break 语法格式如下:

break;



流程如图:

2387773-20220322213353147-374185608.png


2. 示例


  • 在变量 a 大于 15 的时候跳出循环:
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

 

五、 continue 语句


1. 语法


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

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

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

continue 语法格式如下:

continue;



continue 语句流程图如下:

2387773-20220322213522114-937439464.png

2. 示例


  • 在变量 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



 

六、goto 语句


1. 语法


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

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

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

goto 语法格式如下:

goto label;

..

.

label: statement;



goto 语句流程图如下:


2387773-20220322213634581-734403409.png


2. 示例


  • 在变量 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++
 }
}

 

相关文章
|
1月前
|
Go
Go 1.22 for 循环的两处重要更新
本文介绍了 Go 1.22 版本对 for 循环所做的两处重要更新:循环的每次迭代都会创建新变量 和 循环支持对整数范围进行迭代。 - 循环的每次迭代都会创建新变量,有效避免了以往版本中常见的闭包陷阱,提高了代码的安全性和可预测性。 - 循环支持对整数范围进行迭代,极大地增强了 for 循环的灵活性,使得编写计数循环更加直接和简洁。
70 1
Go 1.22 for 循环的两处重要更新
|
1月前
|
JSON JavaScript Go
Go 语言学习指南:变量、循环、函数、数据类型、Web 框架等全面解析
掌握 Go 语言的常见概念,如变量、循环、条件语句、函数、数据类型等等。深入了解 Go 基础知识的好起点是查阅 Go 官方文档
686 2
|
8月前
|
安全 Go 索引
Go切片循环就用range 有这一篇就够了
Go切片循环就用range 有这一篇就够了
151 0
|
2天前
|
Go
go循环语句
go循环语句
5 0
|
29天前
|
Go
Go 语言循环语句
Go 语言循环语句
18 0
|
1月前
|
Go 开发者
Golang深入浅出之-Go语言流程控制:if、switch、for循环详解
【4月更文挑战第21天】本文介绍了Go语言中的流程控制语句,包括`if`、`switch`和`for`循环。`if`语句支持简洁的语法和初始化语句,但需注意比较运算符的使用。`switch`语句提供多分支匹配,可省略`break`,同时支持不带表达式的形式。`for`循环有多种形式,如基本循环和`for-range`遍历,遍历时修改原集合可能导致未定义行为。理解并避免易错点能提高代码质量和稳定性。通过实践代码示例,可以更好地掌握Go语言的流程控制。
25 3
Golang深入浅出之-Go语言流程控制:if、switch、for循环详解
|
1月前
|
程序员 Go API
【Go语言快速上手(二)】 分支与循环&函数讲解
【Go语言快速上手(二)】 分支与循环&函数讲解
|
1月前
|
Go C语言 索引
掌握Go语言:探索Go语言中的循环奇妙世界,从基础到实战(13)
掌握Go语言:探索Go语言中的循环奇妙世界,从基础到实战(13)
|
1月前
|
Go 开发者 索引
Go语言中的循环控制结构解析
【2月更文挑战第3天】本文将详细探讨Go语言中的循环控制结构,包括`for`循环、`range`循环以及`无限循环`的使用方法和适用场景。通过掌握这些循环结构,Go语言开发者能够更加高效地进行迭代操作、处理集合数据以及实现复杂的控制逻辑。
|
1月前
|
编译器 Go
go语言第二章循环结构(for循环)
go语言第二章循环结构(for循环)
34 0