Go后端开发 -- 条件、循环语句 &&

蝎子莱莱xo2024-01-06 12:46

Go后端开发 -- 条件、循环语句 && defer语句

文章目录

一、条件语句

1.if ... else 语句

语法：

go 复制代码 
if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

与C的if ... else语句的区别是条件不用加括号
实例

go 复制代码 
package main

import "fmt"

func main() {
   /* 局部变量定义 */
   var a int = 100;
 
   /* 判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" );
   } else {
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于 20\n" );
   }
   fmt.Printf("a 的值为 : %d\n", a);
}

2.switch语句

语法：

go 复制代码 
switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}
  • switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。
  • switch 默认情况下 case 最后自带 break 语句 ，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough
  • 变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
  • 可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
  • switch语句可以不在switch开头确定判断的条件，可以在case中进行条件判断；

实例：

go 复制代码 
package Switch

import "fmt"

func Switch() {
	grade := 'B'
	marks := 90

	switch marks {
	case 90:
		grade = 'A'
	case 80:
		grade = 'B'
	case 70, 60, 50:
		grade = 'C'
	default:
		grade = 'D'
	}

	switch {
	case grade == 'A':
		fmt.Println("优秀")
	case grade == 'B':
		fmt.Println("良好")
	case grade == 'C':
		fmt.Println("及格")
	default:
		fmt.Println("不及格")
	}

	fmt.Println("你的等级是：", grade)
}
  • switch语句还可以被用于type-switch来判断某个 interface 变量中实际存储的变量类型。

Type Switch 语法格式如下

go 复制代码 
switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

实例：

go 复制代码 
package Switch

import "fmt"

func TypeSwitch() {
	var x interface{}

	switch i := x.(type) {
	case nil:
		fmt.Printf("x的类型: %T\n", i)
	case int:
		fmt.Println("x是int型")
	case float64:
		fmt.Println("x是float64型")
	case func(int) float64:
		fmt.Println("x是func(int)型")
	case bool, string:
		fmt.Println("x是bool或string型")
	default:
		fmt.Println("未知型")
	}
}
  • fallthrough
    使用 fallthrough 会强制执行后面的 case 语句，包括default，fallthrough 不会判断下一条case的表达式结果是否为 true。
  • fallthrough只会强制执行后面一条case语句，而不是后面的全部；

实例1：

go 复制代码 
package Switch

import "fmt"

func Fallthrough() {
	switch {
	case false:
		fmt.Println("1.case条件语句为false")
		fallthrough
	case true:
		fmt.Println("2.case条件语句为true")
		fallthrough
	case false:
		fmt.Println("3.case条件语句为false")
		fallthrough
	case true:
		fmt.Println("4.case条件语句为true")
		fallthrough
	case false:
		fmt.Println("5.case条件语句为false")
		fallthrough
	default:
		fmt.Println("6.默认case")
	}
}


实例2：

go 复制代码 
package Switch

import "fmt"

func Fallthrough() {
	switch {
	case false:
		fmt.Println("1.case条件语句为false")
		fallthrough
	case true:
		fmt.Println("2.case条件语句为true")
		fallthrough
	case false:
		fmt.Println("3.case条件语句为false")
		//fallthrough
	case true:
		fmt.Println("4.case条件语句为true")
		//fallthrough
	case false:
		fmt.Println("5.case条件语句为false")
		//fallthrough
	default:
		fmt.Println("6.默认case")
	}
}

3.select语句

select 是 Go 中的一个控制结构，类似于 switch 语句。

  • select 语句只能用于通道操作 ，每个 case 必须是一个通道操作，要么是发送要么是接收。
  • select 语句会监听所有指定的通道上的操作，一旦其中一个通道准备好就会执行相应的代码块。
  • 如果多个通道都准备好，那么 select 语句会随机选择一个通道执行。如果所有通道都没有准备好，那么执行 default 块中的代码。

Go 编程语言中 select 语句的语法如下：

go 复制代码 
select {
  case <- channel1:
    // 执行的代码
  case value := <- channel2:
    // 执行的代码
  case channel3 <- value:
    // 执行的代码

    // 你可以定义任意数量的 case

  default:
    // 所有通道都没有准备好，执行的代码
}
  • 每个 case 都必须是一个通道
  • 所有 channel 表达式都会被求值
  • 所有被发送的表达式都会被求值
  • 如果任意某个通道可以进行，它就执行，其他被忽略。
  • 如果有多个 case 都可以运行，select 会随机公平地选出一个执行，其他不会执行。
    否则：
    • 如果有 default 子句，则执行该语句。
    • 如果没有 default 子句，select 将阻塞，直到某个通道 可以运行；Go 不会重新对 channel 或值进行求值。

实例1：

go 复制代码 
package Select

import (
	"fmt"
	"time"
)

func Select() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		c1 <- "one"
	}()
	go func() {
		time.Sleep(2 * time.Second)
		c2 <- "two"
	}()

	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-c1:
			fmt.Println("received", msg1)
		case msg2 := <-c2:
			fmt.Println("received", msg2)
		}
	}
}
  • 以上实例中，我们创建了两个通道 c1 和 c2。
    select 语句等待两个通道的数据。如果接收到 c1 的数据，就会打印 "received one"；如果接收到 c2 的数据，就会打印 "received two"。

实例2：

go 复制代码 
package Select

import (
	"fmt"
	"time"
)

func Select1() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		c1 <- "one"
	}()
	go func() {
		time.Sleep(2 * time.Second)
		c2 <- "two"
	}()

	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-c1:
			fmt.Println("received", msg1)
		case msg2 := <-c2:
			fmt.Println("received", msg2)
		}
	}
}

func Select2() {
	// 定义两个通道
	ch1 := make(chan string)
	ch2 := make(chan string)

	// 启动两个 goroutine，分别从两个通道中获取数据
	go func() {
		for {
			ch1 <- "from 1"
		}
	}()
	go func() {
		for {
			ch2 <- "from 2"
		}
	}()

	// 使用 select 语句非阻塞地从两个通道中获取数据
	for {
		select {
		case msg1 := <-ch1:
			fmt.Println(msg1)
		case msg2 := <-ch2:
			fmt.Println(msg2)
		default:
			// 如果两个通道都没有可用的数据，则执行这里的语句
			fmt.Println("no message received")
		}
	}
}
  • 以上实例中，我们定义了两个通道，并启动了两个协程（Goroutine）从这两个通道中获取数据。在 main 函数中，我们使用 select 语句在这两个通道中进行非阻塞的选择，如果两个通道都没有可用的数据，就执行 default 子句中的语句。
    以上实例执行后会不断地从两个通道中获取到的数据，当两个通道都没有可用的数据时，会输出 "no message received"。

二、循环语句

1.for循环

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

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

  • 和 C 语言的 for 一样：
go 复制代码 
for init; condition; post { }

init： 一般为赋值表达式，给控制变量赋初值；

condition： 关系表达式或逻辑表达式，循环控制条件；

post： 一般为赋值表达式，给控制变量增量或减量。

  • 和 C 的 while 一样：
go 复制代码 
for condition { }
  • 和 C 的 for(;;) 一样：
go 复制代码 
for { }
  • for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
go 复制代码 
for key, value := range oldMap {
    newMap[key] = value
}

以上代码中的 key 和 value 是可以省略。

如果只想读取 key，格式如下：

go 复制代码 
for key := range oldMap

或者这样：

go 复制代码 
for key, _ := range oldMap

如果只想读取 value，格式如下：

go 复制代码 
for _, value := range oldMap

实例1：

go 复制代码 
package For

import "fmt"

func For() {
	sum := 0
	for i := 1; i <= 10; i++ {
		sum += i
	}
	fmt.Println(sum)
}

实例2：

go 复制代码 
package For

import "fmt"

func While() {
	sum := 1

	for sum <= 10 {
		sum += sum
	}
	fmt.Println(sum)
}
  • 以上实例是将init 和 post参数去掉，相当于是一个while循环

实例3：

go 复制代码 
package For

import "fmt"

func main() {
   sum := 0
   for {
      sum++ // 无限循环下去
   }
   fmt.Println(sum) // 无法输出
}
  • for后面什么也不跟就是无限循环；

实例4：

go 复制代码 
package For

import "fmt"

func Range() {
	strings := []string{"google", "runoob"}
	for i, s := range strings {
		fmt.Println(i, s)
	}

	numbers := [6]int{1, 2, 3, 5}
	for i, x := range numbers {
		fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
	}
}
  • For-each range 循环可以对字符串、数组、切片等进行迭代输出元素。

实例5：

go 复制代码 
package For

import "fmt"

func Range() {
	map1 := make(map[int]float32)
    map1[1] = 1.0
    map1[2] = 2.0
    map1[3] = 3.0
    map1[4] = 4.0
   
    // 读取 key 和 value
    for key, value := range map1 {
      fmt.Printf("key is: %d - value is: %f\n", key, value)
    }

    // 读取 key
    for key := range map1 {
      fmt.Printf("key is: %d\n", key)
    }

    // 读取 value
    for _, value := range map1 {
      fmt.Printf("value is: %f\n", value)
    }
}
  • For-each range也可以读取map中的k和v

三、defer语句

1.defer语句的作用

defer语句被用于预定对一个函数的调用。可以把这类被defer语句调用的函数称为延迟函数。
defer语句会将其后的函数调用推迟到当前所在函数体的生命周期结束后再执行，类似于c++的析构函数 。这个特性常用于处理成对的操作，如打开/关闭文件、获取/释放锁、连接/断开连接等 ，确保资源被适当地释放，即使在发生错误或提前返回的情况下也能保证执行。

defer作用：

  • 释放占用的资源
  • 捕捉处理异常
  • 输出日志

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。

实例

go 复制代码 
package Defer

import "fmt"

func Defer() {
	defer fmt.Println("main end1")
	defer fmt.Println("main end2")

	fmt.Println("0")
	fmt.Println("1")
}
  • defer语句调用的函数会在当前函数体生命周期结束后再出栈执行，多个defer语句调用函数的顺序类似于堆栈，后进先出；

2.defer和return的先后顺序

go 复制代码 
package Defer

import "fmt"

func deferFunc() int {
	fmt.Println("defer func called...")
	return 0
}

func returnFunc() int {
	fmt.Println("return func caller...")
	return 0
}

func ReturnAndDefer() int {
	defer deferFunc()
	return returnFunc()
}
  • 由于defer语句会将其后的函数调用推迟到当前所在函数体的生命周期结束后再出栈，而return语句是在}之前的，因此return会先执行，defer再执行；

3.recover错误拦截

运行时panic异常一旦被引发就会导致程序崩溃。

  • Go语言提供了专用于"拦截"运行时panic的内建函数recover 。它可以是当前的程序从运行时panic的状态中恢复并重新获得流程控制权。
  • 注意：recover只有在defer调用的函数中有效。

实例1：

go 复制代码 
package main

import "fmt"

func recoverFunc(i int) {
	//定义10个元素的数组
	var arr [10]int
	//错误拦截要在产生错误前设置
	//这里使用匿名函数进行错误拦截，在进行defer调用
	//相当于这个匿名函数在recoverFunc的生命周期结束后才被调用
	defer func() {
		//设置recover拦截错误信息
		err := recover()
		//产生panic异常，打印错误信息
		if err != nil {
			fmt.Println(err)
		}
	}()
	//根据函数参数为数组元素赋值
	//如果i的值超过数组下标 会报错误：数组下标越界
	arr[i] = 2
}

func main() {
	recoverFunc(10)
	fmt.Println("程序继续执行...")
}
  • 在上述实例中，我们定义了一个匿名函数来拦截panic，并用defer去掉用，这个匿名函数会在当前recoverFunc的生命周期结束后进行调用，recoverFunc函数中出现了数组越界的错误，之后被recover()拦截了，程序得以继续执行；

实例2：

go 复制代码 
package main

import "fmt"

func handlePanic() {
    if r := recover(); r != nil {
        fmt.Println("Recovered:", r)
    }
}

func performTask() {
    defer handlePanic()

    fmt.Println("Performing some task...")
    panic("Oops! Something went wrong!")
    fmt.Println("Task completed.")
}

func main() {
    performTask()
    fmt.Println("Main function continues.")
}
  • 在以上的实例中，panic函数调用后，异常被引发，当前performTask函数执行结束，defer调用的函数开始出栈，执行handlePanic函数，panic异常引发后，在handlePanic函数中recover拦截了异常，打印出错误信息，并让main函数继续运行。
相关推荐
nbsaas-boot2 小时前
Java 正则表达式白皮书：语法详解、工程实践与常用表达式库
开发语言·python·mysql
chao_7892 小时前
二分查找篇——搜索旋转排序数组【LeetCode】两次二分查找
开发语言·数据结构·python·算法·leetcode
Nejosi_念旧2 小时前
解读 Go 中的 constraints包
后端·golang·go
风无雨2 小时前
GO 启动 简单服务
开发语言·后端·golang
小明的小名叫小明2 小时前
Go从入门到精通（19）-协程（goroutine）与通道（channel）
后端·golang
光影少年2 小时前
从前端转go开发的学习路线
前端·学习·golang
斯普信专业组3 小时前
Go语言包管理完全指南：从基础到最佳实践
开发语言·后端·golang
我是苏苏4 小时前
C#基础：Winform桌面开发中窗体之间的数据传递
开发语言·c#
一只叫煤球的猫4 小时前
【🤣离谱整活】我写了一篇程序员掉进 Java 异世界的短篇小说
java·后端·程序员
斐波娜娜4 小时前
Maven详解
java·开发语言·maven
热门推荐
01【无标题】02集群聊天服务器---MySQL数据库的建立03Coze扣子平台完整体验和实践（附国内和国际版对比）04深度神经网络训练过程与常见概念05KGG转MP3工具|非KGM文件|解密音频06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Java类变量（静态变量）08使用Ruby接入实时行情API教程09DeepSeek各版本说明与优缺点分析10绿色建筑新态势：楼宇自控助力能效提升，推动成本优化新路径