^-^
【go语言】Golang语言特性
最近更新：2024-12-05   |   字数总计：3.1k   |   阅读估时：14分钟   |   阅读量：次
  1. Go语言特性
    1. defer、recover、panic
    2. interface隐式实现
    3. 通过通信共享内存
    4. 函数式编程与闭包
    5. 文件的copy与文件的读写

Go语言特性

defer、recover、panic

  • 应用场景
    1. 资源释放
    2. 异常捕获和处理
  • defer
    1. 用来声明一个延迟调用函数，该函数可以是匿名函数也可以是具名函数；
    2. defer函数执行时间（位置）：方法return之后，返回参数到调用方法之前；
    3. 可以在方法返回之后改变函数的返回值；
    4. 在方法结束（正常返回、异常结束）都会取调用defer声明的函数，可以有效避免因异常导致的资源无法释放的问题；
    5. 可以指定多个defer，多个延时函数执行顺序为后进先出；
    6. 常用于资源释放、异常捕获等场景，例如：关闭连接、关闭文件等；
    7. 配合recover可以实现异常捕获与处理；
    8. 不建议在for循环中使用defer；
  • recover
    1. 内置函数，可以让进入宕机流程中的goroutine中恢复过来；
    2. 仅在defer指定的延迟调用函数中有效，正常执行过程中，调用recover会返回nil并且没有其他任何效果；
    3. 如果当前的roroutine出现panic，调用recover可以捕获到panic的输入值，并且恢复正常的执行；
  • panic
    1. 一种异常机制（系统、自定义都是通过panic）
    2. 可通过panic函数主动抛出异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package p1

import (
	"fmt"
	"os"
	"log"
	"io"
)

// defer 关键词用来声明一个延迟调用函数
// 该函数可以是匿名函数也可以是具名函数
// defer延迟函数的执行为后进先出
func DeferCase1(){
	fmt.Println("开始执行DeferCase1")
	defer func(){
		fmt.Println("匿名函数defer1")
	}()
	defer f1()
	defer func(){
		fmt.Println("匿名函数defer2")
	}()
	fmt.Println("结束执行DeferCase1")

	/*
	开始执行DeferCase1
	结束执行DeferCase1
	匿名函数defer2
	具名deferf1
	匿名函数defer1
	*/
}

// 参数预计算
func DeferCase2(){
	i := 1
	// 传参方式
	defer func(j int) {
		fmt.Println("defer j:", j) 
	} (i + 1)
	// 闭包方式
	defer func() {
		fmt.Println("defer i:", i) 
	} ()
	i = 99
	fmt.Println("i:", i)
	/*
	i: 99
	defer i: 99
	defer j: 2 // 预计算
	*/
}

// 返回值
// defer函数执行在return之后
func DeferCase3(){
	i, j := f2()
	fmt.Printf("i:%d,j:%d,g:%d\n",i,*j,g)
	/*
	g: 100
	i:100,j:200,g:200
	*/
}

var g = 100
func f2()(int, *int){
	defer func(){
		g = 200
	}()
	fmt.Println("g:",g)
	return g, &g
}

func f1(){
	fmt.Println("具名deferf1")
}



func ExceptionCase(){
	defer func(){
		// 捕获异常，恢复协程，如果没有这个，程序会直接中断
		err := recover()
		if err != nil{
			// 异常处理,如数据库rollback
			fmt.Println("异常处理defer recover",err)
		}
	}()
	fmt.Println("开始执行ExceptionCase")
	panic("ExceptionCase抛出") // 抛出异常
	fmt.Println("结束执行ExceptionCase")
}

func FileReadCase(){
	file, err := os.Open("go.mod")
	if err != nil{
		log.Fatal(err)
	}
	defer func(){
		fmt.Println("释放文件资源")
	}()
	defer file.Close() // 不要写到err判断前面，因为file有可能不正常，或者直接为nil，这种情况下这种Close函数可能出问题
	buf := make([]byte, 1024)
	for{
		n, err := file.Read(buf)
		if err !=nil && err != io.EOF{
			log.Fatal(err)
		}
		if n == 0{
			break
		}
		fmt.Println(buf[:n])
	}
}

interface隐式实现

  1. interface无需任何关键词，只需要该对象的方式集中包含接口定义的所有方法且方法签名一致
  2. 对象实现接口可以借助struct内嵌的特性，实现接口的默认实现
  3. 类型T方法集包含全部receiver T方法；类型*T方法集包含receiver T + *T方法
  4. 类型T实例value或pointer可以调用全部的方法，编译器会自动转换
  5. 类型T实现接口，不管是T还是*T都实现了该接口
  6. 类型*T实现接口，只有T类型的指针实现了该接口
  • 应用场景
    1. 实现面向接口编程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package p1

import "fmt"

// 声明 Animal接口
// 定义行为
type Animal interface {
	// 吃
	Eat()
	// 喝
	Drink()
	// 睡觉
	Sleep()
	// 奔跑
	Run()
}

type animal struct {

}

// 括号中的a animal就是receiver，此时receiver是T
func (a animal) Eat() {
	fmt.Println("Animal Eat默认实现")
}

// 括号中的a *animal就是receiver，此时receiver是*T
func (a *animal) Drink() {
	fmt.Println("Animal Drink默认实现")
}

func (a animal) Sleep() {
	fmt.Println("Animal Sleep默认实现")
}

// 当我们的animal实现了Animal的所有方法后，就可以认为animal实现了Animal接口
func (a animal) Run() {
	fmt.Println("Animal Run默认实现")
}

func init(){
	// a := animal{}
	// a.Eat()
	// a.Drink(),T类型直接调用*T实现的接口，是完全没有问题的
}


type Cat struct{
	animal // 直接内嵌animal，那么cat直接实现了Animal接口
}

func NewCat() Animal {
	return &Cat{}
}

func (c *Cat) Eat(){ // override默认实现
	fmt.Println("Cat实现吃老鼠")
}


func NewDog() Animal {
	// return Dog{}
	return &Dog{} // 都可以，因为receiver *T也实现了 T的所有方法
}

type Dog struct {
	animal
}

func (a Dog) Eat() {
	fmt.Println("狗吃肉")
}

func (a Dog) Drink() {
	fmt.Println("狗喝水")
}

func (a Dog) Sleep() {
	fmt.Println("狗睡觉")
}

func (a Dog) Run() {
	fmt.Println("狗跑步")
}


func NewDove() Animal {
	// return Dove{} 这里不可以，因为*T的实现不会默认被T类型实现
	return &Dove{} 
}


type Dove struct {
	// 不做内嵌
}

func (a *Dove) Eat() {
	fmt.Println("鸽子吃肉")
}

func (a *Dove) Drink() {
	fmt.Println("鸽子喝水")
}

func (a *Dove) Sleep() {
	fmt.Println("鸽子睡觉")
}

func (a *Dove) Run() {
	fmt.Println("鸽子跑步")
}
  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package main

    import "interface/case"

    func main(){
    	cat := p1.NewCat()
    	animalLift(cat)

    	dog := p1.NewDog()
    	animalLift(dog)

    	dove := p1.NewDove()
    	animalLift(dove)
    }

    func animalLift(a p1.Animal){
    	a.Eat()
    	a.Drink()
    	a.Sleep()
    	a.Run()
    }

通过通信共享内存

  • 应用场景

    1. 协程间数据传递
    2. 并发场景下利用通道的阻塞机制，作为同步机制（类似队列）
    3. 利用channel关闭时发送广播的特性，作为协程退出通知

  • channel通过通信共享内存

    1. 方向：读、写、读写
    2. 协程间通信信道
    3. 阻塞协程
    4. 并发场景下的同步机制
    5. 通知协程退出
    6. 多路复用

  • 注意事项

    1. channel用于协程间通讯，必须存在读写双方，否则将造成死锁（也就是说必须用于协程间的通讯）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package p1

import (
	"fmt"
	"time"
)

// 协程间通信
func Communication(){
	// 定义可读可写通道
	ch := make(chan int, 0) // 没有缓冲，那么假如f1写入，f2不读，两个都会阻塞
 
	go communicationF1(ch) // 协程1
	go communicationF2(ch) // 协程2
}

// F1接收一个只写通道
func communicationF1(ch chan <- int){
	// 通过循环向通道写入 0-99
	for i:= 0;i<100;i++{
		ch <- i
	}
}

// F2接收一个只读通道
func communicationF2(ch <- chan  int){
	for i := range ch {
		fmt.Println(i)
	}
}

// 并发场景下，同步机制
func ConcurrentSync(){
	// 带缓冲的通道
	ch := make(chan int, 10) // 带缓冲，f2在缓冲没满的情况下不读，也不会立即阻塞f1
	go func(){ 
		for i:= 0;i<100;i++{
			ch <- i
		}
	}()
	go func(){ // 多协程并发写
		for i:= 0;i<100;i++{
			ch <- i
		}
	}()
	go func(){
		for i:=range ch{
			fmt.Println(i)
		}
	}()
}


// 通知协程退出与多路复用
func NoticeAndMultiplexing(){
	ch := make(chan int, 0)
	strch := make(chan string, 0)
	done := make(chan struct{}, 0)
	go noticeAndMultiplexingF1(ch)
	go noticeAndMultiplexingF2(strch)
	go noticeAndMultiplexingF3(ch,strch, done)
	time.Sleep(5 * time.Second)
	close(done) // 会向所有监听done这个通道的协程发送一个0值
}

func noticeAndMultiplexingF1(ch chan<- int){
	for i:=0;i<100;i++{
		ch<-i
	}
}
func noticeAndMultiplexingF2(ch chan<- string){
	for i:=0;i<100;i++{
		ch<-fmt.Sprintf("数字：%d",i)
	}
}

func noticeAndMultiplexingF3(ch<- chan int, strch <-chan string, done<-chan struct{}){
	i := 0
	for {
		// select 子句作为一个整体阻塞：三个channel中假设有一个通道可用，就不会阻塞；也就是任意通道准备好了，就继续执行
		select{
		case j := <-ch:
			fmt.Println(j)
		case str := <- strch:
			fmt.Println(str)
		case <-done:
			fmt.Println("收到退出通知，退出当前协程")
			return
		}
		i++
		fmt.Println("累计执行次数：",i)
	}
}
  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package main

    import "channel-select/case"

    import (
    	"os"
    	"os/signal"
    )

    func main(){
    	 
    	// p1.Communication()
    	// p1.ConcurrentSync()
    	p1.NoticeAndMultiplexing()

    	// 主协程先通过channel的阻塞机制（没有值就会阻塞）等一下其他协程执行任务
    	ch := make(chan os.Signal, 0)
    	signal.Notify(ch, os.Interrupt, os.Kill)
    	<- ch
    }

函数式编程与闭包

  • 头等函数：支持头等函数的开发语言允许将函数分配给变量；作为参数传递给其他函数；作为其他函数的返回值

  • 函数式编程的应用：

    1. 闭包：函数引用了其他函数内部变量，用于需要外部函数内部变量参与计算的场景
    2. 中间件：在不影响原有函数定义的前提下为函数增加额外功能
    3. 函数类型对象

  • 闭包函数陷阱：

    1. for循环使用闭包，可能会有问题

  • func.go

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    package p1

    import (
    	// "fmt"
    	"errors"
    	"log"
    )

    // 函数返回值可以带名字，这样就不用显式返回了
    func Sum(a,b int)(sum int, err error){
    	if a <= 0 && b <= 0 {
    		err = errors.New("两数相加要求两数不能同时小于等于0")
    		return
    	}
    	sum = a + b
    	return
    }



    // 将函数作为输入输出，实现中间件
    func LogMiddleware(infc func(a,b int)(int, error)) func(a,b int)(int, error){
    	// 返回的函数为闭包函数，其中infc为闭包函数使用的外部函数内部变量
    	return func(a,b int)(int, error){
    		log.Printf("日志中间件，记录操作数：a:%d,b:%d",a,b)
    		return infc(a,b)
    	}
    }

    // 优雅一点
    // 将函数作为类型
    type SumFunc func(a,b int) (int, error)

    func LogMiddleware2(infc SumFunc) SumFunc{
    	// 返回的函数为闭包函数，其中infc为闭包函数使用的外部函数内部变量
    	return func(a,b int)(int, error){
    		log.Printf("日志中间件，记录操作数：a:%d,b:%d",a,b)
    		return infc(a,b)
    	}
    }

    // 声明receiver为函数类型的方法，也就是将函数作为对象，并为对象添加方法
    func (sum SumFunc) Accumulation(list ...int)(int, error){
    	s := 0
    	var err error
    	for _,i := range list{
    		s, err = sum(s, i)
    		if err != nil{
    			return s,err
    		} 
    	}
    	return s,err
    }

  • closure.go

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    package p1

    import "log"

    func Fib(n int) int{
    	if n <=2 {
    		log.Fatal("请选择大于2的位置")
    	}
    	t := tool()
    	var res int
    	for i:=0;i<n-2;i++{
    		res = t()
    	}
    	return res
    }


    // 斐波那契数列，X0+X1 = X2，求Xn
    func tool() func()int{
    	var x0 = 0
    	var x1 = 1
    	var x2 = 0
    	return func() int{
    		x2 = x0 + x1
    		x0 = x1
    		x1 = x2
    		return x2
    	}
    }

    func ClosureTrap(){
    	for i:=0;i<10;i++{
    		go func(){
    			fmt.Println(i) // 循环里的协程的闭包，会有意外的结果，使用闭包的错误方式，正确的方式需要传参
    		}()
    	}
    }

  • main.go

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package main

    import (
    	"function/case"
    	"fmt"
    )

    func main(){
    	fmt.Println(p1.Sum(1,2))
    	f1 := p1.Sum
    	fmt.Println(f1(1,2))
    	// 将函数作为输入输出，实现中间件
    	f2 := p1.LogMiddleware2(f1)
    	fmt.Println(f2(1,2))

    	f3 := p1.SumFunc(f1) // 强制类型转换
    	fmt.Println(f3.Accumulation(1,2,3,4))
    	fmt.Println(f2.Accumulation(1,2,3,4))

    	fmt.Println(p1.Fib(5))
    }

文件的copy与文件的读写

  • 应用场景
    1. 上传下载文件
    2. 大文件分片传输
    3. 文件移动
    4. 文件内容按行获取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
package p1

import (
	"os"
	"log"
	"path"
	"io"
	"strings"
	"fmt"
	"bufio"
)

// 源文件目录
const sourceDir = "source-file/"
const destDir = "dest-file/"

func getFiles(dir string) []string{
	fs, err := os.ReadDir(dir)
	if err != nil {
		log.Fatal(err)
	}
	list := make([]string, 0)
	for _,f := range fs{
		if f.IsDir(){
			continue
		}
		fullName := strings.Trim(dir, "/") + "/" + f.Name()
		list = append(list, fullName)
	}
	return list
}

/* 文件复制 */
func CopyDirToDir(){
	list := getFiles(sourceDir)
	for _,f := range list{
		_,name := path.Split(f)
		destFileName := destDir + "copy/" + name
		// 复制文件
		COPYFile(f, destFileName)
	}
}

func COPYFile(strName, destName string) (int64, error){
	src, err := os.Open(strName)
	if err != nil{
		log.Fatal(err)
	}
	defer src.Close()
	dst,err := os.OpenFile(destName, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil{
		log.Fatal(err)
	}
	defer dst.Close()
	return io.Copy(dst, src)
}

/* 一次性文件读写 */
func ReadWriteFiles(){
	list := getFiles(sourceDir)
	for _, f := range list {
		bytes, err := os.ReadFile(f)
		if err != nil{
			log.Fatal(err)
		}
		_, name := path.Split(f)
		destName := destDir + "normal/" + name
		err = os.WriteFile(destName, bytes, 0644)
		if err != nil{
			log.Fatal(err)
		}
	}
}

/* 分片读写 */
func OneSideReadWriteToDest(){
	list := getFiles(sourceDir)
	for _, f := range list {
		_, name := path.Split(f)
		destName := destDir + "one-side/" + name
		OneSideReadWrite(f, destName)
	}
}

func OneSideReadWrite(srcName, destName string){
	src, err := os.Open(srcName)
	if err != nil {
		log.Fatal(err)
	}
	defer src.Close()
	dst,err := os.OpenFile(destName, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil{
		log.Fatal(err)
	}
	defer dst.Close()
	buf := make([]byte, 1024)
	for{
		n, err := src.Read(buf)
		if err != nil && err != io.EOF{
			log.Fatal(err)
		}
		if n == 0{
			break
		}
		dst.Write(buf[:n])
	}
}

/* 按行读取 */
const GOMOD = "go.mod"
// 一次性读取文件
// 按行拆分并打印
// 适合小文件读取
func ReadLine1() {
	fileHandler, err := os.OpenFile(GOMOD,os.O_RDONLY,0444)
	if err != nil {
		log.Fatal(err)
	}
	defer fileHandler.Close()
	bytes, err := io.ReadAll(fileHandler)
	if err != nil {
		log.Fatal(err)
	}
	list := strings.Split(string(bytes), "\n")
	for _,l := range list{
		fmt.Println(l)
	}
}

// 通过bufio按行读取
// bufio通过对io模块的封装，提供了数据的缓冲功能，能一定程度上减少大数据块读写带来的开销
// 当发起读写操作时，会尝试从缓冲区读取数据，缓冲区没有数据，才会从数据源获取
// 缓冲区大小默认为4K
func ReadLine2(){
	fileHandler, err := os.OpenFile(GOMOD,os.O_RDONLY,0444)
	if err != nil {
		log.Fatal(err)
	}
	defer fileHandler.Close()
	reader := bufio.NewReader(fileHandler)
	for{
		line, err := reader.ReadString('\n')
		if err == io.EOF{
			break
		}
		fmt.Print(line)
	}
}

// 通过scanner按行读取
// 单行默认大小64K
func ReadLine3(){
	fileHandler, err := os.OpenFile(GOMOD,os.O_RDONLY,0444)
	if err != nil {
		log.Fatal(err)
	}
	defer fileHandler.Close()
	scanner := bufio.NewScanner(fileHandler)
	for scanner.Scan(){
		line := scanner.Text()
		fmt.Println(line)
	}
}
2024-12-03 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go语言】Golang并发编程 下一篇：【go语言】Golang语言基础
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题