go-基础-函数

package function

import "fmt"

// 补充
// 1. 包里面的函数，以大小写来区分权限，小写为private,大写为public。
// init函数，在main前，自动被调用，用来初始化数据，可以有多个，从上到下顺序执行。可以任意包中使用，main函数只能在main包中。
/* 
	无需声明原型
	支持不定参数
	支持函数返回参数，返回多个参数
	函数可作为参数传参

	不支持嵌套
	不支持参数默认值
	不支持重载
*/
// 函数参数。 参数是拷贝行为
func plus(a int, b int) int {// 括号不许换行
	return a + b
}

// 简写同类型
func plusPlus(a, b int) int {
	return a + b
}

// 多返回值
func vals() (int, int) { // 多个值使用（）括起来
	return 3, 7
}

// 不限定参数。可变参数只有slice类型，且必须放在最后。一般使用interface{}传任意类型数据。
func sum(nums ...int) { // 任意类型是int的参数
	fmt.Println(nums, " ")
	total := 0
	for _, num := range nums {
		total += num
	}
	fmt.Println(total)
}
// 隐式返回1 无return默认返回所有声明的变量
func ys1(x, y int) int {
	z = x + y
}
// 隐式返回2 指定返回值
func ys2(x, y int) z int {
	z = x + y
	return
}
// 隐式返回3 同名局部变量屏蔽，需显示返回
func ys3(x, y int) int {
	{z = x + y}
	return z
}
// 隐式返回4 defer 延迟调用闭包，执行顺序 z = x + y => z += 100 => return z
func ys4(x, y int) int {
	defer func() {
		z += 100
	}()
	z = x + y
	return
}
// 隐式返回5 执行顺序 z = x + y => z += 200 => return 前表达式即：z + 200 => defer z+=100 => return z
func ys4(x, y int) (z int) {
	defer func() {
		z += 100
	}()
	z = x + y
	return z + 200
}
// 闭包，返回匿名函数,基本使用同js.不在赘诉
func intSeq() func() int {
	i := 0 // 闭包复制的是原对象指针
	return func() int {
		i++
		return i
	}
}

// 递归
func fact(n int) int {
	if n == 0 {
		return 1
	}
	return n * fact(n-1)
}
func fib(n int) int {
	if n < 2 {
		return n
	}
	return fib(n-1) + fib(n-2)
}

// 指针
// &x: 取地址
// *x: 跟进地址取值
func zeroval(ival int) {
	ival = 0
}
func zeroptr(iptr *int) {
	*iptr = 0
}

func main() {
	a := plus(1, 2)
	b := plusPlus(1, 2)
	fmt.Println(a)
	fmt.Println(b)

	_, c := vals()
	fmt.Println(c)

	sum(1, 2, 3, 4, 5)
	nums := []int{1, 2, 3, 4}
	sum(nums...) // 切片传入

	nextInt := intSeq()
	fmt.Println(nextInt())
	fmt.Println(nextInt())
	fmt.Println(nextInt())

	fmt.Println(fact(7))
	fmt.Println(fib(7))

	i := 1
	fmt.Println("init", i) // 1
	zeroval(i)
	fmt.Println("zeroval", i) // 1

	zeroptr(&i)               // 引用传递
	fmt.Println("zeroptr", i) // 0
	fmt.Println("zeroptr &", &i)

}