Golang 【basic_leaming】3 流程控制

分手后的思念是犯贱 2023-10-07 22:20 7阅读 0赞

#### 阅读目录 ####

*  Go 语言 if else (条件判断)
 *   *  Go 语言 if else 条件判断代码示例
     *  if 的特殊写法
 *  Go 语言 for（循环）
 *   *  for 循环 - 初始语句
     *  for 循环 - 条件表达式
     *   *  1 更美观的死循环写法
         *  2 只有一个条件的 for 循环
     *  for 循环 - 结束语句
 *  Go 语言 for range (键值循环)
 *   *  for range 遍历数组、切片、字符串
     *  for range 遍历 map 字典
     *  for range 遍历通道（channel）
     *  for range 中使用匿名变量
 *  Go 语言 switch 语句（分支判断）
 *   *  1 基本写法
     *  2 一分支多值
     *  3 分支表达式
     *  4 fallthrough 关键字 —— 兼容 C 语言的 case 设计
 *  Go 语言 goto 语句（代码跳转）
 *   *  1 使用 goto 跳出循环
     *  2 避免定义重复代码
 *  Go 语言 break 语句（跳出循环）
 *   *  break 跳出代码块 - 退出多层循环
 *  Go 语言 continue 语句（继续下次循环）
 *  参考文献

## Go 语言 if else (条件判断) ##

Go 语言 中，if else 条件判断格式如下：

if 表达式1 {
        
      分支1
    } else if 表达式2 {
        
      分支2
    } else {
        
      分支3
    }

①：当表达式 1 的结果为 true 时，会执行分支 1 的代码；  
②：当表达式 1 的结果为 false 时，会执行表达式2，若结果为 true, 则会执行分支2的代码。  
③：当前面的条件都不满足，即都为 false 时，会执行分支3的代码。

> PS：表达式2、分支2 、分支3都是可选的，可以根据实际情况自行选择。

注意：Go 语言中规定：if 的 左括号 `‘’{‘’` 必须与 if 表达式放在同一行，如果强行放置在其他位置，会发生如下编译错误。

下面是代码反例，编译报错图示:

![在这里插入图片描述][c89ec05d41bc4c9ca14d512522296106.png]

同理，与 else 匹配的 `“{”` 也必须与 else 放置在同一行， else 也必须与上一个 if 或 else if 的右边的大括号放在同一行。

### Go 语言 if else 条件判断代码示例 ###

下面是一段正确的 if else 条件判断示例:

package main
    
    import "fmt"
    
    func main() {
        
    	// 定义一个字符串
    	str := "wgchen.blog.csdn.net"
    
    	// 获取该字符串的实际长度
    	len := len(str)
    
    	// 判断字符串的长度是否等于14
    	if len == 14 {
        
    		// 若等于14
    		fmt.Println("长度等于 14")
    	} else {
        
    		// 若不等于14
    		fmt.Println("长度不等于 14")
    	}
    }

PS E:\golang\src> go run .\main.go
    长度不等于 14
    PS E:\golang\src>

### if 的特殊写法 ###

if 还有种特殊写法，我们可以在 if 表达式之前添加一个执行语句，再根据变量 进行判断，代码如下：

if err := Connect(); err != nil {
        
    	fmt.Println(err)
    	return
    }

Connect() 是一个获取数据库连接的函数，它带有返回值，err := Connect() 是一个语句，执行 Connect() 函数后，将错误赋值给 err 变量。

err != nil 是 if 的条件判断表达式，当 err 不为空时，打印错误并返回。

这种写法可以将返回值和判断放在一行进行处理，使得返回值的作用域范围被限制在了 if else 语句组合中，这样做的好处是，变量的作用域范围越小，那么它可能造成的问题的可能性越小，这对代码的稳定性很有帮助，另外，也可以做炫技使用。

## Go 语言 for（循环） ##

在 Go 语言 中，循环需要使用关键字 for 来完成，格式如下:

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

for 循环会不停地进行循环，直到 **条件表达式** 返回 false 才推出循环，即执行 for 循环 `"}"` 后面的代码。

### for 循环 - 初始语句 ###

初始语句是第一次执行循环前执行的语句，通常情况下，我们会通过它来执行变量初始化操作。

注意： 通过初始语句声明的变量，作用域局限在 for 循环内。

代码如下:

package main
    
    import "fmt"
    
    func main() {
        
    	for i := 0; i < 100; i++ {
        
    		fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    	}
    }

![在这里插入图片描述][a565b7ef5bef413c99a0f1dacb2ee1de.png]  
上面代码打印了一百次知其黑，受其白 wgchen.blog.csdn.net。

另外，初始语句还可以忽略不写，但是初始语句后面的分号必须写，代码如下:

i := 0
    for ; i < 100; i++ {
        
      fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    }

上面的代码中将 `i` 放在了 for 循环前面初始化，这时 `i` 的作用域不止作用在 for 循环内。

### for 循环 - 条件表达式 ###

每次在循环前，会计算条件表达式的值，如果结果为 true, 则继续循环；

否则将结束循环。

注意：**条件表达式同样可以忽略不写，若不写，由于没有终止条件，则会陷入无限死循环**，代码如下:

i := 0
    for ; ; i++ {
        
      if i == 10 {
        
        break
      }
    
      fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    }

上面代码打印 10 次：知其黑，受其白 wgchen.blog.csdn.net

不是说死循环吗？  
怎么只打印了 10 呢？

之所以只打印 10 次，因为循环体中有 if 判断语句，当 i 等于 10 时，执行了 break 结束循环的操作。

#### 1 更美观的死循环写法 ####

还有死循环的写法更具有可读性，代码如下：

i := 0
    for {
        
      if i == 10 {
        
        break
      }
    
      fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    }

可以看到， for 后面直接忽略了初始语句、条件表达式以及结束语句。

#### 2 只有一个条件的 for 循环 ####

上面的代码还可以进一步简化，可以将 if 判断整合到 for 循环中，代码如下:

i := 0
    for i <= 10 {
        
      i++
      fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    }

将条件 i == 10 条件改成了 i <= 10, 并整合到 for 后面，若满足条件则会打印控制台，且每次对 i 执行自增加一操作。

### for 循环 - 结束语句 ###

在结束每次循环前被执行的语句。若循环被 break 、goto 、return 、panic 等语句强制退出，则结束语句不会被执行。

## Go 语言 for range (键值循环) ##

Go 语言 中，我们还可以通过 for range 来遍历数组 、切片 、字符串 、map 以及通道（channel）。

### for range 遍历数组、切片、字符串 ###

通过 for range 遍历数组、切片、字符串的返回值都有一个规律：

*  下标索引 index；
 *  下标对应的值 value；

下面代码演示了如何遍历切片，数组格式类似:

package main
    
    import "fmt"
    
    func main() {
        
    	// 初始化一个切片
    	slice := []int{
        1, 2, 3, 4}
    
    	// 通过 for range 循环切片
    	for index, value := range slice {
        
    		fmt.Printf("index: %d, value: %d\n", index, value)
    	}
    }

PS E:\golang\src> go run .\main.go
    index: 0, value: 1
    index: 1, value: 2
    index: 2, value: 3
    index: 3, value: 4
    PS E:\golang\src>

下面代码演示了如何遍历字符串：

package main
    
    import "fmt"
    
    func main() {
        
    	str := "知其黑，受其白 wgchen.blog.csdn.net"
    
    	// 通过 for range 循环字符串
    	for index, value := range str {
        
    		fmt.Printf("index: %d, value: 0x%x\n", index, value)
    	}
    
    }

PS E:\golang\src> go run .\main.go
    index: 0, value: 0x77e5
    index: 3, value: 0x5176
    index: 6, value: 0x9ed1
    index: 9, value: 0xff0c
    index: 12, value: 0x53d7
    index: 15, value: 0x5176
    index: 18, value: 0x767d
    index: 21, value: 0x20
    index: 22, value: 0x77
    index: 23, value: 0x67
    index: 24, value: 0x63
    index: 25, value: 0x68
    index: 26, value: 0x65
    index: 27, value: 0x6e
    index: 28, value: 0x2e
    index: 29, value: 0x62
    index: 30, value: 0x6c
    index: 31, value: 0x6f
    index: 32, value: 0x67
    index: 33, value: 0x2e
    index: 34, value: 0x63
    index: 35, value: 0x73
    index: 36, value: 0x64
    index: 37, value: 0x6e
    index: 38, value: 0x2e
    index: 39, value: 0x6e
    index: 40, value: 0x65
    index: 41, value: 0x74
    PS E:\golang\src>

上面代码中的 value 变量实际类型是 runne, 本质上是 int32, 以十六进制格式打印出来的是字符串编码。

### for range 遍历 map 字典 ###

通过 for range 遍历 map 字典会返回键和值，称为键值对，它们总是一对一出现，演示代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	m := map[int]string{
        
    		1: "知其黑，受其白",
    		2: "wgchen.blog.csdn.net",
    	}
    
    	for key, value := range m {
        
    		fmt.Printf("key: %d, value: %s\n", key, value)
    	}
    }

PS E:\golang\src> go run .\main.go
    key: 1, value: 知其黑，受其白
    key: 2, value: wgchen.blog.csdn.net
    PS E:\golang\src>

注意： 对 map 字典进行遍历时，遍历出的键值对是无序的，如果需要有序输出，需要先排序。

### for range 遍历通道（channel） ###

for range 遍历通道（channel）有点不同，此时**只会输出一个值，即管道内的类型对应的数据**。

下面代码演示了如何遍历通道（channel）:

package main
    
    import "fmt"
    
    func main() {
        
    
    	// 初始化一个通道
    	c := make(chan int)
    
    	// 启动一个 goroutine, 功能是往通道中推送数据 1、2、3，然后关闭通道
    	go func() {
        
    		c <- 1
    		c <- 2
    		c <- 3
    		close(c)
    	}()
    
    	for value := range c {
        
    		fmt.Println(value)
    	}
    }

注意: goroutine 在启动结束后，会被立刻并行执行。关于 goroutine，后面小节会详细介绍，这里只做了解。

PS E:\golang\src> go run .\main.go
    1
    2
    3
    PS E:\golang\src>

### for range 中使用匿名变量 ###

假设说在 for range 遍历中只想获取下标索引，或者是值要怎么做呢？

比较优雅的写法是通过匿名变量。

什么是匿名变量？

1、它可以理解成一种占位符；  
2、这种变量不会分配内存，也不会占用变量名；  
3、在 for range 中，可以通过匿名变量接受键 key，也可以接受值 value。

下面代码演示了如果通过匿名变量来接受 key, 循环体中只打印了值 value。

package main
    
    import "fmt"
    
    func main() {
        
    	m := map[int]string{
        
    		1: "知其黑，受其白",
    		2: "wgchen.blog.csdn.net",
    	}
    
    	for _, value := range m {
        
    		fmt.Printf("value: %s\n", value)
    	}
    }

PS E:\golang\src> go run .\main.go
    value: 知其黑，受其白
    value: wgchen.blog.csdn.net
    PS E:\golang\src>

## Go 语言 switch 语句（分支判断） ##

分支判断可以理解成批量的 if 语句，使用 switch 语句可以非常方便地对大量值进行条件判断。

### 1 基本写法 ###

Go 语言 改进了其他语言中 switch 语句的设计弊端。Go 语言中 switch 中的每一个 case 都是独立代码块，无需通过 break 语句跳出代码块，以避免执行到下一个 case 代码块。

PS: 如果你有其他语言的编程经验 (如 Java), 一定会对 case 代码块中的 break 语句印象深刻。

swtich 语句的基本格式如下:

package main
    
    import "fmt"
    
    func main() {
        
    	num := 1
    
    	switch num {
        
    	case 1:
    		fmt.Println("1 -> 知其黑 wgchen")
    	case 2:
    		fmt.Println("2 -> 受其白 blog.csdn.net")
    	default:
    		fmt.Println("error")
    	}
    }

PS E:\golang\src> go run .\main.go
    1 -> 知其黑 wgchen
    PS E:\golang\src>

上面代码中，case 对整型 num 进行判断，若条件符合，则打印相应的字符串 。

另外，还使用了 default 分支，default 分支表示若条件均不符合，则执行改代码块。

> 注意：每一个 swtich 语句中只能有一个 default 分支。

### 2 一分支多值 ###

当需要多个 case 放在一起的时候，代码格式如下:

package main
    
    import "fmt"
    
    func main() {
        
    	num := 1
    
    	switch num {
        
    	case 1, 2:
    		fmt.Println("知其黑 blog.csdn.net")
    	}
    
    }

PS E:\golang\src> go run .\main.go
    知其黑 blog.csdn.net
    PS E:\golang\src>

表达式直接用逗号 , 隔开即可。

### 3 分支表达式 ###

case 后面除了定义常量以外，还可以像 if 语句一样添加表达式，代码如下:

package main
    
    import "fmt"
    
    func main() {
        
    	num := 1
    
    	switch {
        
    	case num > 0 && num < 2:
    		fmt.Println("知其黑 blog.csdn.net")
    	}
    }

S E:\golang\src> go run .\main.go
    知其黑 blog.csdn.net
    PS E:\golang\src>

注意： 这个时候，switch 后面不再跟判断变量，直接不写即可。

### 4 fallthrough 关键字 —— 兼容 C 语言的 case 设计 ###

前面说到了 Go 语言中 swtich 语句中的 case 均为独立代码块，执行完成后，不会像 C 语言那种继续执行下一个 case。

但是为了兼容一些移植代码，Go 语言加入了 fallthrough 关键字来实现这一功能。

实例代码如下:

package main
    
    import "fmt"
    
    func main() {
        
    	num := 1
    
    	switch {
        
    	case num > 0:
    		fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    		fallthrough
    	case num < 2:
    		fmt.Println("知其黑，受其白 wgchen.blog.csdn.net")
    	}
    }

PS E:\golang\src> air
    
      __    _   ___
     / /\  | | | |_)
    /_/--\ |_| |_| \_ , built with Go
    
    watching .
    watching resources
    watching resources\views
    watching resources\views\articles
    !exclude tmp
    building...
    running...
    知其黑，受其白 wgchen.blog.csdn.net
    知其黑，受其白 wgchen.blog.csdn.net

## Go 语言 goto 语句（代码跳转） ##

在 Go 语言 中，goto 语句通过标签实现代码间的跳转。  
它通常会被使用在快速跳出循环 、避免定义重复代码等。

### 1 使用 goto 跳出循环 ###

package main
    
    import "fmt"
    
    func main() {
        
    	// 外循环
    	for i := 0; i < 10; i++ {
        
    		// 内循环
    		for j := 0; j < 10; j++ {
        
    			// 当 j 等于 2 时，跳转到标签 breakHere 那里
    			if j == 2 {
        
    				// 跳转标签
    				goto breakHere
    			}
    		}
    	}
    
    	// 手动返回，防止执行后面的标签
    	return
    
    	// 定义一个标签
    breakHere:
    	fmt.Println("跳到这里 ...")
    }

building...
    running...
    跳到这里 ...

### 2 避免定义重复代码 ###

在实际的编码中，经常会定义一些重复性的代码，如下：

![在这里插入图片描述][acce2db27fb445869ce9b1ea3b64a4c1.png]  
上面的这段明显有重复代码，我们可以 goto 定义标签来使代码变的更加优雅一点:

![在这里插入图片描述][34b722f17cd646ab9c169872cc3dba5f.png]

## Go 语言 break 语句（跳出循环） ##

在 Go 语言 中，break 语句可以结束 for 、switch 和 select 代码块。

下面代码演示了 break 语句跳出单层循环:

package main
    
    import "fmt"
    
    func main() {
        
    	// 外循环
    	for i := 0; i < 10; i++ {
        
    		fmt.Printf("i: %d\n", i)
    
    		// 当 i 等于 6 时，跳转到循环
    		if i == 6 {
        
    			// 跳出循环
    			break
    		}
    	}
    
    	fmt.Println("跳出循环 ...")
    }

i: 0
    i: 1
    i: 2
    i: 3
    i: 4
    i: 5
    i: 6
    跳出循环 ...

上面代码，当循环到 6 时，通过 break 语句跳出循环。

### break 跳出代码块 - 退出多层循环 ###

通过 break 语句搭配标签可以跳出代码块，如跳出 for 、switch 和 select 代码块。

下面的代码演示了如何通过 break 跳出多层循环，代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    
    OuterLoop:
    	// 外循环
    	for i := 0; i < 10; i++ {
        
    		fmt.Printf("i: %d\n", i)
    
    		// 内循环
    		for j := 0; j < 10; j++ {
        
    			fmt.Printf("j: %d\n", j)
    			if i == 0 && j == 6 {
        
    				// 跳出 OuterLoop 代码块
    				break OuterLoop
    			}
    		}
    	}
    
    	fmt.Println("跳出循环 ...")
    }

## Go 语言 continue 语句（继续下次循环） ##

在 Go 语言 中，continue 语句可以结束当前 for 循环 ，进入下一次 for 循环, 代码如下:

package main
    
    import "fmt"
    
    func main() {
        
    
    	for i := 0; i < 10; i++ {
        
    		// 当 i 等于 2 时，执行 continue 语句，继续下一次循环
    		if i == 2 {
        
    			continue
    		}
    
    		fmt.Printf("i: %d\n", i)
    	}
    }

running...
    i: 0
    i: 1
    i: 3
    i: 4
    i: 5
    i: 6
    i: 7
    i: 8
    i: 9

可以看到并没有打印 2， 那是因为当循环到 i 等于 2 时，直接执行了 continue 语句，继续了下一循环。

另外，我们还可以在 continue 语句后添加标签，表示开始标签处的循环:

package main
    
    import "fmt"
    
    func main() {
        
    
    OuterLoop:
    	// 外循环
    	for i := 0; i < 3; i++ {
        
    		// 内循环
    		for j := 0; j < 3; j++ {
        
    			// 当 j 等于 1 时，执行 continue 语句跳转到 OuterLoop 标签处，即跳出至外循环，而不是内循环
    			if j == 1 {
        
    				continue OuterLoop
    			}
    			fmt.Printf("i: %d, j: %d\n", i, j)
    		}
    	}
    }

building...
    running...
    i: 0, j: 0
    i: 1, j: 0
    i: 2, j: 0

代码中，当 j 等于 1 时，会执行 continue 语句直接跳转到 OuterLoop 标签处，即跳出至外循环继续，而不是内循环。

## 参考文献 ##

[ Golang 【basic\_leaming】流程控制 ][Golang _basic_leaming_]

![在这里插入图片描述][c7b2013990b645ada504982055be4e73.png]

[c89ec05d41bc4c9ca14d512522296106.png]: https://img-blog.csdnimg.cn/c89ec05d41bc4c9ca14d512522296106.png
[a565b7ef5bef413c99a0f1dacb2ee1de.png]: https://img-blog.csdnimg.cn/a565b7ef5bef413c99a0f1dacb2ee1de.png
[acce2db27fb445869ce9b1ea3b64a4c1.png]: https://img-blog.csdnimg.cn/acce2db27fb445869ce9b1ea3b64a4c1.png
[34b722f17cd646ab9c169872cc3dba5f.png]: https://img-blog.csdnimg.cn/34b722f17cd646ab9c169872cc3dba5f.png
[Golang _basic_leaming_]: https://wgchen.blog.csdn.net/article/details/128346243
[c7b2013990b645ada504982055be4e73.png]: https://img-blog.csdnimg.cn/c7b2013990b645ada504982055be4e73.png