Golang学习历程【第七篇闭包type defer panic recover了解time包】

news2025/2/15 18:59:43

Golang学习历程【第七篇闭包&type defer panic recover了解】

1. 闭包
- 1.1 闭包的定义
- 1.2 闭包的特点
- 1.3 闭包的示例
2. 类型(type)
- 2.1 自定义类型
- 2.2 类型示例
3. 延迟执行（Defer）
- 3.1 `defer` 的用法
- 3.2 `defer` 示例
4. 恐慌（Panic）和恢复（Recover）
- 4.1 `panic` 和 `recover` 的用法
- 4.2 `panic` 和 `recover` 示例
5. time包

1. 闭包

1.1 闭包的定义

闭包函数（Closure）是函数式编程中的一个重要概念。在Go语言中，闭包函数是指一个函数与其引用的环境的组合。闭包函数可以访问并修改其外部函数中的变量，即使外部函数已经执行完毕。

1.2 闭包的特点

闭包函数可以访问其外部函数的局部变量。
闭包函数可以修改其外部函数的局部变量。
闭包函数可以保持其外部函数的局部变量在函数执行完毕后仍然存在。

1.3 闭包的示例

package main

import "fmt"

/**
 * 闭包
 * 一个函数和与其相关的引用环境组合而成的实体
 */
func adder() func(int) int {
	sum := 0
	// 返回一个函数，函数引用了sum变量
	return func(x int) int {
		// 函数引用了sum变量
		sum += x
		return sum
	}
}
func main() {
	// 调用adder函数，返回一个函数，这个函数引用了sum变量
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		// 调用返回的函数，函数引用了sum变量
		fmt.Println(pos(i), neg(-2*i)) 
	}

	/**
	   - `adder` 函数返回一个闭包。每个闭包都绑定了自己的 `sum` 变量。
	   - `pos` 和 `neg` 是两个独立的闭包，它们各自维护自己的 `sum`。
	   运行结果
		0 0
		1 -2
		3 -6
		6 -12
		10 -20
		15 -30
		21 -42
		28 -56
		36 -72
		45 -90
	*/
}

2. 类型(type)

2.1 自定义类型

Go 允许使用 type 关键字定义新的类型。

2.2 类型示例

package main

import "fmt"

// 自定义一个函数类型，类型名：addFun
type addFun func(int) int

// 自定义一个int类型，类型名：selfint
type selfint int

func adder2(x int) addFun {
	return func(y int) int {
		return x + y
	}
}
func main() {
	// 定义一个eg函数，其类型为addFun，是一个函数类型
	var eg addFun = adder2(10)
	// 调用eg函数 ,eg函数是adder2函数的返回闭包函数，执行eg ==> adder2(10) + y ==> 10 + 15 = 25
	fmt.Println(eg(15))
	var num1 selfint = 10
	var num2 int = 20
	// 自定义类型selfint，不能直接与int类型进行运算，需要转换
	fmt.Println(num1 + selfint(num2))
	// 或者使用类型转换
	fmt.Println(int(num1) + num2)
	/**
	 * 运行结果：
	 * 25
	 * 30
	 * 30
	 */
}

3. 延迟执行（Defer）

3.1 `defer` 的用法

defer 语句会将其后面的函数调用推迟到外层函数返回之后执行。

3.2 `defer` 示例

package main

import "fmt"

func main() {
	// defer 是一个关键字，用于延迟执行一个函数调用，直到包含该 defer 语句的函数执行完毕。
	defer fmt.Println("world")
	fmt.Println("hello")
	/*
	 * 运行结果：
	 * hello
	 * world
	 */
}

4. 恐慌（Panic）和恢复（Recover）

Panic相当与抛出异常，Recover相当于捕获异常，Golang中没有try…catch

4.1 `panic` 和 `recover` 的用法

panic 用于表示程序遇到了无法处理的错误。
recover 用于从 panic 中恢复。

4.2 `panic` 和 `recover` 示例

package main

import "fmt"

func main() {
	// 定义一个延时函数并执行
	defer func() {
		// 延时函数，等待主线程执行结束，捕获panic
		if r := recover(); r != nil {
			// 打印panic信息
			fmt.Println("Recovered from", r)
		}
	}()
	// 执行语句 Starting the program
	fmt.Println("Starting the program")
	// 触发panic 相当于触发java的throw new Exception()
	panic("Something went wrong!")
	// 下面语句不会被执行
	fmt.Println("This line will not be executed")
	/*
	 * 运行结果：
	 * - `panic` 触发了一个恐慌，程序会中止执行。
	   - `recover` 捕获了恐慌，程序继续执行。
	 * Starting the program
	 * Recovered from Something went wrong!
	 */
}

5. time包

time包是Go语言标准库中提供的一个用于处理时间的包，它提供了时间相关的函数和数据类型，可以用于获取当前时间、格式化时间、解析时间等操作。
time包中的Now函数可以获取当前时间，它返回一个Time类型的值，表示当前时间。下面是一个简单的示例：

// 1. 获取当前时间
currentTime := time.Now()
fmt.Println("当前时间：", currentTime)
// 2. 获取当前时间的年、月、日、时、分、秒等信息
year := currentTime.Year()
month := currentTime.Month()
day := currentTime.Day()
hour := currentTime.Hour()
minute := currentTime.Minute()
second := currentTime.Second()
fmt.Printf("当前时间：%d年%d月%d日 %d时%d分%d秒\n", year, month, day, hour, minute, second)
// 3. 格式化时间
// time包提供了Format函数用于格式化时间，它接受一个格式字符串作为参数，返回一个字符串表示格式化后的时间。下面是一个简单的示例：
fmt.Println("格式化时间：", currentTime.Format("2006-01-02 15:04:05"))
// 4. 解析时间
// time包提供了Parse函数用于解析时间，它接受一个格式字符串和一个时间字符串作为参数，返回一个Time类型的值表示解析后的时间。下面是一个简单的示例：
timeStr := "2023-01-01 12:00:00"
parsedTime, err := time.Parse("2006-01-02 15:04:05", timeStr)
if err != nil {
	fmt.Println("解析时间失败：", err)
	return
}
fmt.Println("解析时间：", parsedTime)
// 5. 时间间隔
// time包提供了Duration类型表示时间间隔，它表示两个时间点之间的时间差。下面是一个简单的示例：
duration := time.Duration(10) * time.Second
fmt.Println("时间间隔：", duration)
// 6. 时间操作
// time包提供了Add函数用于将时间间隔添加到时间上，返回一个新的时间。下面是一个简单的示例：
newTime := currentTime.Add(duration)
fmt.Println("新时间：", newTime)
// 7. 时间比较
// time包提供了Before、After和Equal函数用于比较两个时间的大小关系。下面是一个简单的示例：
if currentTime.Before(parsedTime) {
	fmt.Println("当前时间在解析时间之前")
} else if currentTime.After(parsedTime) {
	fmt.Println("当前时间在解析时间之后")
} else {
	fmt.Println("当前时间与解析时间相等")
}
if currentTime.Equal(parsedTime) {
	fmt.Println("当前时间与解析时间相等")
}
/**
 * 以上运行结果：
 * 当前时间： 2023-10-13 10:18:00.0000007 +0800 CST m=+0.000014679
 * 当前时间： 2023年10月13日 10时18分0秒
 * 格式化时间： 2023-10-13 10:18:00
 * 解析时间： 2023-01-01 12:00:00 +0000 UTC
 * 时间间隔： 10s
 * 新时间： 2023-10-13 10:28:00.0000007 +0800 CST m=+10.000014679
 * 当前时间在解析时间之前
 * 当前时间与解析时间不相等
 */

总结：

获取当前时间： time.Now()
获取时间的详细信息： currentTime.Year() | currentTime.Month() | currentTime.Day() | currentTime.Hour() | currentTime.Minute() | currentTime.Second()
格式化时间： currentTime.Format(“2006-01-02 15:04:05”)
解析时间： time.Parse(“2006-01-02 15:04:05”, timeStr)
时间间隔： time.Duration(10) * time.Second
时间操作： currentTime.Add(duration)
时间比较： currentTime.Before(parsedTime) | currentTime.After(parsedTime) | currentTime.Equal(parsedTime)