函数、包和错误处理

一、函数

为完成某一功能的程序指令(语句)的集合,称为函数。在go中,函数分为:自定义函数、系统函数。

func 函数名(形参列表) (返回值列表){

　　执行语句

　　return 返回值列表

}

形参列表表示函数的输入

函数中的执行语句表示未来实现某一功能代码块

函数可以有返回值，也可以没有返回值

package main

import "fmt"

func main() {
	var n1 float64 = 1.2
	var n2 float64 = 2.3
	var operator byte = '+'
	result := cal(n1, n2, operator)
	fmt.Println("result = ", result)
}

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
}

1、函数的调用机制

在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间 和其它的栈的空间区分开来
在每个函数对应的栈中，数据空间是独立的，不会混淆
当一个函数调用完毕(执行完毕)后，程序会销毁这个函数对应的栈空间

package main

import "fmt"

func test(n int) {
	n = n + 1
	fmt.Println("test() n = ", n)
}

func getSum(n1 int, n2 int) int {
	sum := n1 + n2
	fmt.Println("getSum sum = ", sum)
	return sum
}

func main() {
	n := 20
	test(n)
	fmt.Println("main() n = ", n)

	sum := getSum(10, 20)
	fmt.Println("main sum = ", sum)
}

2、return语句

go函数支持返回多个值，这一点是其它编程语句没有的。

func 函数名(形参列表) (返回值列表){

　　执行语句

　　return 返回值列表

}

如果返回多个值时，在接收时希望忽略某个返回值，则使用_符号表示占位忽略

如果返回值只有一个，(返回值类型列表)可以不写()

package main

import "fmt"

func test(n int) {
	n = n + 1
	fmt.Println("test() n = ", n)
}

func getSum(n1 int, n2 int) int {
	sum := n1 + n2
	fmt.Println("getSum sum = ", sum)
	return sum
}

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

func main() {
	n := 20
	test(n)
	fmt.Println("main() n = ", n)

	sum := getSum(10, 20)
	fmt.Println("main sum = ", sum)

	res1, res2 := getSumAndSub(1, 2)
	fmt.Printf("res1 = %v res2 = %v\n", res1, res2)

	_, res3 := getSumAndSub(3, 5)
	fmt.Printf("res3 = %v", res3)
}

3、 函数的递归调用

一个函数在函数体内又调用了本身，称为递归调用。

package main

import "fmt"

func test(n int) {
	if n > 2 {
		n--
		test(n)
	}
	fmt.Println("n = ", n)
}

func main() {
	test(4)
}

 函数递归需要遵守的重要原则:

(1)、执行一个函数时，就创建一个新的受保护的独立空间(新函数栈)
(2)、函数的局部变量是独立的，不会相互影响
(3)、递归必须向退出递归的条件逼近，否则就是无限递归
(4)、当一个函数执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当函数执行完毕或者返回时，该函数本身也会被系统销毁

斐波那契数

package main

import "fmt"

//斐波那契数
func fib(n int) int {
	if (n == 1 || n == 2) {
		return 1
	} else {
		return fib(n-1) + fib(n-2)
	}
}

func main() {
	res := fib(5)
	fmt.Println("res5 = ", res)
	fmt.Println("res4 = ", fib(4))
	fmt.Println("res3 = ", fib(3))
	fmt.Println("res2 = ", fib(2))
	fmt.Println("res1 = ", fib(1))
}

猴子吃桃子问题

package main

import "fmt"

//猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一半，然后再多吃一个。
//当到第十天时，想再吃时(还没吃)，发现只有 1 个桃子了。问题:最初共多少个桃子?
// 思路分析:
//1、第 10 天只有一个桃子
//2、第9天有几个桃子 = (第10天桃子数量 + 1) * 2
//3、规律: 第 n 天的桃子数据 peach(n) = (peach(n+1) + 1) * 2
func peach(n int) int {
	if n > 10 || n < 1 {
		fmt.Println("输入的天数错误")
		return 0
	}
	if n == 10 {
		return 1
	} else {
		return (peach(n+1) + 1) * 2
	}
}

func main() {
	fmt.Println("第1天桃子数量是", peach(1))
}

 函数使用的注意事项

(1)、函数的形参列表可以是多个，返回值列表也可以是多个。
(2)、形参列表和返回值列表的数据类型可以是值类型和引用类型。
(3)、函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写该函数可以被本包文件和其它包文件使用，类似public,首字母小写，只能被本包文件使用，其它包文件不能使用，类似private
(4)、函数中的变量是局部的，函数外不生效
(5)、基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。
(6)、如果希望函数内的变量能修改函数外的变量(指的是默认以值传递的方式的数据类型)，可以传 入变量的地址&，函数内以指针的方式操作变量。从效果上看类似引用。

package main

import "fmt"

func test(n *int) {
	*n = *n + 10

	fmt.Println("test() n = ", *n)
}

func main() {
	num := 20
	test(&num)
	fmt.Println("main() num = ", num)
}

 (7)、Go函数不支持函数重载

(8)、在Go中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。

package main

import "fmt"

func getSum(n1 int, n2 int) int {
	return n1 + n2
}

func main() {
	a := getSum

	fmt.Printf("a的类型%T，getSum类型是%T\n", a, getSum)

	res := a(10, 20)
	fmt.Println("res = ", res)
}

(9)、函数既然是一种数据类型，因此在Go中，函数可以作为形参，并且调用。

package main

import "fmt"

func getSum(n1 int, n2 int) int {
	return n1 + n2
}

func myFun(funvar func(int, int) int, num1 int, num2 int) int {
	return funvar(num1, num2)
}

func main() {
	res := myFun(getSum, 50, 60)
	fmt.Println("res = ", res)
}

(10)、为了简化数据类型定义，Go支持自定义数据类型

基本语法:type 自定义数据类型名 数据类型
type myInt int //这时myInt就等价int来使用了
type mySum func (int, int) int //这时mySum就等价一个函数类型 func (int, int) int

package main

import "fmt"

func getSum(n1 int, n2 int) int {
	return n1 + n2
}

type myFunType func(int, int) int

func myFun(funvar myFunType, num1 int, num2 int) int {
	return funvar(num1, num2)
}

func main() {
	res := myFun(getSum, 50, 60)
	fmt.Println("res = ", res)
}

 (11)、支持对函数返回值命名

package main

import "fmt"

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

func main() {
	a, b := getSumAndSub(1, 2)
	fmt.Printf("a = %v b = %v\n", a, b)
}

 (12)、使用 _ 标识符，忽略返回值

package main

import "fmt"

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

func main() {
	res, _ := cal(10, 20)
	fmt.Printf("res = %d", res)
}

 (13)、Go支持可变参数

 func sum(args...int) sum int{

　　函数体

}

func sum(n1 int,args...int) sum int{

　　函数体

}

args是slice切片，通过args[index]可以访问到各个值。

如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表最后。

package main

import "fmt"

func sum(n1 int, args ...int) int {
	sum := n1
	for i := 0; i < len(args); i++ {
		sum += args[i]
	}
	return sum
}

func main() {
	res := sum(10, 0, -1, 90, 10, 100)
	fmt.Println("res = ", res)
}

 编写一个函数，实现交换两个数的值。

package main

import "fmt"

func swap(n1 *int, n2 *int) {
	t := *n1
	*n1 = *n2
	*n2 = t
}

func main() {
	a := 1
	b := 2
	swap(&a, &b)
	fmt.Printf("a = %v b = %v", a, b)
}

4、init函数

每一个源文件都可以包含一个init函数，该函数会在main函数执行前，被go运行框架调用，也就是说init会在main函数前被调用。

package main

import "fmt"

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

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

 init 函数的注意事项

(1)、如果一个文件同时包含全局变量定义，init函数和main函数，则执行的流程全局变量定义 -> init函数 -> main函数

package main

import "fmt"

var age = test()

func test() int {
	fmt.Println("test()")
	return 90
}
func init() {
	fmt.Println("init()...")
}

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

 (2)、init函数最主要的作用，就是完成一些初始化的工作

5、匿名函数

Go 支持匿名函数，匿名函数就是没有名字的函数，如果我们某个函数只是希望使用一次，可以考 虑使用匿名函数，匿名函数也可以实现多次调用。

在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次。

package main

import "fmt"

func main() {
	res := func(n1 int, n2 int) int {
		return n1 + n2
	}(10, 20)
	fmt.Println("res = ", res)
}

将匿名函数赋给一个变量(函数变量)，再通过该变量来调用匿名函数。

package main

import "fmt"

func main() {
	f := func(n1 int, n2 int) int {
		return n1 + n2
	}
	res := f(10, 30)
	fmt.Println("res = ", res)
	res2 := f(20, 30)
	fmt.Println("res2 = ", res2)
}

如果将匿名函数赋给一个全局变量，那么这个匿名函数，就成为一个全局匿名函数，可以在程序有效。

package main

import "fmt"

var (
	fun1 = func(n1 int, n2 int) int {
		return n1 * n2
	}
)

func main() {
	res := fun1(4, 9)
	fmt.Println("res = ", res)
}

6、闭包

闭包就是一个函数和与其相关的引用环境组合的一个整体(实体)。

package main

import "fmt"

//AddUpper是一个函数，返回的数据类型是fun (int) int
func AddUpper() func(int) int {
	var n int = 10
	return func(x int) int {
		n = n + x
		return n
	}
}

func main() {
	f := AddUpper()
	fmt.Println(f(1))
	fmt.Println(f(2))
	fmt.Println(f(3))
}

闭包返回的是一个匿名函数, 但是这个匿名函数引用到函数外的n ,因此这个匿名函数就和n形成一 个整体，构成闭包。

闭包可以理解成：闭包是类, 函数是操作，n是字段。函数和它使用到n构成闭包。
当反复的调用f函数时，因为n是初始化一次，因此每调用一次就进行累计。
要搞清楚闭包的关键，就是要分析出返回的函数它使用(引用)到哪些变量，因为函数和它引用到的变量共同构成闭包。

package main

import (
	"fmt"
	"strings"
)

//编写一个函数makeSuffix(suffix string) 可以接收一个文件后缀名(比如.jpg)，并返回一个闭包。
//调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg) ,则返回文件名.jpg , 如果已经有.jpg后缀，则返回原文件名。
//strings.HasSuffix , 该函数可以判断某个字符串是否有指定的后缀。
func makeSuffix(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

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

 7、函数的defer

在函数中，程序员经常需要创建资源(比如:数据库连接、文件句柄、锁等) ，为了在函数执行完 毕后，及时的释放资源，go的设计者提供defer(延时机制)。

package main

import (
	"fmt"
)

func sum(n1 int, n2 int) int {
	//当执行到defer时，暂时不执行，会将defer后面的语句压入到独立的栈(defer栈)
	//当函数执行完毕后，再从defer栈按照先入后出的方式出栈执行
	defer fmt.Println("ok1 n1 = ", n1)
	defer fmt.Println("ok2 n2 = ", n2)

	res := n1 + n2
	fmt.Println("ok3 res = ", res)
	return res
}

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

在defer将语句放入到栈时，也会将相关的值拷贝同时入栈。

package main

import (
	"fmt"
)

func sum(n1 int, n2 int) int {
	//当执行到defer时，暂时不执行，会将defer后面的语句压入到独立的栈(defer栈)
	//当函数执行完毕后，再从defer栈按照先入后出的方式出栈执行
	defer fmt.Println("ok1 n1 = ", n1)
	defer fmt.Println("ok2 n2 = ", n2)

	n1++
	n2++

	res := n1 + n2
	fmt.Println("ok3 res = ", res)
	return res
}

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

defer最主要的价值是在，当函数执行完毕后，可以及时的释放函数创建的资源。

8、函数参数传递方式

值传递和引用传递
不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是，值传递的是值的拷贝，引用传递的是地址的拷贝，一般来说，地址拷贝效率高，因为数据量小，而值拷贝决定拷贝的数据大小，数据越大，效率越低。

package main

import "fmt"

var name = "tom"

func test01() {
	fmt.Println(name)
}

func test02() {
	name := "jack"
	fmt.Println(name)
}

func main() {
	fmt.Println(name)
	test01()
	test02()
	test01()
}

 

值类型:基本数据类型int系列,float系列, bool,string,数组和结构体struct

引用类型:指针、slice 切片、map、管道chan、interface 等都是引用类型

9、变量作用域

(1)、函数内部声明或定义的变量叫做局部变量，作用域仅限于函数内部。

(2)、函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母为大写，则作用 域在整个程序有效
(3)、如果变量是在一个代码块，比如for/if中，那么这个变量的的作用域就在该代码块

package main

import "fmt"

//编写一个函数,从终端输入一个整数打印出对应的金子塔
func printPyramid(totalLevel int) {
	for i := 1; i <= totalLevel; i++ {
		for j := 1; j <= totalLevel-i; j++ {
			fmt.Print("  ")
		}
		for k := 1; k <= 2*i-1; k++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

func main() {
	var n int
	fmt.Println("请输入打印金字塔的层数")
	fmt.Scanln(&n)
	printPyramid(n)
}

编写一个函数,从终端输入一个整数(1—9),打印出对应的乘法表

package main

import "fmt"

//编写一个函数,从终端输入一个整数(1—9),打印出对应的乘法表
func printMulti(num int) {
	for i := 1; i <= num; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v * %v = %v \t", j, i, j*i)
		}
		fmt.Println()
	}
}

func main() {
	var num int
	fmt.Println("请输入一个整数")
	fmt.Scanln(&num)
	printMulti(num)
}

10、字符串常用的系统函数

package main

import (
	"fmt"
	"strconv"
	"strings"
)

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

	//2、字符串遍历
	str2 := "hello北京"
	r := []rune(str2)
	for i := 0; i < len(r); i++ {
		fmt.Printf("%c\t", r[i])
	}
	fmt.Println()

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

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

	//5、字符串转[]byte
	var bytes = []byte("hello go")
	fmt.Printf("bytes = %v\n", bytes)

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

	//7、10进制转2，8，16进制
	str = strconv.FormatInt(123, 2)
	fmt.Printf("123对应的2进制是 = %v\n", str)
	str = strconv.FormatInt(123, 16)
	fmt.Printf("123对应的16进制是 = %v\n", str)

	//8、查找子串是否指定在指定的字符串中
	b := strings.Contains("seafood", "mary")
	fmt.Printf("b = %v\n", b)

	//9、统计一个字符串有几个指定的子串
	num := strings.Count("ceheese", "Abc")
	fmt.Printf("num = %v\n", num)

	//10、不区分大小写的字符串比较(==是区分字母大小写的比较)
	b = strings.EqualFold("abc", "Abc")
	fmt.Printf("b = %v\n", b)
	fmt.Println("结果", "abc" == "Abc")

	//11、返回子串在字符串第一次出现的index值，如果没有返回-1
	index := strings.Index("NLT_abcabcabc", "abc")
	fmt.Printf("index = %v\n", index)

	//12、返回子串在字符串最后一次出现的index，如果没有返回-1
	index = strings.LastIndex("go golang", "go")
	fmt.Printf("index = %v\n", index)

	//13、将指定的子串替换成另一个子串
	str2 = "go go hello"
	str = strings.Replace(str2, "go", "北京", -1)
	fmt.Printf("str = %v str2 = %v\n", str, str2)

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

	//15、将字符串的字母进行大小写的转换
	str = "goLang Hello"
	str = strings.ToLower(str)
	fmt.Printf("str = %v\n", str)
	str = strings.ToUpper(str)
	fmt.Printf("str = %v\n", str)

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

	//17、将字符串左右两边指定的字符去掉
	str = strings.Trim("! he!llo! ", " !")
	fmt.Printf("str = %q\n", str)

	//18、将字符串左边指定的字符去掉
	str = strings.TrimLeft("! he!llo! ", " !")
	fmt.Printf("str = %q\n", str)

	//19、将字符串右边指定的字符去掉
	str = strings.TrimRight("! he!llo! ", " !")
	fmt.Printf("str = %q\n", str)

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

	//21、判断字符串是否以指定的字符串结束
	fmt.Println(strings.HasSuffix("abc.jpg", "abc"))
}

11、时间和日期相关函数

时间和日期相关函数，需要导入time包

package main

import (
	"fmt"
	"time"
)

func main() {
	//1、time.Time 类型，用于表示时间
	now := time.Now()
	fmt.Printf("now = %v now type = %T\n", now, now)

	//2、获取年月日，时分秒
	fmt.Printf("年 = %v\n", now.Year())
	fmt.Printf("月 = %v\n", now.Month())
	fmt.Printf("月 = %v\n", int(now.Month()))
	fmt.Printf("日 = %v\n", now.Day())
	fmt.Printf("时 = %v\n", now.Hour())
	fmt.Printf("分 = %v\n", now.Minute())
	fmt.Printf("秒 = %v\n", now.Second())

	//3、fmt.Printf()格式化日期时间
	fmt.Printf("当前时间 %d-%d-%d %d:%d:%d \n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())

	//4、fmt.Sprintf()格式化日期时间
	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 = %v\n", dateStr)

	//5、time.Format()格式化日期时间
	fmt.Printf(now.Format("2006-01-02 19:09:34"))
	fmt.Println()
	fmt.Printf(now.Format("2010-12-03"))
	fmt.Println()
	fmt.Printf(now.Format("15:09:43"))
	fmt.Println()
}

 12、内置函数

golang提供了一些内置函数可以直接使用。

len:用来求长度，比如string、array、slice、map、channel

new:用来分配内存，主要用来分配值类型，比如int、float32、struct...返回的是指针

package main

import "fmt"

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

	num2 := new(int)
	*num2 = 100
	fmt.Printf("num2的类型 = %T num2的值 = %v num2的地址 = %v\n num2这个指针指向的值 = %v", num2, num2, &num2, *num2)
}

二、包

包的本质实际上就是创建不同的文件夹，来存放程序文件。

go的每一个文件都是属于一个包的，也就是说go是以包的形式来管理文件和项目目录结构。

1、包的三大作用：
区分相同名字的函数、变量等标识符
当程序文件很多时,可以很好的管理项目 控
制函数、变量等访问范围，即作用域
2、打包基本语法
package 包名
3、引入包的基本语法
import "包的路径"

4、包使用的注意事项
(1)、在给一个文件打包时，该包对应一个文件夹，文件的包名通常和文件所在的文件夹名一致，一般为小写字母。
(2)、当一个文件要使用其它包函数或变量时，需要先引入对应的包
引入方式1:import "包名"
引入方式2:
import (
"包名"
"包名"
)
(3)、package指令在文件第一行，然后是import指令。
(4)、在import包时，路径从$GOPATH的src下开始，不用带src , 编译器会自动从src下开始引入
(5)、为了让其它包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其它语言的public,这样才能跨包访问。
(6)、在访问其它包函数，变量时，其语法是 包名.函数名
(7)、如果包名较长，go支持给包取别名， 注意:取别名后，原来的包名就不能使用了，需要使用别名来访问该包的函数和变量。
(8)、在同一包下，不能有相同的函数名(也不能有相同的全局变量名)，否则报重复定义
(9)、如果要编译成一个可执行程序文件，就需要将这个包声明为main, 即package main .这个就是一个语法规范，如果你是写一个库 ，包名可以自定义

三、错误处理

在默认情况下，当发生错误后(panic),程序就会退出(崩溃)。

go语言不支持传统的try...catch...finally这种处理。

go中引入的错误处理方式为：defer,panic,recover

go中抛出panic异常，然后在defer中通过recover捕获这个异常，然后正常处理

package main

import (
	"fmt"
	"time"
)

func test() {
	//使用defer+recover来捕获和处理异常
	defer func() {
		err := recover() //recover()内置函数，可以捕获到异常
		if err != nil { //说明捕获到错误
			fmt.Println("err = ", err)
			fmt.Println("发送邮件") //可以将错误信息发送给管理员
		}
	}()
	num1 := 10
	num2 := 0
	res := num1 / num2
	fmt.Println("res = ", res)
}

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

自定义错误：

Go程序中，也支持自定义错误，使用 errors.New和panic内置函数。
(1)、errors.New("错误说明") , 会返回一个error类型的值，表示一个错误
(2)、panic内置函数 ,接收一个interface{}类型的值(也就是任何值了)作为参数。可以接收error类型的变量，输出错误信息，并退出程序

package main

import (
	"errors"
	"fmt"
)

//函数读取配置文件init.conf的信息，如果文件名传入不正确，返回一个自定义错误
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()下面的代码...")
}