Golang_4_函数

func hello()  {
	fmt.Println("hello world!")
}

// exec函数，参数值为函数名称
func exec(f func())  {
	f()
}

func main(){
	f := hello
	exec(f)
}

func test(x *int){
   fmt.Printf("point: %p, target: %v\n", &x, x)
}

func main() {
   a := 0x100
   p := &a

   fmt.Printf("point: %p, target: %v\n", &p , p)
   // p 的地址和 p 的 地址
   //point: 0xc42008a018, target: 0xc420082008
   test(p)
   // 形参的地址 和 传入的值
   //point: 0xc42008a028, target: 0xc420082008
}

func test(p **int) {
   x := 100
   *p = &x // 地址操作
}

func main() {
   var p *int // 定义指针变量
   test(&p) // 调用函数，使用 &p
   fmt.Println(*p) // 还原指针对应的值，输出100
}

func test(s string, a ...int) {
   fmt.Printf("%T, %v\n", s, s)
   fmt.Printf("%T, %v\n", a, a)
}

func main() {
   test("abc", 1, 2, 3, 4)
}
// string, abc
// []int, [1 2 3 4]

func test(a ...int) {
   fmt.Printf("%T, %v\n", a, a)
}

func main() {
   a := [3]int{1, 2, 3}
   test(a[:]...) // 数组转化为切片类型
   // []int, [1 2 3]
}

func test(a ...int) {
   for i := range a{
      a[i] += 100
   }
}

func main() {
   a := []int{1, 2, 3} // 切片类型
   test(a...) // 切片类型传参
   fmt.Println(a)
}

func test(x int) int{
   if x > 0 {
      return 1
   } else if x < 0 {
      return -1
   }
}// 错误：Missing return at end of function

func test(x int) int{
   for{
      x++
   }
}
// 死循环 without break，不报错
// 若循环内加上 break，则会报错

import "errors"

func div(x, y int) (int, error){// 多返回值需要使用括号
   if y == 0 {
      return 0, errors.New("Division by zero")
   }
   return x / y, nil
}

func log(x int, err error) {
	fmt.Println(x, err)
}

// 多返回值直接作 return 的结果
func test() (int, error) {
	return div(5, 0)
}

func main() {
    // 多返回值作实参
	log(test())
}

func paging(sql string, index int) (count int, pages int, err error) {
   return // 隐式返回，相当于 return count, pages, err
}

// 定义一个函数，它的返回值是一个函数
func test(x string) func() {
   name := "小王子"
   return func() {
      fmt.Println(x, name)
   }
}

// 闭包 = 函数 + 外层变量的引用
func main() {
   f := test("hello") // f 就是一个闭包
   f() // 相当于执行了test函数内部的匿名函数
}

// 1. 声明一个 makeSuffixFunc 的函数，参数为 suffix(string)
// 2. 返回值是一个函数类型：这个函数类型接收一个string参数，返回一个string参数
func makeSuffixFunc(suffix string) func(string) string {
    // 3. 返回一个匿名函数，和上层函数的返回值相同
    return func(name string) string {
        // HasSuffix：返回 name 是否以 suffix 结尾
        // 4. name 是匿名函数的变量，suffix 不是匿名函数的变量，而是外层函数的变量
        // 5. 定义的不是一个普通的匿名函数，还包含外层变量的引用，返回的结果也是一个闭包
        if !strings.HasSuffix(name, suffix){
            return name + suffix
        }
        return name
    }
}

// 闭包 = 函数 + 外层变量的引用
func main() {
    // 传入 suffix 变量为 .txt
    r := makeSuffixFunc(".txt")
    // 返回的匿名函数
    ret := r("哈哈哈")
    fmt.Println(ret)
}

// 1. calc 为计算函数，接收一个参数 base
// 2. 返回值有两个，都是函数类型
// 3. 内部定义了 add 和 sub 两个函数，最后return
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
	// 判断返回是不是闭包
	// 就是判断返回函数的内部是否包含外层变量的引用
	// 这里两个函数的 base 是外层变量引用，所以是闭包
}

func main() {
	// 闭包 = 函数 + 外层变量的引用
	// 100 就是外层的 base，100是内层的 i
	x, y := calc(100)
	ret1 := x(200) // base = 100 + 200
	fmt.Println(ret1)
	ret2 := y(200) // base = 300 - 200
	fmt.Println(ret2)
}

func main() {
   x, y := 1, 2
   defer func(a int) {
      fmt.Println("defer x , y = ", a, y) // y 是闭包
   }(x) // 注册时复制参数，为1

   x += 100
   y += 200
   fmt.Println(x, y)
}
// 101 202
// defer x , y =  1 202 // 延迟调用，最后执行

func Scanlan(a ...interface{})(n int, err error)

var errDivByZero = errors.New("division by zero")

func div(x, y int) (int, error) {
   if y == 0 {
      return 0, errDivByZero
   }
   return x / y, nil
}

func main() {
   z, err := div(5, 0)
   if err == errDivByZero {
      log.Fatalln(err) // 输出 2019/09/24 20:14:49 division by zero
   }

   fmt.Println(z)
}