一、基本结构

func 函数名(入参1 入参类型, 入参2 入参类型...)(出参1 出参类型...){

        // 函数体，写一些代码逻辑

        // 当函数声明了入参时（函数可以没有入参），一定要使用入参

        // 当函数声明了出参时（函数可以没有出参），一定要return出参

}

func a(data1 int, data2 string)(ret1 int, ret2 string){
	// 无需在函数内部定义 ret1 和 ret2 变量
	ret1 = data1
	ret2 = data2
	return 	// return 后面省略了 ret1, ret2
}

二、传参

1. 传入不定参数会被当成切片

func main(){
	a(247, "1", "2", "3")
}

func a(data1 int, data2... string){
	fmt.Println(data1, data2)
	// data2可以使用append方法，说明是个切片
	data2 = append(data2, "4")
}

/*
输出结果：
247 [1 2 3]
*/

2. 入参和出参均为切片

func main(){
	sl := []int{1, 2}
	fmt.Println(b(sl...))
	fmt.Println(c(sl))
}
// 不同的传参形式
func b(input... int) (output []int) {
	output = append(input, 3, 4)
	output[0] = 7
	return
}
func c(input []int) []int {
	output := append(input, 5, 6)
	output[0] = 7
	return output
}

/*
输出结果：
[7 2 3 4]
[7 2 5 6]
*/

三、特殊函数

1. 匿名函数

func main(){
	d := func(data1 string) {
		fmt.Println(data1)
	}
	d("I'm an anonymous function.")
}

/*
输出结果：
I'm an anonymous function.
*/

2. 自执行函数

func main(){
    // 自执行函数
	(func(){
		fmt.Println("Entin")
	})()	// 后面必须跟一个小括号
}

3. 闭包函数

// 返回值为函数的函数
func main(){
	closure()(7)
}

func closure()func(int){
	return func(i int) {
		fmt.Println(i)
	}
}

/*
输出结果：
7
*/

4. 延迟调用函数

// 延迟调用函数总是最后才被执行
func main(){
	defer first()
	fmt.Println("Entin")
}

func first(){
	fmt.Println("I want to be executed first.")
}

/*
输出结果：
Entin
I want to be executed first.
*/