函数

• • 函数:一段代码块

• • 所有的流程控制代码和业务代码都只能写在函数内部

• • 为什么使用函数:

• • 把一个功能提出作为一个函数便于后期维护,结构清晰

• • 函数声明的语法

• • 函数声明后不会执行,必须调用后才会执行

func 函数名(参数列表) 返回值{
  //函数体
}

• • 函数调用的语法

返回值:=函数名(参数)

无参数无返回值函数

• • 函数可以有参数也可以没有参数,可以有返回值也可以没有返回值

func main() {
    demo1()
}
func demo1(){
    fmt.Println("执行demo1函数")
}

//上面代码等同于
//func main(){
// fmt.Println("执行demo1函数")
//}

有参数函数

• • 函数的参数可以有多个,且每个参数类型都可以不同

• • 参数表示调用函数方想要给函数内部传递的值,给函数使用的.

• • 声明函数时的参数叫做形参数,调用函数时参数叫做实参

func main() {
    i:=5
    s:="msr"
    show(s,i)
}
func show(name string,age int){
    fmt.Println("姓名:",name,"年龄",age)
}

有返回值函数

• • 函数的返回值是给调用方返回的数据,给调用方使用的.

• • 具有返回值的函数,必须要有return

func main() {
    a, b := 1, 2
    fmt.Println(add(a,b))
}
func add(c, d int) int {
    return c + d
}

• • 也可以在返回值类型前面添加变量,return关键字后不写内容,表示变量是什么返回值什么

func main() {
    a, b := 1, 2
    fmt.Println(add2(a,b))
}

func add2(c, d int) (sum int) {
    sum = c + d
    return
}

多返回值函数

• • 在Go语言中每个函数声明时都可以定义成多返回值函数

• • Go语言中所有的错误都是通过返回值返回的

• • 声明多返回值函数的语法

func 函数名(参数列表) (返回值,返回值){
  //函数体
}

• • 调用函数的语法

变量,变量:=函数名(参数)

• • 调用函数时如果不想接收可以使用下划线占位

变量,_:=函数名(参数)

• • 理论上函数返回值个数可以无限多个,但是一般不去定义特别多个返回值(用结构体代替多返回值)

代码演示

• • 函数的返回值可以不接收,表示执行函数

• • 函数的返回值如果接收,用于接收返回值的变量个数与返回值个数相同

• • 不想接收的使用占位符(_)占位

func main() {
    //不接收函数返回值
    demo()

    //每个返回值都接收
    a, b := demo()
    fmt.Println(a, b)

    //不希望接收的返回值使用下划线占位
    c, _ := demo()
    fmt.Println(c)
}

func demo() (string, int) {
    return "msr", 17
}

• • 多返回值函数也可以给返回值定义变量,return后面就不需要编写内容

func demo() (name string, age int) {
    name = "nsr"
    age = 17
    return
}

可变参数函数

• • Go语言支持可变参数函数

• • 可变参数指调用参数时,参数的个数可以是任意个

• • 可变参数必须在参数列表最后的位置,在参数名和类型之间添加三个点表示可变参数函数

func 函数(参数,参数,名称 ... 类型 ){
    //函数体
}

• • 输出语句就是可变参数函数,源码如下

func Println(a ...interface{}) (n int, err error) {
    return Fprintln(os.Stdout, a...)
}

• • 声明函数时,在函数体把可变参数当作切片使用即可

代码示例

• • 声明可变参数声明与调用

func main() {
    demo("看书", "写代码", "看抖音视频")
}

func demo(hover ... string) {
    for a, b := range hover {
        fmt.Println(a, b)
    }
}

• • 可变参数必须存在其他参数后面,一个函数不能有多个可变参数.

• • 因为前面普通参数个数是确定的,编译器知道,哪个实参给哪个形参

func main() {
    demo("张三", "看书", "写代码", "看抖音视频")
}

func demo(name string, hover ... string) {
    fmt.Println(name, "的爱好是")
    for a, b := range hover {
        fmt.Println(a, b)
    }
}

匿名函数

• • 匿名函数就是没有名称的函数

• • 正常函数可以通过名称多次调用,而匿名函数由于没有函数名,所以大部分情况都是在当前位置声明并立即调用(函数变量除外)

• • 匿名函数声明完需要调用,在函数结束大括号后面紧跟小括号

func (){
  
}()//括号表示调用

• • 匿名函数都是声明在其他函数内部

  匿名函数演示

• • 无参数匿名函数

  func main(){
     func(){
        fmt.Println("这是匿名函数")
     }()//括号表示调用
  }

• • 有参数匿名函数

func main() {
   func(s string) {
      fmt.Println(s, "这是匿名函数")
   }("传递参数") //调用时传递参数
}

• • 有参数有返回值匿名函数

func main() {
    r := func(s string) int {
        fmt.Println(s, "这是匿名函数")
        return 110
    }("传递参数") //调用时传递参数
    fmt.Println(r)
}

函数变量

• • 在Go语言中函数也是一种类型,函数有多少种形式,函数变量就有多少种写法

    var a func()           //无参数无返回值
    var b func(int)        //有一个int类型参数
    var c func(int) string //有一个int类型参数和string类型返回值
    fmt.Println(a, b, c)   //输出:<nil> <nil> <nil>

• • 定义完函数变量后,可以使用匿名函数进行赋值.也可以使用已经定义好的函数进行赋值

• • 函数变量定义以后与普通函数调用语法相同,变量名就是普通函数声明的函数名

func main() {
    var a func()
    a = func() {
        fmt.Println("执行函数")
    }   //注意此处没有括号,有括号表示调用函数,变量a就表示接收函数返回值
    a() //调用函数

    /*
    也可以使用短变量方式定义函数变量
    等效于
    func b(s string){
        //...
    }
     */
    b := func(s string) {
        fmt.Println("执行第二个函数")
    }
    b("参数")

    //使用定义好的函数
    d := c
    d()
    //函数名称c也是一个变量
    c()
}

func c() {
    fmt.Println("c函数")
}

• • 函数类型变量是除了slice、map、channel、interface外第五种引用类型

func main() {
    var a func()
    a = b
    a()
    var c func()
    c = a
    c()
    fmt.Printf("%p %p", a, c)//输出地址相同
}

func b() {
    fmt.Println("b")
}

函数作为参数或返回值

• • 变量可以作为函数的参数或返回值类型.而函数既然可以当做变量看待,函数变量也可以当做函数的参数或返回值

• • 函数作为参数时,类型写成对应的类型即可

func main() {
    a(func(s string) {
        fmt.Println(s)
    })
}

func a(b func(s string)) {
    fmt.Println("a执行")
    b("传递给s的内容")
}

• • 函数作为返回值

func main() {
    //此时result指向返回值函数.
    result := a()
    //调用函数,才能获取结果
    fmt.Println(result())
}

func a() func() int {
    return func() int {
        return 110go
    }
}

原文始发于微信公众号（杂食的程序员）：golang学习九：函数