Golang 流程控制

最新推荐文章于 2023-06-07 13:53:16 发布
最新推荐文章于 2023-06-07 13:53:16 发布
阅读量136 收藏
点赞数
分类专栏： golang学习 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cdc_tr/article/details/129801005
版权

一、条件判断

1. 条件判断简介

条件语句是用来判断给定的条件是否满足(表达式值是否为true或者false)，并根据判断的结果决定执行情况的语句。go语言中的条件语句主要包含如下几种情况：

  • if - else if - else 语句：if 语句由一个布尔表达式后紧跟一个或多个语句组成，语句后可以使用可选的 else 和 else if 语句, 这些语句中的表达式在布尔表达式的值和 if 语句后布尔表达式的值不同时执行；可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
  • switch 语句： switch 语句用于基于不同条件执行不同动作。
  • select 语句： select 语句类似于 switch 语句，但是 select 会随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。

在 go 语言中使用 if 时需要注意以下几点：

  • 不需使用括号将条件包含起来。
  • 大括号{}必须存在，即使只有一行语句。
  • 左括号必须在if或else的同一行。
  • 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔。

在 go 语言中使用 switch 时需要注意以下几点：

  • 支持多条件匹配。
  • 不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
  • 如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。
  • 分支还可以使用表达式。

2. if 语句的使用

2.1 if 语句

go语言中 if 语句的语法如下：

// 当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3
if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

示例1：满足条件则执行，否则跳过。

package main

import "fmt"

func main() {

	age := 20

	if age >= 18 {
		fmt.Println("你已经成年了")
	}

	fmt.Printf("程序运行结束")
}

示例2：初始变量可以声明在布尔表达式里面，但是只在判断中生效。

package main

import "fmt"

func main() {
	if age := 20; age >= 18 {
		fmt.Println("你已经成年了")
	}

	fmt.Printf("程序运行结束")

	fmt.Println(age)  // undefined: age
}

示例3：不能使用0或非0表示真假。

package main

import "fmt"

func main() {
	var i = 1
	if i {       // 编译失败
		fmt.Println("here")
	}
	fmt.Printf("程序运行结束")
}
2.2 if-else 语句

go语言中 if-else 语句的语法如下：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

示例1：判断奇数偶数。

package main

import (
	"fmt"
)

func main() {
	var num int

	fmt.Println("输入一个数字：")
	fmt.Scan(&num)
	fmt.Printf("s 的值是：%v \n", num)

	if num%2 == 0 {
		fmt.Println("偶数")
	} else {
		fmt.Print("奇数")
	}
}

示例2：判断是否成年。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// 生成一个 1~100 随机数
	rand.Seed(time.Now().UnixNano())
	age := rand.Intn(100)

	if age >= 18 {
		fmt.Println("你已经成年")
	} else {
		fmt.Println("你还未成年")
	}
}

示例3：初始变量可以声明在布尔表达式里面，但是只在判断中生效。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// 生成一个 1~100 随机数
	rand.Seed(time.Now().UnixNano())

	if age := rand.Intn(100); age >= 18 {
		fmt.Println("你是成年人")
	} else {
		fmt.Println("你还未成年")
	}

	//fmt.Println(age)  age 作用域只在布尔表达式中
}
2.3 if-else if-else 语句

go语言中 if-else if-else 语句的语法如下：

if 布尔表达式1 {
    // do something
} else if 布尔表达式2 {
    // do something else
}else {
    // catch-all or default
}

示例1：根据分数划分等级

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// 生成一个 1~100 随机数
	rand.Seed(time.Now().UnixNano())
	score := rand.Intn(100)
	
	if score >= 60 && score <= 70 {
		fmt.Println("C")
	} else if score > 70 && score <= 90 {
		fmt.Println("B")
	} else {
		fmt.Println("A")
	}
}

示例2：初始变量可以声明在布尔表达式里面，但是只在判断中生效。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// 生成一个 1~100 随机数
	rand.Seed(time.Now().UnixNano())

	if score := rand.Intn(100); score >= 60 && score <= 70 {
		fmt.Println("C")
	} else if score > 70 && score <= 90 {
		fmt.Println("B")
	} else {
		fmt.Println("A")
	}

	//fmt.Println(score)  score 作用域只在布尔表达式中
}

示例3：输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	var c string
	fmt.Println("输入一个字符：")
	fmt.Scan(&c)

	if c == "S" {
		fmt.Println("输入第二个字符：")
		fmt.Scan(&c)
		if c == "a" {
			fmt.Println("Saturday")
		} else if c == "u" {
			fmt.Println("Sunday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "F" {
		fmt.Println("Friday")
	} else if c == "M" {
		fmt.Println("Monday")
	} else if c == "T" {
		fmt.Println("输入第二个字符：")
		fmt.Scan(&c)
		if c == "u" {
			fmt.Println("Tuesday")
		} else if c == "h" {
			fmt.Println("Thursday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "W" {
		fmt.Println("Wednesday")
	} else {
		fmt.Println("输入错误")
	}
}
2.4 if 语句嵌套使用

go语言中 if 语句也可以嵌套使用，语法如下：

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

示例：比较三个数的大小

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())

	a := rand.Intn(100)
	b := rand.Intn(100)
	c := rand.Intn(100)

	fmt.Printf("随机生成数字a的值为：%v \n", a)
	fmt.Printf("随机生成数字b的值为：%v \n", b)
	fmt.Printf("随机生成数字c的值为：%v \n", c)

	if a > b {
		if a > c {
			fmt.Println("a最大")
		}
	} else {
		if b > c {
			fmt.Println("b最大")
		} else {
			fmt.Println("c最大")
		}
	}
}

3. switch 语句的使用

3.1 基本使用

switch 语句会执行满足条件的 case 分支，如果所有的 case 都未命中，则会执行 default 分支 。Go语言规定每个 switch 只能有一个 default 分支。

package main

import (
	"fmt"
)

func main() {
	finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}
}
3.2 初始变量声明

初始变量可以声明在布尔表达式里面，但是作用域只有 switch 代码段 。

package main

import (
	"fmt"
)

func main() {
	switch finger := 3; finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}
    
    //fmt.Println(finger) // undefined: finger
}
3.3 分支可以有多个值

一个分支可以有多个值，多个值中间使用英文逗号分隔。

package main

import (
	"fmt"
)

func main() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}
3.4 分支的值可以是表达式

分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。

package main

import (
	"fmt"
)

func main() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好学习吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活着真好")
	}
}
3.5 fallthrough 的使用

fallthrough 语法可以执行满足条件的 case 的下一个 case

package main

import (
	"fmt"
)

func main() {
	s := "a"
	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
		fallthrough
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}
}

二、循环

go 语言中的所有循环类型均可以使用 for 关键字来完成。条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。

1. for 语句

go语言中 for 语句的语法如下：

for 初始语句;条件表达式;结束语句{
    循环体语句
}

示例1：基本使用，输出 1~10

package main

import "fmt"

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

示例2：for 循环的初始语句可以写在外面，但是初始语句后的分号必须要写

package main

import "fmt"

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

示例3：初始条件和结束条件都可以省略（结束条件可以写在循环体中）

package main

import "fmt"

func main() {
	i := 1
	for i <= 10 {
		fmt.Printf("i: %v \n", i)
		i ++  // 结束条件
	}
}

示例4：无限循环

package main

import "fmt"

func main() {
    // 条件永远满足
	i := 1
	for i <= 10 {
		fmt.Printf("i: %v \n", i)
	}
    
    // 或者直接写一个for关键字
    for {
        fmt.Println("我一直在执行~")
    }
}

2. for range 语句

Go 语言中可以使用 for range 遍历数组、切片、字符串、map 及通道（channel）。 通过 for range 遍历的返回值有以下规律：

  • 数组、切片、字符串返回索引和值。
  • map返回键和值。
  • 通道（channel）只返回通道内的值。
package main

import "fmt"

func main() {
	
    s := "hello南京"
    
    // 普通方式遍历字符串是按照单个字节遍历
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i]) // 104(h) 101(e) 108(l) 108(l) 111(o) 229(å) 141() 151(—) 228(ä) 186(º) 172(¬) 
	}
	// 使用 for + range 遍历字符串，可以正常遍历出中文
    for _, r := range s { 
		fmt.Printf("%v(%c) ", r, r)  // 104(h) 101(e) 108(l) 108(l) 111(o) 21335(南) 20140(京) 
	}
}

三、流程控制关键字

1. break 关键字

break 语句可以结束 for、switch 和 select 的代码块。Go 语言中使用 break 要注意以下几点：

  • 单独在 select 中使用 break 和不使用 break 没有区别。
  • 在 switch 语句中，如果没有使用 fallthough，使用 break 和不使用 break 没有区别；如果有 fallthough，使用 break 能够终止 fallthough 后面的 case 语句的执行。
  • 带标签的 break ，可以直接跳出多层循环的作用域，不需要使用控制变量一层一层跳出循环，没有带 break 的只能跳出当前语句块。
1.1 跳出for循环
package main

import "fmt"

func main() {

	for i := 1; i <= 10; i++ {
		if i == 5 {
			break
		}
        
		fmt.Println(i)  // 输出 1 2 3 4
	}
}
1.2 跳出switch循环
package main

import "fmt"

func main() {
	i := 2
	switch i {
	case 1:
		fmt.Println("等于1")
		break
	case 2:
		fmt.Println("等于2")
		break  // 满足条件后直接退出switch。break后所有代码都不会执行
		fallthrough
	case 3:
		fmt.Println("等于3")
		break
	default:
		fmt.Println("不关心")
		break
	}
}
1.3 带标签的break

break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的 for、switch 和 select 的代码块上。

package main

import "fmt"

func main() {

	for i := 0; i <= 10; i++ {
		for j := 0; j <= 10; j++ {
			if j == 5 {
				break  // 只能退出里层的j循环，外层的i循环还是会继续执行
			}

			fmt.Printf("j: %v\n", j)
		}

		fmt.Printf("i: %v\n", i)
	}


breakKey:
	for i := 0; i <= 10; i++ {
		for j := 0; j <= 10; j++ {
			if j == 5 {
				break breakKey  // 可以退出两层循环
			}

			fmt.Printf("j: %v\n", j)
		}

		fmt.Printf("i: %v\n", i)
	}
}

2. continue 关键字

continue 在 Go 中只能用在 for 循环中，它可以终止本次循环，直接进行下一次循环。

package main

import "fmt"

func main() {

	for i := 0; i <= 10; i++ {
		if i == 2 {
			continue  // 遇到i等于2时，直接跳过，开始下一次循环。continue后的代码不会执行
		}

		fmt.Println(i)
	}
}

continue 后也可以添加标签，表示退出标签对应的本次循环的代码块，继续开始下一次循环：

package main

import "fmt"

func main() {
forLoop1:
	for i := 0; i <= 5; i++ {
		//forLoop2:
		for j := 0; j <= 5; j++ {
			if i == 2 && j == 2 {
				continue forLoop1 // 当i和j都等于2时，跳过当前的j循环和i循环，直接开始循环i=3
			}

			fmt.Printf("i: %v, j: %v\n", i, j)
		}
	}
}

3. goto 关键字

goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。

示例：当 j==2 时退出双层循环

package main

import "fmt"

func main() {
	// 可以通过标识位来判断是否要退出外层循环
	exitFlag := false

	for i := 0; i <= 5; i++ {
		for j := 0; j <= 5; j++ {
			if j == 2 {
				exitFlag = true
				break
			}
			fmt.Printf("i: %v, j: %v\n", i, j)
		}

		if exitFlag {
			break
		}
	}
}

可以使用 goto + 标签 来优化代码：

package main

import "fmt"

func main() {

	for i := 0; i <= 5; i++ {
		for j := 0; j <= 5; j++ {
			if j == 2 {
				goto exitFlag  // 直接跳转到标签对应的代码段处
			}
			fmt.Printf("i: %v, j: %v\n", i, j)
		}
	}

exitFlag:
	fmt.Println("end~")
}
cdc-x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言学习笔记—golang流程控制
qq_39280718的博客
06-18 227
Go语言中的流程控制
Golang学习笔记 控制流
乐百川
06-01 360
条件语句if语句下面是Golang的if语句，需要注意的是条件判断块不需要小括号，而且if语句的大括号不能省略，即使其中只有一行语句。if condition == true { fmt.Println("条件为真") } else { fmt.Println("条件为假") }if语句可以包含一个初始化块，初始化块和判断条件中使用;分隔。初始化块用来初始化可能在语句中使用的变量，这
Go语言基础之流程控制
aaronthon的博客
03-26 146
Go语言基础之流程控制 Go语言基础之流程控制 流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。 Go语言中最常用额流程控制有if和for，而switch和goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。 if else(分支结构) if条件判断基本写法 Go语言中...
Go语言中的流程控制
红牛编程
10-22 234
文章目录1 概述2 条件分支 if3 状态分支 switch3.1 基础3.2 fallthrough，向下穿越3.3 条件型 switch4 循环for4.1 基本4.2 省略语句4.3 break4.4 continue4.5 嵌套循环5 goto6 延迟执行defer 1 概述 Go语言提供了条件分支 if，状态分支 switch，循环 for，跳转 goto，延迟执行 defer，这些流程...
golang 流程控制
Mars
05-18 294
文章目录分支ifif...elseif..else if ...elseswitchfallthrough循环forrangewhile?do?breakcontinuegotoselect 分支 if //if 中可以直接定义变量 if 布尔表达式 { /* 在布尔表达式为 true 时执行 */ } //例子 age := 0 _, _ = fmt.Scanln(&age) if age > 18{ fmt.Println("对自己负责") } if s:="呀";age&gt
Go语言的流程控制
DXB2021的博客
01-22 404
使用if语言的程序清单如下： package main import( "fmt" ) func main(){ b:=true if b{ fmt.Println("b is true!") } } 运行结果如下： b is true! 使用else语句的代码清单如下： package main import( "fmt" ) func main(){ b:=false if b{ fmt.Println("b is true!") }
Go语言 流程控制
谢谢你们的关注
07-19 241
Go语言 流程控制
5.Golang流程控制语句与循环1
08-03
【Golang流程控制语句与循环】 在Go语言（Golang）中，流程控制语句是程序执行流程的重要组成部分，主要包括if-else分支和for循环。下面我们将详细讲解这两个概念。 1. if-else分支 在Go语言中，`if`语句用于基于...
6.Golang流程控制语句与循环(二)1
08-03
在Golang编程语言中，流程控制语句是程序执行顺序的关键组成部分，它们允许开发者根据不同的条件来决定程序的运行路径。本篇文章将深入探讨其中的`switch-case`、`select-case`以及`goto`语句。 首先，我们来看`...
详解Golang 中的并发限制与超时控制
09-20
在Golang中，并发控制和超时管理是构建高效、可靠程序的关键部分。本文将深入探讨这两个主题，以便更好地理解和应用它们。 首先，让我们来看并发。Golang通过goroutines和channels实现了轻量级线程的概念，使并发...
golang实现并发数控制的方法
09-20
在Golang中，控制并发数是一项重要的任务，它关乎到系统的资源利用率和性能表现。并发控制可以帮助我们避免因过度并发导致的系统压力过大，确保程序的稳定性和效率。本文将探讨如何在Golang中实现并发数控制。 首先...
Golang 流程控制（if、switch、for、continue、break）
qq_38172514的博客
06-30 1326
Golang 流程控制（if、switch） if判断 if 示例： package main import "fmt" func main() { var yes string fmt.Print("有没有卖西瓜的：") fmt.Scan(&yes) fmt.Print("老婆的想法：买十个包子") if yes == "y" || yes == "yes" || yes == "Y" || yes == "YES" { fmt.Println("和一个西瓜") } f
go语言：流程控制
Mr_qing的博客
03-23 182
一、Go语言if else（分支结构） 在Go语言中，关键字 if 是用于测试某个条件（布尔型或逻辑型）的语句，如果该条件成立，则会执行 if 后由大括号{}括起来的代码块，否则就忽略该代码块继续执行后续的代码。 if condition { // do something } 如果存在第二个分支，则可以在上面代码的基础上添加 else 关键字以及另一代码块，这个代码块中的代码只有在条件...
go语言—控制流程
最新发布
fanfjaiyun的博客
06-07 77
第 14 行，默认情况下循环只能一层一层退出，为此就需要设置一个状态变量 breakAgain，需要退出时，设置这个变量为 true。第 15 行，标签只能被 goto 使用，但不影响代码执行流程，此处如果不手动返回，在不满足条件时，也会执行第 18 行代码。代码说明：第 12 行将结束当前循环，开启下一次的外层循环，而不是第 8 行的循环。第 16 行，使用 break 退出当前循环，执行后，代码调转到第 20 行。第 10 行，使用 goto 语句跳转到指明的标签处，标签在第 17 行定义。
Go语言实践[回顾]教程22--详解Go语言的流程控制
IT技术实战
10-12 467
编程语言代码的执行顺序，本质上说就是 “顺序” 和 “跳转” 这两种。顺序，就是按照代码书写顺序从上至下、从左至右（有优先级提权的先执行）的顺序依次执行（底层实际上是按照程序指令存储器上的存放顺序逐条执行）。跳转，就是在顺序执行中遇到跳转语句就跳转到指定的某处开始继续顺序执行。
Go语言基础三 流程控制
m0_46937429的博客
10-09 996
在编程中 需要接收用户输入的数据 就可以使用输入语句来获取1，switch 语句用于基于不同条件执行不同的动作 每一个case 分支都是唯一的 从上到下逐一测试 直到匹配为止2，匹配项后面也不需要在加breaki < 10;i ++ {fmt . Println("我是美女") }1)将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的for称为外层循环在里面的for循环称为内层循环。【建议一般使用两层，最多不要超过3层】2)实质上，嵌套循环就是把内层循环当成外层循环的循环体。
Go语言学习15-基本流程控制
Huazie
07-10 2824
Go语言流程控制方法(基本流程控制: if , for , switch , goto)
golang流程控制总结
geek99_guo的博客
12-07 587
go语言中的流程控制 本文视频教程地址：https://www.bilibili.com/video/BV1zR4y1t7Wj?from=search&seid=12495842889998176802&spm_id_from=333.337.0.0 go语言中的条件 条件语句是用来判断给定的条件是否满足(表达式值是否为true或者false)，并根据判断的结果(真或假)决定执行的语句，go语言中的条件语句也是这样的。 go语言中的条件语句包含如下几种情况 if 语句：if 语句 由一个布
Go——控制结构(if、switch、for、Lable、goto、break)
吴声子夜歌的博客
04-30 237
现代计算机存储结构无论“普林斯顿结构”，还是“哈佛结构”，程序指令都是线性地存放在存储器上。程序执行从本质上来说就是两种模式：顺序和跳转。·顺序就是按照程序指令在存储器上的存放顺序逐条执行。跳转就是遇到跳转指令就跳转到某处继续线性执行。Go是一门高级语言，其源程序虽然经过了高度的抽象并封装了很多语法糖，但还是跳不出这个模式（这里暂时不考虑goroutine引入并发后的执行视图变化）。顺序在Go里面体现在从main函数开始逐条向下执行，就像我们的程序源代码顺序一样；
Golang流程控制：if-else与for循环深度解析
"Golang流程控制语句与循环的讲解" 在Golang编程语言中，流程控制语句是程序执行流程的重要组成部分，它们允许我们根据特定条件执行不同的代码块或者重复执行某些代码。本教程主要涉及两个核心概念：if-else 分支和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值