函数

main函数是程序入口

定义

func sumFn(x int, y int) int {  // 如果类型相同，只需最后参数写入类型即可
    sum := x + y
    return sum
}

func main() {
    fmt.Sprintln(sumFn(1,2))
}

可变参数

func sumFn(props ...int) int {  // 可变参数只能写在最后
  sum := props[0] + props[1]
  return sum
}

多返回值

func sumFn(props ...int) (int,int) {  // 括号包裹返回值，返回多个值
  sum := props[0] + props[1]
  return sum, 10
}

// 返回值命名
func sumFn(props ...int) (tsum int, tcode int) {  // 括号包裹返回值，返回多个值
  sum := props[0] + props[1]
  return
}

自定义函数类型

使用type定义

type calc func(int, int) int

这里定义了一个calc类型的函数，而这个函数，必须传入两个int型参数以及返回一个int型返回值。任何不符合这个条件的都不属于calc这个自定义函数类型。

package main

import "fmt"

type calc func(int, int) int

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

func main() {
	var c calc
	c = add
	var d int = c(1, 2)
	fmt.Println(d)
  fmt.Printf("类型 %T\n", c)  // 请注意，这里的类型是main.calc，含义是 包.类型
}

// 可能会看到下面这种代码：
// func sub(a int, b func(int) int) int {}
// 由于函数可以返回函数，也就意味着可以返回自定义的函数类型，所以这里的参数b的类型是自定义函数类型，其类型为func(int) int

匿名函数

一般的语言都会有匿名函数。匿名函数的核心思想是：只处理简单事务。比如，两数相加，或者颠倒字符顺序，可以在函数里简单写点代码就能够完成的，不涉及到对其他函数的调用的(或者说调用极少)，可以写成匿名函数。

go里，一个方法里面不能包含具名函数，只能够使用匿名函数的形式来声明和使用函数

func main() {
	var a = func(x int) int { // 注意这里，匿名函数
		return 1 + x
	}
	fmt.Println(a(3))       // 匿名函数赋值给了a，所以能够调用a

  // func() {
	// 	fmt.Println("123")
	// }()                      // 注意这里的括号。匿名函数末尾加上括号会立即执行。括号里写入参数，则该匿名函数会接收到参数
}

递归调用

函数调用自己

// 算出1~100的和
func add1to100(x, y int) int {
	if x < 100 {
		x = x + 1
		y = y + x
		return add1to100(x, y)
	} else {
		return y
	}
}

func main() {
	fmt.Println(add1to100(1, 1))
}

闭包

定义在函数内部的函数。

闭包的出现动机是，希望能有办法：使得变量能够不属于全局，但是又能常驻内存。

注意，由于常驻内存，也就意味着：过分使用闭包会导致内存占用过多，导致性能下降

func getInnerVar() func() int {
	var num1 = 10
	return func() int {           // 返回了函数，形成闭包
		return 1 + num1
	}
}

func main() {
	fmt.Println(getInnerVar()())  // 这里getInnerVar()是函数, 调用函数要再加个()
}