golang并不是传统的函数式编程语言,但是它支持函数式编程。
这里主要讲闭包的应用。

函数式编程 vs 函数指针

1. 函数式一等公民:参数,变量,返回值都可以是函数
2. 高阶函数
3. 函数->闭包

"正统"函数式编程

1. 不可变性:不能有状态,只有常量和函数
2. 函数只能有一个参数
3. golang没有以上规定

golang闭包的应用

1. 更为自然,不需要修饰如何访问自由变量
2. 没有lambda表达式,但是有匿名函数

1. 累加器

1.1 functional/adder/adder.go

package main
import "fmt"
func adder() func(int) int {
 sum := 0
 return func(v int) int {
 sum += v
 return sum
 }
}
type iAdder func(int) (int, iAdder)
func adder2(base int) iAdder {
 return func(v int) (int, iAdder) {
 return base + v, adder2(base + v)
 }
}
func main() {
 // a := adder() is trivial and also works.
 a := adder2(0)
 for i := 0; i < 10; i++ {
 var s int
 s, a = a(i)
 fmt.Printf("0 + 1 + ... + %d = %d\n",
 i, s)
 }
}

1.2 Output:

0 + 1 + ... + 0 = 0
0 + 1 + ... + 1 = 1
0 + 1 + ... + 2 = 3
0 + 1 + ... + 3 = 6
0 + 1 + ... + 4 = 10
0 + 1 + ... + 5 = 15
0 + 1 + ... + 6 = 21
0 + 1 + ... + 7 = 28
0 + 1 + ... + 8 = 36
0 + 1 + ... + 9 = 45

2. 实现斐波那契数列

2.1 functional/fib/fib.go:

package fib
// 1, 1, 2, 3, 5, 8, 13, ...
func Fibonacci() func() int {
 a, b := 0, 1
 return func() int {
 a, b = b, a+b
 return a
 }
}

2.2 functional/main.go:

package main
import (
 "bufio"
 "fmt"
 "io"
 "strings"
 "learngo/functional/fib"
)
type intGen func() int
func (g intGen) Read(
 p []byte) (n int, err error) {
 next := g()
 if next > 10000 {
 return 0, io.EOF
 }
 s := fmt.Sprintf("%d\n", next)
 // TODO: incorrect if p is too small!
 return strings.NewReader(s).Read(p)
}
func printFileContents(reader io.Reader) {
 scanner := bufio.NewScanner(reader)
 for scanner.Scan() {
 fmt.Println(scanner.Text())
 }
}
func main() {
 var f intGen = fib.Fibonacci()
 printFileContents(f)
}

2.3 Output

1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传