Go函数、包和错误处理

95 阅读 0 评论 63 点赞

我是靠谱客的博主机智小土豆，这篇文章主要介绍Go函数、包和错误处理，现在分享给大家，希望可以做个参考。

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
package main
import(
	"fmt"
)

/*
	func 函数名 (形参列表) (返回值列表) {
		执行语句
		return 返回值列表
	}
*/

func cal (n1 float64, n2 float64, operator byte) float64 {
	var res float64
	switch operator {
	case '+':
		res = n1 + n2
	case '-':
		res = n1 - n2
	case '*':
		res = n1 * n2
	case '/':
		res = n1 / n2
	default:
		fmt.Println("输入有误")
	}
	return res
}

func main(){
	var operator byte
	var n1 float64
	var n2 float64
	fmt.Scanln(&n1)
	fmt.Scanln(&operator)
	fmt.Scanln(&n2)
	result := cal(n1,n2,operator)
	fmt.Println(result)
}

//Go函数不支持函数重载

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//支持函数返回值命名
package main
import(
	"fmt"
)

func getSumAndSub (n1 int, n2 int) (sum int, sub int) {
	sub = n1 - n2
	sum = n1 + n2
	return
}

func main(){
	a1,b1 := getSumAndSub(10,20)
	fmt.Println(a1,b1)
}

包

包的本质是创建不同的文件夹存放程序文件
go的每一个文件都属于一个包，即go使以包的形式管理文件和项目目录结构
包的三大作用
- 区分相同名字的函数、变量等标识符
- 当程序文件很多时，可以更好的管理项目
- 控制函数、变量等访问范围，即作用域
打包基本语法
- 复制代码package 包名
```
1
2
package 包名
```
引入包的基本语法
- 复制代码import "包的路径"
```
1
2
import "包的路径"
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ySc6FJqu-1622206087527)(C:Users51936AppDataRoamingTyporatypora-user-imagesimage-20210325213313872.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v4YHzIWm-1622206087528)(C:Users51936AppDataRoamingTyporatypora-user-imagesimage-20210325213344720.png)]
包使用细节
- 在给一个文件打包时，该包对应一个文件夹，比如此处的utils文件夹对应的包名就是utils，文件的包名通常和文件所在的文件夹名一致，一般为小写字母
- 当一个文件要使用其他函数或变量时，需要先引入对应的包
- package指令在文件第一行，其次是import指令
- 如果包名较长，Go支持给包取别名，取别名后原来的包名不能使用
  - 复制代码util"project01/utils"
```
1
2
util"project01/utils"
```
- 若果要编译成一个可执行程序文件，需要将此包声明为main，即package main，如果是写一个库，包名可以自定义

函数调用机制底层

栈区：基本数据类型一般分配到栈区，编译器存在一个逃逸分析
堆区：引用数据类型一般分配到堆区，编译器存在一个逃逸分析
代码区：存放代码的地方
在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其他的栈的空间区分开
在每个函数对应的栈中，数据空间时独立的
当一个函数调用完毕之后，程序会销毁这个函数对应的栈空间
基本数据类型和数组默认都是值传递的

return语句

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//Go函数支持返回多个值
/*基本语法
func 函数名 (形参列表) (返回值类型列表) {
	语句
	return 返回值列表
}
*/

//如果返回多个值在接收时希望忽略某个返回值，可以使用_符号表示占位忽略
//如果返回值只有一个，返回值列表可以不写()

func a (n1 int,n2 int) (int,int) {
	sum := n1 + n2
	sub := n1 - n2
	return sum,sub
}

自定义数据类型

复制代码

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

//基本语法
/*
type 自定义数据类型名 数据类型
*/

func main(){
	type myInt int

	var num1 myInt
	var num2 int
	num1 = 40
	num2 = int(num1)//go认为myInt与int是两个类型，需要显示转换
	fmt.Println(num1,num2)
	
}

init函数

复制代码

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
package main
import(
	"fmt"
)

//每个源文件都可以包含一个init函数，该函数会在main函数执行前被Go运行框架调用
//即init会在main函数前被调用
//init函数可以用于作初始化
//如果一个文件中包含全局变量定义，init函数和main函数
//执行的流程是 全局变量定义->init函数->main函数

var age = test()
//为了看到全局变量是先被初始化的，可以使用函数
func test() int {
	fmt.Println("test()")
	return 90
}

func init(){
	fmt.Println("init()...")
}
func main(){
	fmt.Println("main()...")
}

匿名函数

复制代码

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
package main

import(
	"fmt"
)
//Go支持匿名函数，匿名函数就是没有名字的函数
//如果希望某个函数只使用一次，可以使用匿名函数
//匿名函数也可以实现多次调用

//方式三
//全局匿名函数
var (
	//Fun1是一个全局匿名函数
	Fun1 = func (n1 int,n2 int) int {
		return n1 * n2
	}
)

func main(){
	//使用方式一
	//在定义匿名函数的时候就直接调用，这种方式匿名函数只能调用一次
	res1 := func (n1 int,n2 int) int {
		return n1 + n2
	} (10,20)
	fmt.Println(" res1=",res1)

	//使用方式二
	//将匿名函数赋给变量
	//该变量的数据类型就是函数类型，该变量不是函数名
	//可以通过a实现多次调用
	a := func (n1 int, n2 int) int {
		return n1 + n2
	}
	res2 := a(10,20)
	res3 := a(20,30)
	fmt.Println(" res2=",res2)
	fmt.Println(" res3=",res3)

	//全局匿名函数的使用
	res4 := Fun1(4,9)
	fmt.Println("res4=",res4)
}

闭包

复制代码

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 main
import(
	"fmt"
)

//闭包就是一个函数和与其相关的引用环境组合的一个整体（实体）
//即定义在函数内的函数
//累加器
//AddUpper是一个函数，返回的数据类型是fun (int) int
//闭包的说明
/*var n int = 10
return func (x int) int {
		n = n + x
		return n
	}
*/
//返回的是一个匿名函数，这个匿名函数引用到函数外的n
//因此该匿名函数和n形成一个整体，构成闭包
//当反复调用函数时，因为n时初始化一次，所以每调用一次就进行累计

//n相当于闭包中的全局函数
func AddUpper() func (int) int {
	var n int = 10
	return func (x int) int {
		n = n + x
		return n
	}
}

func main(){
	
    f := AddUpper()//f类型为func (int)int
	fmt.Println(f(1))//11
	fmt.Println(f(2))//13
	fmt.Println(f(2))//16
}

复制代码

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
//编写一个函数makeSuffix（suffix string)
//可以接收一个文件后缀名(比如.jpg)，并返回一个闭包
//调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg)
//则返回文件名.jpg，如果有则返回原文件名
//要求使用闭包的方式完成
package main
import(
	"fmt"
	"strings"
)

func makeSuffix (suffix string) func (string) string {
	return func  (name string) string {
		//如果name没有指定后缀，则加上，否则就返回原来名字
		if !strings.HasSuffix(name,suffix) {
			return name + suffix
		}

		return name
	}
}

func main(){
	f2 := makeSuffix(".jpg")
	fmt.Println("文件名处理后=",f2("winter"))
	fmt.Println("文件名处理后=",f2("bird,jpg"))
}

defer

复制代码

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
package main
import(
	"fmt"
)

//在函数中，经常需要创建资源（如数据库连接、文件句柄、锁等）
//为了在函数执行后及时释放资源
//Go提供defer(延时机制)

func sum (n1 int, n2 int) int {
	//当执行到defer时，暂时不执行，会将defer后面的语句压入到独立的栈（defer栈）
	//当函数执行完毕后，再从defer栈，按照先进后出的方式出栈，执行
	//在defer将语句放入到栈时，也会把相关的值拷贝同时入栈
	defer fmt.Println("ok1 n1=",n1)//3 ok1 n1=10
	defer fmt.Println("ok2 n2=",n2)//2 ok2 n2=20
	n1++
	n2++
	res := n1 + n2
	fmt.Println("ok3 res=",res)//1 ok3 res=32
	return res
}

func main(){
	res := sum (10,20) 
	fmt.Println("res=",res)//4 res=32
}

//defer在golang中通常做法
//创建资源后，比如（打开了文件，获取了数据库的链接或者是锁链接）
//可以执行defer file.Close()defer connect.Close()
//在defer后，可以继续使用创建资源
//当函数完毕后，系统会依次从defer栈中取出语句，关闭资源

字符串常用的系统函数

复制代码

package main
import (
	"fmt"
	"strconv"
	"strings"
)

func main(){

//统计字符串的长度，按字节 len(str)
	golang的编码统一为utf-8 (ascii的字符(字母和数字) 占一个字节，汉字占用3个字节)
	str := "hello北" 
	fmt.Println("str len=", len(str)) // 8

str2 := "hello北京"
	//字符串遍历，同时处理有中文的问题 r := []rune(str)
	r := []rune(str2)
	for i := 0; i < len(r); i++ {
		fmt.Printf("字符=%cn", r[i])
	}

//字符串转整数:	 n, err := strconv.Atoi("12")
	n, err := strconv.Atoi("123")
	if err != nil {
		fmt.Println("转换错误", err)
	}else {
		fmt.Println("转成的结果是", n)
	}

//4)整数转字符串  str = strconv.Itoa(12345)
	str = strconv.Itoa(12345)
	fmt.Printf("str=%v, str=%Tn", str, str)

//5)字符串 转 []byte:  var bytes = []byte("hello go")
	var bytes = []byte("hello go")
	fmt.Printf("bytes=%vn", bytes)

//6)[]byte 转 字符串: str = string([]byte{97, 98, 99})
	str = string([]byte{97, 98, 99}) 
	fmt.Printf("str=%vn", str)

//10进制转 2, 8, 16进制:  str = strconv.FormatInt(123, 2),返回对应的字符串
	str = strconv.FormatInt(123, 2)
	fmt.Printf("123对应的二进制是=%vn", str)
	str = strconv.FormatInt(123, 16)
	fmt.Printf("123对应的16进制是=%vn", str)

//查找子串是否在指定的字符串中: strings.Contains("seafood", "foo") //true
	b := strings.Contains("seafood", "mary")
	fmt.Printf("b=%vn", b)

//统计一个字符串有几个指定的子串 ： strings.Count("ceheese", "e") //4
	num := strings.Count("ceheese", "e")
	fmt.Printf("num=%vn", num)

//10)不区分大小写的字符串比较(==是区分字母大小写的): fmt.Println(strings.EqualFold("abc", "Abc")) // true

b = strings.EqualFold("abc", "Abc")
	fmt.Printf("b=%vn", b) //true

fmt.Println("结果","abc" == "Abc") // false //区分字母大小写

//11)返回子串在字符串第一次出现的index值，如果没有返回-1 : 
	//strings.Index("NLT_abc", "abc") // 4

index := strings.Index("NLT_abcabcabc", "abc") // 4
	fmt.Printf("index=%vn",index)

//12)返回子串在字符串最后一次出现的index，
	//如没有返回-1 : strings.LastIndex("go golang", "go")

index = strings.LastIndex("go golang", "go") //3
	fmt.Printf("index=%vn",index)

//将指定的子串替换成 另外一个子串: strings.Replace("go go hello", "go", "go语言", n) 
	//n可以指定你希望替换几个，如果n=-1表示全部替换

str2 = "go go hello"
	str = strings.Replace(str2, "go", "北京", -1)
	fmt.Printf("str=%v str2=%vn", str, str2)

//按照指定的某个字符，为分割标识，将一个字符串拆分成字符串数组： 
	//strings.Split("hello,wrold,ok", ",")
	strArr := strings.Split("hello,wrold,ok", ",")
	for i := 0; i < len(strArr); i++ {
		fmt.Printf("str[%v]=%vn", i, strArr[i])
	} 
	fmt.Printf("strArr=%vn", strArr)

//15)将字符串的字母进行大小写的转换: 
	//strings.ToLower("Go") // go strings.ToUpper("Go") // GO

str = "goLang Hello"
	str = strings.ToLower(str) 
	str = strings.ToUpper(str) 
	fmt.Printf("str=%vn", str) //golang hello

//将字符串左右两边的空格去掉： strings.TrimSpace(" tn a lone gopher ntrn   ")
	str = strings.TrimSpace(" tn a lone gopher ntrn   ")
	fmt.Printf("str=%qn", str)

//17)将字符串左右两边指定的字符去掉 ： 
	//strings.Trim("! hello! ", " !")  // ["hello"] //将左右两边 ! 和 " "去掉
	str = strings.Trim("! he!llo! ", " !")
	fmt.Printf("str=%qn", str)

//20)判断字符串是否以指定的字符串开头: 
	//strings.HasPrefix("ftp://192.168.10.1", "ftp") // true

b = strings.HasPrefix("ftp://192.168.10.1", "hsp") //true
	fmt.Printf("b=%vn", b)
}

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
package main
import (
	"fmt"
	"strconv"
	"strings"
)

func main(){

	//统计字符串的长度，按字节 len(str)
	golang的编码统一为utf-8 (ascii的字符(字母和数字) 占一个字节，汉字占用3个字节)
	str := "hello北" 
	fmt.Println("str len=", len(str)) // 8


	str2 := "hello北京"
	//字符串遍历，同时处理有中文的问题 r := []rune(str)
	r := []rune(str2)
	for i := 0; i < len(r); i++ {
		fmt.Printf("字符=%cn", r[i])
	}


	//字符串转整数:	 n, err := strconv.Atoi("12")
	n, err := strconv.Atoi("123")
	if err != nil {
		fmt.Println("转换错误", err)
	}else {
		fmt.Println("转成的结果是", n)
	}

	//4)整数转字符串  str = strconv.Itoa(12345)
	str = strconv.Itoa(12345)
	fmt.Printf("str=%v, str=%Tn", str, str)

	//5)字符串 转 []byte:  var bytes = []byte("hello go")
	var bytes = []byte("hello go")
	fmt.Printf("bytes=%vn", bytes)

	//6)[]byte 转 字符串: str = string([]byte{97, 98, 99})
	str = string([]byte{97, 98, 99}) 
	fmt.Printf("str=%vn", str)

	//10进制转 2, 8, 16进制:  str = strconv.FormatInt(123, 2),返回对应的字符串
	str = strconv.FormatInt(123, 2)
	fmt.Printf("123对应的二进制是=%vn", str)
	str = strconv.FormatInt(123, 16)
	fmt.Printf("123对应的16进制是=%vn", str)

	//查找子串是否在指定的字符串中: strings.Contains("seafood", "foo") //true
	b := strings.Contains("seafood", "mary")
	fmt.Printf("b=%vn", b) 

	//统计一个字符串有几个指定的子串 ： strings.Count("ceheese", "e") //4
	num := strings.Count("ceheese", "e")
	fmt.Printf("num=%vn", num)

	//10)不区分大小写的字符串比较(==是区分字母大小写的): fmt.Println(strings.EqualFold("abc", "Abc")) // true

	b = strings.EqualFold("abc", "Abc")
	fmt.Printf("b=%vn", b) //true

	fmt.Println("结果","abc" == "Abc") // false //区分字母大小写

	//11)返回子串在字符串第一次出现的index值，如果没有返回-1 : 
	//strings.Index("NLT_abc", "abc") // 4

	index := strings.Index("NLT_abcabcabc", "abc") // 4
	fmt.Printf("index=%vn",index)

	//12)返回子串在字符串最后一次出现的index，
	//如没有返回-1 : strings.LastIndex("go golang", "go")

	index = strings.LastIndex("go golang", "go") //3
	fmt.Printf("index=%vn",index)

	//将指定的子串替换成 另外一个子串: strings.Replace("go go hello", "go", "go语言", n) 
	//n可以指定你希望替换几个，如果n=-1表示全部替换

	str2 = "go go hello"
	str = strings.Replace(str2, "go", "北京", -1)
	fmt.Printf("str=%v str2=%vn", str, str2)

	//按照指定的某个字符，为分割标识，将一个字符串拆分成字符串数组： 
	//strings.Split("hello,wrold,ok", ",")
	strArr := strings.Split("hello,wrold,ok", ",")
	for i := 0; i < len(strArr); i++ {
		fmt.Printf("str[%v]=%vn", i, strArr[i])
	} 
	fmt.Printf("strArr=%vn", strArr)

	//15)将字符串的字母进行大小写的转换: 
	//strings.ToLower("Go") // go strings.ToUpper("Go") // GO

	str = "goLang Hello"
	str = strings.ToLower(str) 
	str = strings.ToUpper(str) 
	fmt.Printf("str=%vn", str) //golang hello

	//将字符串左右两边的空格去掉： strings.TrimSpace(" tn a lone gopher ntrn   ")
	str = strings.TrimSpace(" tn a lone gopher ntrn   ")
	fmt.Printf("str=%qn", str)

	//17)将字符串左右两边指定的字符去掉 ： 
	//strings.Trim("! hello! ", " !")  // ["hello"] //将左右两边 ! 和 " "去掉
	str = strings.Trim("! he!llo! ", " !")
	fmt.Printf("str=%qn", str)

	//20)判断字符串是否以指定的字符串开头: 
	//strings.HasPrefix("ftp://192.168.10.1", "ftp") // true

	b = strings.HasPrefix("ftp://192.168.10.1", "hsp") //true
	fmt.Printf("b=%vn", b)
}

Go时间和日期函数

复制代码

package main

//时间和日期相关函数需要导入time包
import(
	"fmt"
	"time"
)

func main () {
	//获取当前时间
	//now := time.Now()//now的数据类型为time.Time
	now := time.Now()
	fmt.Printf("now=%v now type=%Tn",now,now)

//通过now获取年月日，时分秒
	fmt.Printf("年=%vn",now.Year())
	fmt.Printf("月=%vn",now.Month())
	fmt.Printf("月=%vn",int(now.Month()))
	fmt.Printf("日=%vn",now.Day())
	fmt.Printf("时=%vn",now.Hour())
	fmt.Printf("分=%vn",now.Minute())
	fmt.Printf("秒=%vn",now.Second())

//格式化日期时间
	
	//方式一 使用Printf或Sprintf
	fmt.Printf("当前年月日 %d-%d-%d %d:%d:%d n",now.Year(),
now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())

dateStr := fmt.Sprintf("当前年月日 %d-%d-%d %d:%d:%d n",now.Year(),
	now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
	fmt.Printf("dateStr=%vn",dateStr)

//方式二
	//使用now.Fowmat() 参数的数字时固定的
	fmt.Printf(now.Format("2006/01/02 15：04：05"))
	fmt.Println()
	fmt.Printf(now.Format("2006-01-02"))
	fmt.Println()
	fmt.Printf(now.Format("15:04:05"))
	fmt.Println()

//时间常量
	/*
	const (
		Nanosecond Duration = 1//纳秒
		Microsecond = 1000*Nanosecond//微秒
		Millisecond = 1000*Microsecond//毫秒
		Second = 1000*Millisecond//秒
		Minute = 60 * Second//分钟
		Hour = 60 * Minute//小时
	)
	*/
	//常量的作用：在程序中可用于获取指定时间单位

//需求，每隔1秒打印一个数字，打到100就退出
	i := 0
	for {
		i++
		fmt.Println(i)
		//休眠
		//Sleep中参数必须为整数
		time.Sleep(time.Second)
		if i == 100 {
			break
		}
	}

//获取当前unix时间戳和unixnano时间戳
	//可以获取随机数字
	fmt.Printf("unix的时间戳=%v unixnano的时间戳=%vn",now.Unix(),now.UnixNano())

}

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
package main

//时间和日期相关函数需要导入time包
import(
	"fmt"
	"time"
)

func main () {
	//获取当前时间
	//now := time.Now()//now的数据类型为time.Time
	now := time.Now()
	fmt.Printf("now=%v now type=%Tn",now,now)

	//通过now获取年月日，时分秒
	fmt.Printf("年=%vn",now.Year())
	fmt.Printf("月=%vn",now.Month())
	fmt.Printf("月=%vn",int(now.Month()))
	fmt.Printf("日=%vn",now.Day())
	fmt.Printf("时=%vn",now.Hour())
	fmt.Printf("分=%vn",now.Minute())
	fmt.Printf("秒=%vn",now.Second())

	//格式化日期时间
	
	//方式一 使用Printf或Sprintf
	fmt.Printf("当前年月日 %d-%d-%d %d:%d:%d n",now.Year(),
now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())

	dateStr := fmt.Sprintf("当前年月日 %d-%d-%d %d:%d:%d n",now.Year(),
	now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
	fmt.Printf("dateStr=%vn",dateStr)

	//方式二
	//使用now.Fowmat() 参数的数字时固定的
	fmt.Printf(now.Format("2006/01/02 15：04：05"))
	fmt.Println()
	fmt.Printf(now.Format("2006-01-02"))
	fmt.Println()
	fmt.Printf(now.Format("15:04:05"))
	fmt.Println()

	//时间常量
	/*
	const (
		Nanosecond Duration = 1//纳秒
		Microsecond = 1000*Nanosecond//微秒
		Millisecond = 1000*Microsecond//毫秒
		Second = 1000*Millisecond//秒
		Minute = 60 * Second//分钟
		Hour = 60 * Minute//小时
	)
	*/
	//常量的作用：在程序中可用于获取指定时间单位

	//需求，每隔1秒打印一个数字，打到100就退出
	i := 0
	for {
		i++
		fmt.Println(i)
		//休眠
		//Sleep中参数必须为整数
		time.Sleep(time.Second)
		if i == 100 {
			break
		}
	}

	//获取当前unix时间戳和unixnano时间戳
	//可以获取随机数字
	fmt.Printf("unix的时间戳=%v unixnano的时间戳=%vn",now.Unix(),now.UnixNano())

}

内置函数

len:求长度
new:用来分配内存，主要用来分配值类型
- 复制代码package main import( "fmt" ) func main(){ num1 := 100 fmt.Printf("num1的类型%T,num1的值%v,num1的地址%vn",num1,num1,&num1) num2 := new(int) //num2的类型为int* fmt.Printf("num2的类型%T,num2的值%v,num2的地址%v,num2指向的值%vn",num2,num2,&num2,*num2) }
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import(
	"fmt"
)

func main(){
	num1 := 100
	fmt.Printf("num1的类型%T,num1的值%v,num1的地址%vn",num1,num1,&num1)

	num2 := new(int)
	//num2的类型为int*
	fmt.Printf("num2的类型%T,num2的值%v,num2的地址%v,num2指向的值%vn",num2,num2,&num2,*num2)
}
```
make：用来分配内存，主要用来分配引用类型

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
package main
import(
	"fmt"
)

//Go不支持传统的try...catch...finall等处理方式
//Go中引入的处理方式为defer，panic，recover
//Go中可以抛出一个panic异常，然后再defer中通过recover捕获这个异常，然后正常处理

func test () {
	//使用defer + recover处理异常
	defer func() {
		err := recover()//recover（）内置函数，可以捕获到异常
		if err != nil {//说明捕获到异常
			fmt.Println("err=",err)
		}
	}()
	num1 : = 10
	num2 := 0
	res := num1 / num2
	fmt.Println("res=",res)
}

func main(){

	test()
	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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main
import(
	"fmt"
	"errors"
)
//在Go中，支持自定义错误，使用error.New和panic内置函数
//error.New("错误说明")，会返回一个error类型的值，表示一个错误
//panic内置函数，接收一个interface{}类型的值（即任何值）作为参数
//可以接收error类型的变量，输出错误信息，并退出程序

func readConf (name string) (err error) {
	if name == "config.ini" {
		//读取...
		return nil
	} else {
		//返回一个自定义错误
		return errors.New("读取文件错误...")
	}
}

func test () {
	err := readConf("config.ini")
	if err != nil {
		//读取文件发生错误，就输出这个错误，并终止程序
		panic(err)
	}

	fmt.Println("test()继续执行")
}

func main() {
	test()
	fmt.Println("main()下面的代码")
}

est()
fmt.Println(“main()下面的代码”)
}

复制代码

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

#### Go的自定义错误

```go
package main
import(
	"fmt"
	"errors"
)
//在Go中，支持自定义错误，使用error.New和panic内置函数
//error.New("错误说明")，会返回一个error类型的值，表示一个错误
//panic内置函数，接收一个interface{}类型的值（即任何值）作为参数
//可以接收error类型的变量，输出错误信息，并退出程序

func readConf (name string) (err error) {
	if name == "config.ini" {
		//读取...
		return nil
	} else {
		//返回一个自定义错误
		return errors.New("读取文件错误...")
	}
}

func test () {
	err := readConf("config.ini")
	if err != nil {
		//读取文件发生错误，就输出这个错误，并终止程序
		panic(err)
	}

	fmt.Println("test()继续执行")
}

func main() {
	test()
	fmt.Println("main()下面的代码")
}

最后

以上就是机智小土豆最近收集整理的关于Go函数、包和错误处理的全部内容，更多相关Go函数、包和错误处理内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Go
浏览次数：95 次浏览
发布日期：2023-09-19 08:56:03
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_2_f1_14__23_gz.html

Go函数、包和错误处理