package main

/*
函数function
Go 函数 不支持 嵌套、重载和默认参数。
但支持以下特性：
无需声明原型（C语言在使用函数之前需要声明函数的原型）、不定长度变参、多返回值、命名返回值参数、
        匿名函数、闭包
定义函数使用关键字 func，且左大括号不能另起一行。
函数也可以作为一种类型使用
*/

import (
    "fmt"
)

func main() {
    A5(1)       //[1]
    A5(1, 2, 3) //[1 2 3]
    a, b := 1, 2
    A5(a, b)
    fmt.Println(a, b) //1,2.   a,b的值没有改变，相当于构建了一个slice数组，
    //基本类型是值传递，函数A5改变了数组但是没后改变a,b的值

    sli := []int{11, 22} //中括号里面什么都不写是slice,
    A7(sli)
    fmt.Println(sli) //[333 444],slice是引用传递，

    sli2 := [...]int{0, 101} //中括号里面什么都不写是slice,这里是数组
    A8(sli2)
    fmt.Println(sli2) //[0 101],数组是值传递

    //如果要改变基本类型的值，则要用到指针
    a1 := 888
    A9(&a1)
    fmt.Println(a1) //999

    a2 := B1 //函数 类型
    a2()     //B1B1B1B1

    //匿名函数
    a3 := func() {
        fmt.Println("a3a3a3a3")
    }
    a3()

    //闭包:返回匿名函数
    f := closure(10)
    fmt.Println(f(1)) //11
    fmt.Println(f(2)) //12

    f1 := closure(20)
    fmt.Println(f1(1)) //21
    fmt.Println(f1(2)) //22

}

func A(a int, b string) (int, string, int) { //函数参数和返回值
    return a, b, 1
}

func A1(a int, b string) int { //返回值只有一个可以只写数据类型
    return a
}

func A2(a, b, c int) int { //多个参数的数据类型一样可以省写
    return a
}

func A3() (int, int, int) { //如果返回值没有写名字，则返回的时候要加上名字
    a, b, c := 1, 2, 3
    return a, b, c
}

func A4() (a, b, c int) {
    a, b, c = 1, 2, 3 //这里不能使用:=,因为返回值写了a,b,c,那么a,b,c就已经初始化了，这里直接赋值就可以了
    return            //这里可以直接return，返回的就是a,b,c
}

func A5(a ...int) { //a接收不定参后，a变成了一个slice,用于接收多个参数，
    fmt.Println(a) //[1 2]
    a[0] = 333
    a[1] = 444
    fmt.Println(a) //[33 44]
    return
}

func A7(a []int) { //用于接收slice
    fmt.Println(a) //[11 22]
    a[0] = 333
    a[1] = 444
    fmt.Println(a) //[333 444]
    return
}

func A8(a [2]int) { //用于接收数组
    fmt.Println(a) //[0 101]
    a[0] = 333
    a[1] = 444
    fmt.Println(a) //[333 444]
    return
}

func A9(a *int) { //用于接收地址
    fmt.Println(*a) //888
    *a = 999
    fmt.Println(*a) //999
    return
}

func A6(b string, a ...int) { //b string要写在前面， a ...int要写在最后面
    fmt.Println(a)
    return
}

func B1() {
    fmt.Println("B1B1B1B1")
    return
}

func closure(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

package main

import (
    "fmt"
)

func main() { //闭包
    var fs = [4]func(){}

    for i := 0; i < 4; i++ {
        defer fmt.Println("defer i = ", i) //没有匿名函数，这里是参数i，i是基本类型，是值拷贝，
        defer func() {
            fmt.Println("defer_clouser i = ", i) //匿名函数，得到的是i的引用
        }()

        fs[i] = func() {
            fmt.Println("clouser i=", i) //i的引用，
        }
    }

    for _, f := range fs {
        f()
    }

    /*
        clouser i= 4
        clouser i= 4
        clouser i= 4
        clouser i= 4
        defer_clouser i =  4
        defer i =  3
        defer_clouser i =  4
        defer i =  2
        defer_clouser i =  4
        defer i =  1
        defer_clouser i =  4
        defer i =  0
    */
}