Go函数

函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段，其可以提高应用的模块性和代码的重复利用率。

函数定义

Go语言中定义函数使用func关键字，具体格式如下：

func 函数名(参数)(返回值){
    函数体
}

函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也称不能重名。首字母大小写和可见性相关
参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。相同参数类型，可以定义在最后一个参数末尾。
返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用,分隔。
函数体：实现功能的代码块。

package main

import (
	"fmt"
)

// 定义Hello
// 无参，无返回值
func sayHello() {
	fmt.Println("hello")
}

// 有参数, 无返回值
func sayHi(name string) {
	fmt.Println("hi, ", name)
}

// 有返回值 加法功能函数add
func add(a int, b int) int {
	fmt.Println(a, b)
	return a + b // return 关键字用来向函数调用者返回结果
}

func main() {
	// 函数调用 函数名称(参数[实参])
	sayHello() // 注意小括号
	sayHello() //hello

	sayHi("rxg") //hi,  rxg
	name := "小软"
	sayHi(name) //hi,  小软

	c := add(2, 1) // 实参 => 形参
	fmt.Println(c) //2 1 //3
}

函数的调用

定义了函数之后，我们可以通过函数名()的方式调用函数。 例如我们调用上面定义的函数

参数

类型简写

函数的参数中如果相邻变量的类型相同，则可以省略前面的类型：

func add(a, b int) int {
	return a + b 
}

可变参数

可变参数是指函数传入的参数个数是可变的，为了做到这点，首先需要将函数定义为可以接受可变参数的类型：

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

形如...type格式的类型只能作为函数的参数类型存在，并且必须是最后一个参数，它是一个语法糖（syntactic sugar），即这种语法对语言的功能并没有影响，但是更方便程序员使用，通常来说，使用语法糖能够增加程序的可读性，从而减少程序出错的可能。

从内部实现机理上来说，类型...type本质上是一个数组切片，也就是[]type，这也是为什么上面的参数 args 可以用 for 循环来获得每个传入的参数。

固定参数搭配可变参数使用时，可变参数要放在固定参数的后面：

func intSum(x int, y ...int) int {
	fmt.Println(x, y)
	sum := x
	for _, v := range y {
		sum = sum + v
	}
	return sum
}

任意类型的可变参数

如果你希望传任意类型，可以指定类型为 interface{}，下面是Go语言标准库中 fmt.Printf() 的函数原型：

func Printf(format string, args ...interface{}) {
    // ...
}

用 interface{} 传递任意类型数据是Go语言的惯例用法，使用 interface{} 仍然是类型安全的

package main

import "fmt"

func myPrintf(args ...interface{}) {
	for _, arg := range args {
		switch arg.(type) {
		case int:
			fmt.Println(arg, "is an int value.")
		case string:
			fmt.Println(arg, "is a string value.")
		case int64:
			fmt.Println(arg, "is an int64 value.")
		default:
			fmt.Println(arg, "is an unknown type.")
		}
	}
}
func main() {
	var v1 int = 1
	var v2 int64 = 234
	var v3 string = "hello"
	var v4 float32 = 1.234
	myPrintf(v1, v2, v3, v4)
}

返回值

Go语言中通过return关键字向外输出返回值，return退出函数体

func add(a, b int) int {
	return a + b 
}

多返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来:

func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

package main

import "fmt"

func op(a, b int) (int, int, int, int) {
	return a + b, a - b, a * b, a / b
}

func main() {
    c := 3
	fmt.Println(op(4, 2))
	a, b, c, d := op(4, 2) // 至少有一个变量未定义过
	fmt.Println("a=", a, "b=", b, "c=", c, "d=", d)
}

返回值命名

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回:

func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

返回值补充

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片:

func someFunc(x string) []int {
	if x == "" {
		return nil // 没必要返回[]int{}
	}
	...
}

变量作用域

全局变量

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。 在函数中可以访问到全局变量。

package main

import "fmt"

//定义全局变量num
var num int64 = 10

func testGlobalVar() {
	fmt.Printf("num=%d
", num) //函数中可以访问全局变量num
}
func main() {
	testGlobalVar() //num=10
}

局部变量

局部变量又分为两种： 函数内定义的变量无法在该函数外使用，例如下面的示例代码main函数中无法使用testLocalVar函数中定义的变量x：

func testLocalVar() {
	//定义一个函数局部变量x,仅在该函数内生效
	var x int64 = 100
	fmt.Printf("x=%d
", x)
}

func main() {
	testLocalVar()
	// fmt.Println(x) // 此时无法使用变量x
}

如果局部变量和全局变量重名，优先访问局部变量。

package main

import "fmt"

//定义全局变量num
var num int64 = 10

func testNum() {
	num := 100
	fmt.Printf("num=%d
", num) // 函数中优先使用局部变量
}
func main() {
	testNum() // num=100
}

if、for、switch语句块变量

语句块定义的变量，通常我们会在if条件判断、for循环、switch语句上使用这种定义变量的方式。

func localVar(x, y int) {
    fmt.print(x, y) // 函数的参数也是只在本函数中生效
    if x > 0 {
        z := 100
        fmt.Println(z) // 变量z只在if语句块生效
    }
    // fmt.Println(z) // 此处无法使用变量z
}

for语句块:

func localVar() {
	for i := 0; i < 10; i++ {
		fmt.Println(i) // 变量i只在当前for语句块中生效
	}
	// fmt.Println(i) // 此处无法使用变量i
}

函数类型与变量

函数也可以赋值给变量，存储在数组、切片、映射中，也可作为参数传递给函数或作为函数返回值进行返回

切片作为参数传递给函数会受影响吗(1):

package main

import "fmt"

func main() {
	name := "rxg"
	nums := []int{1, 2, 3}

	func(name string, nums []int) {
		// 1.
		fmt.Println(name, nums) //rxg [1 2 3]
		name = "silence"
		nums = []int{1, 2}
		// 2.
		fmt.Println(name, nums) //silence [1 2]
	}(name, nums)

	// 3.
	fmt.Println(name, nums) //rxg [1 2 3]
}

切片作为参数传递给函数会受影响吗(2):

package main

import "fmt"

func main() {
	name := "rxg"
	nums := []int{1, 2, 3}

	func(pname string, pnums []int) {
		// 1.
		fmt.Println(pname, pnums) //rxg, [1, 2, 3]
		pname = "silence"
		pnums = []int{1, 2}
		// 2.
		fmt.Println(pname, pnums) //silence, [1, 2]
	}(name, nums)
	/* 函数里面实际的赋值
		pname := name
		pnums := nums
		pname = "silence"
		pnums = []int{1, 2}
	*/

	// 3.
	fmt.Println(name, nums) //rxg [1 2 3]
}

切片作为参数传递给函数会受影响吗(3):

package main

import "fmt"

func main() {
	name := "rxg"
	nums := []int{1, 2, 3}

	func(pname string, pnums []int) {
		// 1.
		fmt.Println(pname, pnums) //rxg, [1, 2, 3]
		pname = "silence"
		pnums[0] = 100
		// 2.
		fmt.Println(pname, pnums) //silence [100, 2, 3]
	}(name, nums)
	/*	实际是改内存地址的值
		pname := name
		pname = "silence"

		pnums := nums
		pnums[0] = 100
	*/

	// 3.
	fmt.Println(name, nums) //rxg [100 2 3]
}

定义函数类型

使用type关键字来定义一个函数类型：

type calculation func(int, int) int
// calculation类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。
// 简单来说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。
func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

add和sub都能赋值给calculation类型的变量。

var c calculation
c = add

函数类型变量

声明函数类型的变量并且为该变量赋值：

package main

import "fmt"

func add(x, y int) int {
	return x + y
}

func main() {
	type calculation func(int, int) int
	var c calculation               // 声明一个calculation类型的变量c
	c = add                         // 把add赋值给c
	fmt.Printf("type of c:%T
", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // 像调用add一样调用c

	f := add                        // 将函数add赋值给变量f1
	fmt.Printf("type of f:%T
", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // 像调用add一样调用f
}

高阶函数

函数作为参数

func add(x, y int) int {
	return x + y
}

func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}

func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

函数作为返回值

func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

package main

import (
	"fmt"
	"math/rand"
	"strings"
	"time"
)

func sayHi() {
	fmt.Println("hi")
}

func sayHello() {
	fmt.Println("hello")
}

func genFunc() func() {
	if rand.Int()%2 == 0{
		return sayHi
	}
	return sayHello
}

func aFields(split rune) bool {
	return split == 'a'
}

func main() {
	rand.Seed(time.Now().Unix())
	f := genFunc()
	f()

	fmt.Printf("%q
", strings.FieldsFunc("aaabsad", aFields)) //["bs" "d"]
}

匿名函数

当我们不希望给函数起名字的时候，可以使用匿名函数:

一、
func(x, y int) int { return x + y }

二、
func(参数列表)(返回参数列表){
    函数体
}

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为只执行一次的立即执行函数:

func main() {
    //(1)将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

    //(2)自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

闭包

Go语言中闭包是引用了自由变量的函数，被引用的自由变量和函数一同存在，即使已经离开了自由变量的环境也不会被释放或者删除，在闭包中可以继续使用这个自由变量，因此，简单的说：

函数 + 引用环境 = 闭包

匿名函数同样被称之为闭包, 例如：

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。 在f的生命周期内，变量x也一直有效。

闭包进阶(1)：

package main

import "fmt"

func adder(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder(10)
	fmt.Println(f(10)) //20
	fmt.Println(f(20)) //40
	fmt.Println(f(30)) //70

	f1 := adder(20)
	fmt.Println(f1(40)) //60
	fmt.Println(f1(50)) //110
}

变量f定义adder函数需要传参

闭包进阶(2)：

package main

import (
	"fmt"
	"strings"
)

// 以什么结尾，不是则加上，是则直接返回
func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func main() {
	jpgFunc := makeSuffixFunc(".jpg")
	txtFunc := makeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test")) //test.jpg
	fmt.Println(txtFunc("test")) //test.txt
	fmt.Println(txtFunc("txt.txt")) //txt.txt
	fmt.Println(txtFunc("txt")) //txt.txt
}

闭包进阶(3), 返回两个函数:

package main

import (
	"fmt"
)

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main() {
	addF, subF := calc(10)
	fmt.Println(addF(1), subF(2)) //11 9
	fmt.Println(addF(3), subF(4)) //12 8
	fmt.Println(addF(5), subF(6)) //13 7
}

defer语句

Go语言的 defer 语句会将其后面跟随的语句进行延迟处理，在 defer 归属的函数即将返回时，将延迟处理的语句按 defer 的逆序进行执行，也就是说，先被 defer 的语句最后被执行，最后被 defer 的语句，最先被执行-栈：

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}
/*
结果
start
end
3
2
1
*/

由于defer语句延迟调用的特性，所以defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、连接数、解锁及记录时间等。

defer执行时机

Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。

先赋值
defer
return

四个示例:

// 示例一
func main() {
	fmt.Println("start")

	// defer 函数调用
	// defer 延迟执行
	// 在函数退出之前执行
	defer func() {
		fmt.Println("defer")
	}()

	fmt.Println("end")
	// start -> end -> defer
}

// 示例二
func main() {
	fmt.Println("start")

	// defer 函数调用
	// defer 延迟执行
	// 在函数退出之前执行
	defer func() {
		fmt.Println("defer 1")
	}()

	defer func() {
		fmt.Println("defer 2")
	}()

	fmt.Println("end")
	// start -> end -> defer 2 -> defer 1 => 堆栈
}

// 示例三
func main() {
	fmt.Println("start")

	// defer 函数调用
	// defer 延迟执行
	// 在函数退出之前执行
	for i := 0; i < 2; i++ {
		defer func(i int) {
			fmt.Printf("defer %d 
", i)
		}(i)
	}

	// defer 0 defer 1
	fmt.Println("end")
	// start -> end -> defer 1 -> defer 0 => 堆栈
}

// 示例四
func test() (i int) {
	// 在延迟执行中尽量不要修改返回值
	// var i int = 1
	i = 1
	defer func() {
		fmt.Println("defer")
		i = 2
	}()

	return i
}

func main() {
	fmt.Println(test()) // 返回2，知道为什么吗？和变量作业域有关
}

defer经典案例

func f1() int {
	x := 5
	defer func() {
		x++
	}()
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func main() {
	fmt.Println(f1()) //5
	fmt.Println(f2()) //6
	fmt.Println(f3()) //5
	fmt.Println(f4()) //5
}

defer面试题

// 按照顺序一步一步，即可解答
func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

结果
A 1 2 3
B 10 2 12
BB 10 12 22
AA 1 3 4

错误信息处理

Go语言中目前（Go1.14）是没有异常机制，go语言认为错误只是一个值err，源码都可见返回err。可以使用panic和recover模式来处理错误。 panic可以在任何地方引发，但recover只有在defer调用的函数中有效：

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	panic("panic in B") // panic导致程序崩溃，异常退出了。
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}
/*
结果
func A
panic: panic in B

goroutine 1 [running]:
main.funcB(...)
	、/hannuota.go:12
main.main()
	、/hannuota.go:20 +0x9d
*/

通过recover将程序恢复回来，继续往后执行

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//如果程序出出现了panic错误,可以通过recover恢复过来
		if err != nil {
			fmt.Println("recover in B")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

/*
func A
recover in B
func C
/*

总结

(1)recover()必须搭配defer使用。

(2)defer一定要在可能引发panic的语句之前定义。

递归

所谓递归函数指的是在函数内部调用函数自身的函数，从数学解题思路来说，递归就是把一个大问题拆分成多个小问题，再各个击破，在实际开发过程中，递归函数可以解决许多数学问题，如计算给定数字阶乘、产生斐波系列等。

构成递归需要具备以下条件：

(1)一个问题可以被拆分成多个子问题；
(2)拆分前的原问题与拆分后的子问题除了数据规模不同，但处理问题的思路是一样的；
(3)不能无限制的调用本身，子问题需要有退出递归状态的条件！！！

汉诺塔

package main

import "fmt"

/*
	start => 开始
	tmp => 借助
	end => 终止
	layer => 盘子的数量
*/
func tower(start, tmp, end string, layer int) {
	if layer == 1 {
		fmt.Println(start, "->", end)
		return
	}

	/*
		n个盘子 (开始)start -> (终止)end (借助)tmp
		n-1个盘子start -> tmp 借助end
		第N个 start -> end
		n-1个盘子 tmp -> end 借助start
	*/
	// layer - 1 start -> end
	tower(start, end, tmp, layer-1)
	fmt.Println(start, "->", end)
	tower(tmp, start, end, layer-1)
}

func main() {
	/*
		汉诺塔:
		n个盘子 (开始)start -> (终止)end (借助)layer

		n-1个盘子start -> tmp 借助end
		第N个 start -> end
		n-1个盘子 tmp -> end 借助A
	*/
	tower("A", "B", "C", 4)
}

阶乘

package main

import "fmt"

func fact(n int) int {
	if n < 0 {
		return -1
	}
	if n == 0 {
		return 1
	}
	return n * fact(n-1)
}

func main() {
	/*
		阶乘
		n! = 1 * 2 * 3 * ... * n
		=> (1 * ... * n-1) *n
		=> (n-1)! * n

		0! = 1
		fact(n) = n * fact(n-1)
		递归=> 结束条件
		fact(3) = 3 * fact(2)
		fact(2) = 2 * fact(1)
		fact(1) = 1 * fact(0)
		fact(0) = 1
	*/
	fmt.Println(fact(5))
}

斐波那契数列

package main

import "fmt"

func main() {
	result := 0
	for i := 1; i <= 10; i++ {
		result = fibonacci(i)
		fmt.Printf("fibonacci(%d) is: %d
", i, result)
	}
}

func fibonacci(n int) (res int) {
	if n <= 2 {
		res = 1
	} else {
		res = fibonacci(n-1) + fibonacci(n-2)
	}
	return
}