一等公民函数

函数是一等公民

Golang中函数可以：

赋值给某个变量
作为入参传递给另外一个函数
作为其他函数的返回值

在编程语言中，我们一般说这种函数是类似于变量的一等公民，因为在其他编程语言中，一般只有变量才符合这些特性。

当然，除了Golang，Javascript中函数也是一等公民。将函数做为一等公民非常有意义，这类编程语言一般可以做为函数式编程语言使用。

匿名函数

我们先来看一个将函数赋值给变量的例子。

package main

import "fmt"

func main() {
    a := func() {
        fmt.Println("hello world first class function")
    }
    a()
    fmt.Printf("%T", a)
}

这里我们将一个函数赋值给了变量a。注意这个函数没有声明函数名称，这类函数一般称为匿名函数。

由于该匿名函数没有函数名称，因此我们只能通过变量a来调用。该程序执行结果如下：

hello world first class function
func()

当然我们也可以通过立即调用来调用匿名函数。

package main

import "fmt"

func main() {
    func() {
        fmt.Println("hello world first class function")
    }()
}

这里我们定义了一个匿名函数并进行了立即调用，直接结果如下：

hello world first class function

立即调用也可以传参数进去。

package main

import "fmt"

func main() {
    func(n string) {
        fmt.Println("Welcome", n)
    }("Gophers")
}

该程序执行结果如下：

Welcome Gophers

自定义函数类型

我们不仅可以定义结构体类型、接口类型，还可以自定义函数类型。

type add func(a int, b int) int

这行代码定义了一个新的函数类型add，该类型的函数要求接收两个int参数作为入参，函数返回值类型也为int。下面我们定义一个该类型函数的变量。

package main

import "fmt"

type add func(a int, b int) int

func main() {
    var a add = func(a int, b int) int {
        return a + b
    }
    s := a(5, 6)
    fmt.Println("Sum", s)
}

这里我们定义了一个add类型的变量a，我们给该变量赋的值是一个入参为两个int，返回值也为int的函数。注意我们赋值的函数签名必须符合add类型的定义。该程序执行结果如下：

Sum 11

高阶函数

符合下面两个条件之一的函数我们称为高阶函数：

存在一个或多个函数作为入参
将一个新的函数作为返回值

我们分别就这两种情况举个例子。

将函数作为入参传给其他函数

package main

import "fmt"

func simple(a func(a, b int) int) {
    fmt.Println(a(60, 7))
}

func main() {
    f := func(a, b int) int {
        return a + b
    }
    simple(f)
}

这里我们定义了函数simple，该函数的入参是函数类型。我们在main函数内部创建了一个符合simple入参要求的匿名函数，并传递给simple函数来调用。程序输出为67。

返回一个新函数

package main

import "fmt"

func simple() func(a, b int) int {
    f := func(a, b int) int {
        return a + b
    }
    return f
}

func main() {
    s := simple()
    fmt.Println(s(60, 7))
}

这里定义的函数simple返回了一个新函数f，f入参为两个int，返回值类型也是int。我们在main函数中调用simple()，赋值给s。因此s的值即为函数f。程序输出为67。

闭包

将函数作为一等公民的编程语言一般都有闭包的概念，比如Javascript，Golang也不例外。闭包是指在函数内部可以访问到函数外部定义的变量。当然，如果函数嵌套级别较深，可能会有多层访问，也就形成了作用域链。 听起来有点晦涩，我们通过例子来理解下。

package main

import "fmt"

func appendStr() func(string) string {
    t := "Hello"
    c := func(b string) string {
        t = t + " " + b
        return t
    }
    return c
}

func main() {
    a := appendStr()
    fmt.Println(a("World"))
    fmt.Println(a("Gopher"))
}

我们定义了一个函数appendStr，该函数的返回值是一个新函数，因此该函数是一个高阶函数。在appendStr函数内部，我们定义了变量t，因此在被返回的函数c内部我们是能够访问到t这个变量的，也就是说t在函数c的作用域链上。

我们在main函数中调用appendStr()赋值给变量a，这时a的值即为c，是appendStr返回的函数。由于t变量在函数c的作用域链上，因此每次调用a(也就是调用c)时都能访问到变量t，也就是说可以多次调用a来更新变量t的值。因此第一次调用a时t由Hello更新成了Hello World，第二次调用a时，t的值已经时Hello World了。

该程序输出如下：

Hello World
Hello World Gopher

这里提到的作用域链非常重要，原文没有提到这个，我个人觉得重要就补充了下，是学习高阶函数和闭包不容易理解的地方，是难点也是核心。

下面我们升级下前面的程序，来深刻体会下作用域链。

package main

import "fmt"

var g = "Hi"

func appendStr() func(string) string {
    t := "Hello"
    g = g + " " + "Hi"
    c := func(b string) string {
        t = t + " " + b + g
        return t
    }
    return c
}

func main() {
    a := appendStr()
    b := appendStr()
    fmt.Println(a("World"))
    fmt.Println(b("Everyone"))
    fmt.Println(a("Gopher"))
    fmt.Println(b("!"))
}

这里我们在函数appendStr外部定义了一个变量g，因此g位于函数appendStr的作用域链上。调用appendStr可以访问到其作用域链上的g，第一次调用appendStr后g更新为Hi Hi，第二次调用后g更新为Hi Hi Hi。该程序输出为：

Hello WorldHi Hi Hi
Hello EveryoneHi Hi Hi
Hello WorldHi Hi Hi GopherHi Hi Hi
Hello EveryoneHi Hi Hi !Hi Hi Hi

真实适用场景

前面我们看了几个例子，下面我们看下作为一等公民的函数都有哪些真实适用场景。我来实现实现一个函数filter来根据某些条件过滤一个切片，这在函数式编程中是非常常见的一种用法。

首先我们定义几个结构体类型student。

type student struct {
    firstName string
    lastName string
    grade string
    country string
}

下面实现函数filter，入参为一个切片列表，一个过滤条件判断函数。

func filter(s []student, f func(student) bool) []student {
    var s []student
    for _, v := range s {
        if f(v) {
            r = append(r, v)   
        }
    }
}

下面是完成程序：

package main

import "fmt"

type student struct {
    firstName string
    lastName  string
    grade     string
    country   string
}

func filter(s []student, f func(student) bool) []student {
    var r []student
    for _, v := range s {
        if f(v) {
            r = append(r, v)
        }
    }
    return r
}

func main() {
    s1 := student{
        firstName: "Naveen",
        lastName:  "Ramanathan",
        grade:     "A",
        country:   "India",
    }
    s2 := student{
        firstName: "Samuel",
        lastName:  "Johnson",
        grade:     "B",
        country:   "USA",
    }
    s := []student{s1, s2}
    f := filter(s, func(s student) bool {
        return s.grade == "B"
    })
    fmt.Println(f)
}

我们定义了两个student结构体变量，然后通过filter函数过滤出了grade为B的student。输出为：[{Samuel Johnson B USA}]。

假设我们现在像过滤出来自India，即印度的同学，那么只需要把过滤判断函数改为如下即可：

f := filter(s, func(s student) bool {
    return s.country == "India"
})
fmt.Println(f)

是不是很方便好用？

下面我们再实现一个函数iMap，用来遍历处理一个int类型的切片，并返回处理后的切片。

package main

import "fmt"

func iMap(s []int, f func(int) int) []int {
    var r []int
    for _, v := range s {
        r = append(r, f(v))
    }
    return r
}
func main() {
    a := []int{5, 6, 7, 8, 9}
    r := iMap(a, func(n int) int {
        return n * 5
    })
    fmt.Println(r)
}

这里我们将切片中的每个元素都乘了5，输出为：[25 30 35 40 45]。

像filter、map这些函数都是借助高阶函数这个特性来实现的，其实本质上是属于函数式编程的范畴，感兴趣的话可以接着去深入学习函数式编程，Haskell、Golang、Javascript、Python等编程语言都支持函数式编程。学习函数式编程对编程水平的提升绝对大有裨益。

PreviousDefer Next反射

Last updated 4 years ago