Artikel untuk membantu anda memahami fungsi asas bahasa Go (Bahagian 2)

Semakan utama terakhir

Kita tahu di atas bahawa apabila mentakrifkan fungsi, peruntukan memori fungsi boleh difahami seperti berikut.

Pada masa yang sama, kita juga tahu bahawa tidak kira apa operasi yang dilakukan, ia hanya akan beroperasi pada timbunan di atas nilai

Fungsi dan pembolehubah

Nama fungsi ialah pembolehubah

Saya tidak tahu sama ada anda telah memikirkannya dengan baik dan menerima fungsi ini .

package main


import "fmt"


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


func main() {
    var s1 = say
    s1()
}

Keputusan pelaksanaan adalah seperti berikut. .

Pelaksanaan tiada masalah.

Jadi, apakah jenis pembolehubah ini? ? ?

fmt.Printf("%T\n"，s1)

执行结果

如果我将say函数改一下呢？

func say(s int) int{
    fmt.Println("say")
    return 1
}

fmt.Printf("%T\n"，s1)

可以发现，如果函数参数和返回值不一样，打印出来的类型也是不一样的。

定义函数类型

上述我们知道，可以通过变量接收一个函数名。

通过变量接收函数名是没有约束的，不管函数几个参数，几个返回值，都可以接收，真是活出了动态语言的样子。

而定义函数类型就是限制变量接收函数，只能接收指定格式的函数。

主要用到type关键字。

格式

type 变量名 func([参数类型，参数类型]) [返回值类型]
中括号表示可选参数

例如

type a func()
type b func(int)
type a func(int，int) int

具体代码

package main


import "fmt"


/*
    定义一个函数类型的变量
    接收的函数参数必须是两个int类型
    函数的返回值也必须是int类型
*/
type cType func(int， int) int


func say1(a， b int) int {
    fmt.Println("say"，a+b)
    return 1
}
func say2(a， b int) {
    fmt.Println("say")


}
func main() {
    var s1 cType
    s1 = say1//调用s1其实调用的就是say1
    s1(1，1)


    //var s2 cType
    //s2 = say2//报错，cannot use say2 (type func(int， int)) as type cType in assignment
}

高阶函数

千万不要被这个名字唬住了。

简单点说，高阶函数就是把函数当作参数或者把函数当作返回值。

函数当作参数

package main


import "fmt"


func add(x int， y int) int {
    return x + y
}
func calc(x int， y int， other func(int， int) int) int {
    return other(x， y)
}
func main() {
    //将add函数传入第三个参数
    var result = calc(34， 12， add)
    fmt.Println(result)
}

函数当作返回值

package main


import "fmt"


func add(x int， y int) int {
  return x + y
}
func test() (func(int， int) int) {
  return add
}
func main() {
  var a = test()
  fmt.Println(a(1，2))
}

至于上述两个的功能，恕小生不才，至今用到的场景不多。

匿名函数

匿名函数顾名思义，就是没有名字的函数。

语法如下

func([参数，参数...])[(返回值，返回值)]{
  代码
}()
//匿名函数后面必须跟括号，直接执行

例如

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

代码

package main


import "fmt"


func main() {
    //s1等于一个匿名函数，并且直接执行
  var s1 = func(x int， y int) (int) {
    return x + y
  }(1，2)
  fmt.Println(s1)
}

闭包

闭包，这个有点不太理解，简单点说就是函数里面套了一个函数，里面函数引用的外面函数的变量。

示例

package main


import "fmt"


func other() func() {
    //返回的是一个函数类型
  var a = 666
  return func() {
        //内部函数使用的是外面函数的a
    fmt.Println(a)
  }
}
func main() {
  var o = other()
  o()
}

执行结果。

结果是没有问题的。

虽然我们以前学过，函数执行完毕后，里面的变量会回收。

Tetapi apabila menggunakan penutup, boleh difahami bahawa jika fungsi dalam menggunakan pembolehubah fungsi luar, maka pembolehubah ini tidak akan dikitar semula.

Summary

Artikel ini terutamanya bercakap tentang Functions dan Variables, higher-order functions , anonymous functions, closure,

Antaranya, penutupan adalah lebih sukar untuk difahami, jadi anda mesti memikirkannya. Mata pedang datang dari mengasah, dan keharuman bunga plum datang dari sejuk yang pahit Anda mesti berlatih lebih banyak. 🎜🎜

Atas ialah kandungan terperinci Artikel untuk membantu anda memahami fungsi asas bahasa Go (Bahagian 2). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!