Go 函数

函数基础

package main

import "fmt"

//给类型命别名
type MyFunc func(a,b int)(int,string)

type Myint  int

//函数
func main() {

    var a int =10
    var b Myint=9
    fmt.Println(a+int(b))


    //定义方式
    /*
        func 名字(参数名 类型，参数名 类型)(返回值类型，返回值类型){
            函数体内容
            return 返回值1，返回值2
        }
    */
    //1 调用函数
    //add(2,3,"xxx")
    //var a int =add(2,3)
    //a := add(2, 3)
    //fmt.Println(a)
    //多返回值就需要用多变量接收
    //a,b:=add(3,4)
    //fmt.Println(a,b)
    //多返回值，忽略一个返回值
    //a,_:=add(3,4)
    //fmt.Println(a)
    //fmt.Println(_)


    //匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数
    //var a func()
    //a = func (){
    //    fmt.Println("我是匿名函数")
    //}
    //a()
    //函数返回值是函数
    //a:=test()
    //fmt.Println(a)  // 函数内存地址
    //a()
    //8 函数返回值为函数,返回的函数带参数
    //a:=test()
    //a("xxx")

    //9 函数返回值为函数,返回的函数带参数,带返回值
    //var a func(a,b int)int
    //a=test()
    //fmt.Println(a(2,3))

    //10 函数参数为函数类型，返回值为带参数，带返回值的函数类型
    //a,b:=test(func() {
    //    fmt.Println("我是函数参数")
    //})(3,4)
    //f:= func() {
    //    fmt.Println("我是函数参数")
    //}
    //
    //f1:=test(f)
    //a,b:=f1(3,4)
    //fmt.Println(a,b)

    //闭包函数的使用
    //a:=test(19)
    ////a是闭包函数
    //a()

    //装饰器是闭包函数的典型应用（go中没有装饰器的语法糖），通过闭包实现装饰器

    //类型重命名
    //var a MyFunc =test()
    //c,d:=a(1,2)
    //fmt.Println(c,d)


}

//1 有参数无返回值(定义函数)
//func add(a int,b int)  {
//    fmt.Println(a+b)
//}

//2 有参数无返回值,有多个相同类型参数
//func add(a ,b int)  {
//    fmt.Println(a+b)
//}
//3 有参数无返回值,有多个相同类型参数，也有不同类型
//func add(a ,b int,msg string)  {
//    fmt.Println(a+b)
//    fmt.Print(msg)
//}

//4 多个参数，一个返回值
//func add(a, b int) int {
//    return a + b
//}


//4 多个参数，多个返回值
//func add(a, b int) (int,int) {
//    return a + b,a*b
//}

//5 命名返回值
//func add(a, b int) (c int,d int) {
//    c=a+b
//    d=a*b
//    //return时，不需要再写c,d了
//    return
//}


//6  函数是一等公民，函数可以赋值给变量

//7 函数返回值为函数
//func test() func() {
//    return func() {
//        fmt.Println("我是返回函数")
//    }
//}

//8 函数返回值为函数,返回的函数带参数
// 类型只要有不一样的地方，就不是一个类型
//func test() func(msg string) {
//    return func(msg string) {
//        fmt.Println(msg)
//    }
//}

//9 函数返回值为函数,返回的函数带参数,带返回值
//func test() func(a,b int) int{
//    return func(a,b int) int {
//        return a+b
//    }
//}

//10 函数参数为函数类型，返回值为带参数，带返回值的函数类型
//func test(f func()) func(a,b int) (int,int){
//    return func(a,b int) (int,int) {
//        f()
//        return a+b,a*b
//    }
//}

//11 闭包函数：1 定义在函数内部  2对外部作用域有引用
// 闭包函数就是多了一种函数传参的方法，包进去了
//func test(age int) func()  {
//    a:= func() {
//        fmt.Println(age)
//    }
//    return a
//}

//12
func test()MyFunc  {
    return func(a,b int)(int,string) {
        fmt.Println("xxx")
        return 10,"ok"
    }

}

 函数高级

package main

import "fmt"

//函数高级(都是按位置传，没有关键字一说)

func main() {
    //test(1,2,5,6,7,8,8)

    //res:=find(10,1,2,43,54,6,7,8,9,10)
    //fmt.Println(res)


    //3 匿名函数 ，定义在函数内部
    //定义一个匿名函数,加括号使用匿名函数
    //func (){
    //    fmt.Println("我是匿名函数")
    //}()
    //把函数赋值给一个变量,并且执行
    //var a func()  //函数类型
    //a = func() {
    //    fmt.Println("aaaaa")
    //}
    //a()
    ////a是什么类型？定义出a来



    //var a func()=test(10)
    //a()
    //fmt.Println(a)
    var f func(c int)int
    f=test(10,20)
    res:=f(30)
    fmt.Println(res)

}


//1 可变长参数(可以传任意长度的int类型)
//func test(a... int)  {
//    fmt.Println(a)  //切片类型
//    fmt.Println(a[0])
//}

//2 案例：输入一个数字，和一堆数字，判断第一个数字在不在后面一堆中

//func find(a int,b ...int) string {
//    for i:=0;i<len(b);i++ {
//        if a==b[i]{
//            return "在"
//        }
//    }
//    return "不在"
//}


// 3 匿名函数（没有名字的函数）


// 4 闭包函数（定义在函数内部，对外部作用域有引用）
// 函数可以赋值给一个变量：函数是一等公民，头等函数
//func test(c int) func() {
//    a:=func (){
//        fmt.Println(c)
//    }
//    return a
//}


//5 更高级的使用
//func test(a func(func()),b func())(func(a,b int),func())  {
//    return func(a, b int) {
//
//    }, func() {
//
//        }
//}


//函数的参数和返回值都是类型的一部分
//func()
//func(a int)
//func(a int)int
func test(a,b int)func(c int)int{
    f:= func(c int) int{
        return a+b
    }
    return f
}

可变参数函数

//package main
//
//import "fmt"
//
////可变长参数
//
//func main() {
//    //test1(1,2,3,4)
//
//    //给可变长参数传入切片
//    var a []int=[]int{3,4,5}
//    //var a =[]string{} //错误的
//    test1(a...) //打散了传过去
//
//}
//
//func test1(a ...int)  {
//    fmt.Println(a)
//    fmt.Println(len(a))
//    fmt.Println(cap(a))
//    fmt.Printf("%T",a)
//
//
//}


package main

import (
"fmt"
)



func main() {
    welcome := []string{"hello", "world"}
    change(welcome...)  //底层是直接把切片传入了
    fmt.Println(welcome)
}

func change(welcome ...string) {
    welcome[0] = "Go"
    fmt.Println(welcome)
}