Go语言中循环语句使用的示例详解

目录
  • 一、概述
    • 1. 循环控制语句
    • 2. 无限循环
  • 二、Go 语言 for 循环
    • 1. 语法
    • 2. for语句执行过程
    • 3. 示例
    • 4. For-each range 循环
  • 三、循环嵌套
    • 1. 语法
    • 2. 示例
  • 四、break 语句
    • 1. 语法
    • 2. 示例
  • 五、 continue 语句
    • 1. 语法
    • 2. 示例
  • 六、goto 语句
    • 1. 语法
    • 2. 示例

一、概述

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

循环程序的流程图:

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 语句语法流程如下图所示:

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;  

流程如图:

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 语句流程图如下:

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 语句流程图如下:

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++
    }
}

到此这篇关于Go语言中循环语句使用的示例详解的文章就介绍到这了,更多相关Go语言循环语句内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Go语言模拟while语句实现无限循环的方法

    本文实例讲述了Go语言模拟while语句实现无限循环的方法.分享给大家供大家参考.具体实现方法如下: 这段代码把for语句当成C语言里的while(true)用实现无限循环 复制代码 代码如下: package main import "fmt" func main() {     sum := 0     for {         sum ++         if sum > 10{             break         }else{            

  • Golang的循环语句和循环控制语句详解

    目录 一.循环语句 1. 普通循环 1)语法 2)举例 2. 循环嵌套 3. range循环 二.循环控制语句 1.Break-中断(跳出)循环 1)中断(跳出)循环 2)指定想中断(跳出)的循环(嵌套循环中使用) 2.Continue-跳过当次循环 3.goto-条件转移 一.循环语句 1. 普通循环 1)语法 for init; condition; post { } init(可选):给控制变量赋初值: condition(可选):控制条件(不填的时候等于while True): post

  • golang语言中for循环语句用法实例

    本文实例讲述了golang语言中for循环语句用法.分享给大家供大家参考.具体分析如下: for循环是用来遍历数组或数字的.用for循环遍历字符串时,也有 byte 和 rune 两种方式.第一种为byte,第二种rune. 复制代码 代码如下: package main import ( "fmt" ) func main() { s := "abc汉字" for i := 0; i < len(s); i++ { fmt.Printf("%c,&

  • Go语言学习之循环语句使用详解

    目录 1.for循环 2.for-each语法 3.break的使用 4.continue的使用 5.goto的使用 1.for循环 写法基本和其他语言一致,只是没有了while循环,用for代替while. 样例代码如下 // for循环 func loop1() { sum := 0 for i := 0; i < 100; i++ { sum += i } fmt.Printf("sum = %d\n", sum) // 和while循环一样 sum1 := 3 for s

  • Go语言基础for循环语句的用法及示例详解

    目录 概述 语法 注意 示例一  死循环,读取文件 示例二  打印乘法表 示例三  遍历字符串,数组,map 概述 for循环是一个循环控制结构,可以执行指定次数的循环 语法 第一种 for {} //无线循环 第二种 for 条件语句{} 第三种 for 初始语句; 条件语句; 迭代后语句 {} 第四种 for key,value:=range 表达式/变量{} 注意 省略初始条件,相当于while循环体必须用 { } 括起来初始化语句和后置语句是可选的如果只剩下条件表达式了,那么那两个分号也

  • 手把手带你走进Go语言之循环语句

    目录 概述 循环语句 方法一 方法二 方法三 break 关键字 continue 关键字 goto 关键字 [Golang]✔️走进 Go 语言✔️ 第六课 条件表达式 概述循环语句方法一方法二方法三break 关键字continue 关键字goto 关键字 概述 Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界. (第 6 课) 循环语句 使用好循环语句可以帮助我们提升代码的简洁性, 提高代码效率. 方法一 格式: for init; condi

  • Go语言中循环语句使用的示例详解

    目录 一.概述 1. 循环控制语句 2. 无限循环 二.Go 语言 for 循环 1. 语法 2. for语句执行过程 3. 示例 4. For-each range 循环 三.循环嵌套 1. 语法 2. 示例 四.break 语句 1. 语法 2. 示例 五. continue 语句 1. 语法 2. 示例 六.goto 语句 1. 语法 2. 示例 一.概述 在不少实际问题中有许多具有规律性的重复操作,因此在程序中就需要重复执行某些语句. 循环程序的流程图: Go 语言提供了以下几种类型循环

  • Go语言中的字符串处理方法示例详解

    1 概述 字符串,string,一串固定长度的字符连接起来的字符集合.Go语言的字符串是使用UTF-8编码的.UTF-8是Unicode的实现方式之一. Go语言原生支持字符串.使用双引号("")或反引号(``)定义. 双引号:"", 用于单行字符串. 反引号:``,用于定义多行字符串,内部会原样解析. 示例: // 单行 "心有猛虎,细嗅蔷薇" // 多行 ` 大风歌 大风起兮云飞扬. 威加海内兮归故乡. 安得猛士兮守四方! ` 字符串支持转义

  • Go语言中的延迟函数defer示例详解

    前言 大家都知道go语言的defer功能很强大,对于资源管理非常方便,但是如果没用好,也会有陷阱哦.Go 语言中延迟函数 defer 充当着 try...catch 的重任,使用起来也非常简便,然而在实际应用中,很多 gopher 并没有真正搞明白 defer.return.返回值.panic 之间的执行顺序,从而掉进坑中,今天我们就来揭开它的神秘面纱!话不多说了,来一起看看详细的介绍吧. 先来运行下面两段代码: A. 匿名返回值的情况 package main import ( "fmt&qu

  • C语言中循环语句练习实例

    计算n的阶乘 int main() { int i=0; int ret=1; scanf("%d",&i); for(i=1;i<=n;i++) { ret=ret*i; } printf("%d\n",ret); return 0; } 计算1!+2!+3!+.....+10! int main() {计算1!+2!+3!+.....+10! int i = 0; int j = 0; int sum = 0; int ret = 1; for (

  • Go语言基础if条件语句用法及示例详解

    目录 概述 语法 格式规则 概述 条件语句需要开发者通过指定一个或多个条件 并通过测试条件是否为 true 来决定是否执行指定语句 并在条件为 false 的情况再执行另外的语句. 语法 package main func main() { //第一种格式 if 条件表达式 { 语句1 } //第二种格式 if 初始化表达式; 条件表达式 { 语句1 } //第三种格式 if 初始化表达式; 条件表达式 { 语句1 }else{ 语句2 } //第四种格式 if 初始化表达式; 条件表达式 {

  • Go语言基础函数基本用法及示例详解

    目录 概述 语法 函数定义 一.函数参数 无参数无返回 有参数有返回 函数值传递 函数引用传递 可变参数列表 无默认参数 函数作为参数 二.返回值 多个返回值 跳过返回值 匿名函数 匿名函数可以赋值给一个变量 为函数类型添加方法 总结 示例 概述 函数是基本的代码块,用于执行一个任务 语法 函数定义 func 函数名称( 参数列表] ) (返回值列表]){ 执行语句 } 一.函数参数 无参数无返回 func add() 有参数有返回 func add(a, b int) int 函数值传递 fu

  • Go语言中函数可变参数(Variadic Parameter)详解

    目录 基本语法 示例一:函数中获取可变参数 示例二:将切片传给可变参数 示例三:多参数 基本语法 在Python中,在函数参数不确定数量的情况下,可以使用如下方式动态在函数内获取参数,args实质上是一个list,而kwargs是一个dict def myFun(*args, **kwargs): 在Go语言中,也有类似的实现方式,只不过Go中只能实现类似*args的数组方式,而无法实现**kwargs的方式.实现这种方式,其实也是利用数组的三个点表达方式,我们这里来回忆一下. 关于三个点(…)

  • C语言中枚举与指针的实例详解

     C语言中枚举与指针的实例详解 总结一下, 定义枚举,用typedef enum关键字, 比如 typedef enum{Red,Green,Blue} Color3; 枚举到数值的转换,如果没有指定代表数值就是从0开始算, 比如 Color3 c=Red; printf("%d",c);会显示0, 除非指定 如typedef enum{Red=3,Green=5,Blue=10} Color3; 关于类型指针的定义, 定义的时候在变量名左边加*代表此变量只是一个空指针而已, 若需要赋

  • Go语言基础设计模式之策略模式示例详解

    目录 概述 针对同一类型问题的多种处理方式 一.不使用策略模式 二.策略模式 UML 总结 示例 概述 定义一系列算法,将每个算法封装起来.并让它们能够相互替换.策略模式让算法独立于使用它的客户而变化. 针对同一类型问题的多种处理方式 一.不使用策略模式 package main import "fmt" type User struct { Name string } func (this User) travel(t string) { switch t { case "

  • Go语言基础go fmt命令使用示例详解

    go fmt 命令主要是用来帮你格式化所写好的代码文件[很多第三方集成软件都是使用了go fmt命令] 一.使用: go fmt <文件名>.go 使用go fmt命令,更多时候是用gofmt,而且需要参数 -w,否则格式化结果不会写入文件.gofmt -w src,可以格式化整个项目. 二.参数介绍 -l 显示那些需要格式化的文件 -w 把改写后的内容直接写入到文件中,而不是作为结果打印到标准输出. -r 添加形如"a[b:len(a)] -> a[b:]"的重写规

随机推荐

其他