曾经写 Java 的时分，听到前端同学议论闭包，觉得甚是别致，后边自己写了一小段时间 JS，虽只学到皮毛，也大约了解到闭包的概念，现在作业常用言语是 Go，许多高雅的代码中总是有闭包的身影，看来不了解个透是不或许的了，本文让我来科普(按照自己水平随意瞎扯)一下：
1、什么是闭包？
在实在讲述闭包之前，咱们先衬托一点常识点：
- 函数式编程
- 函数效果域
- 效果域的承继关系
1.1 前提常识衬托
1.2.1 函数式编程
函数式编程是一种编程范式，看待问题的一种办法，每一个函数都是为了用小函数组织成为更大的函数，函数的参数也是函数，函数回来的也是函数。咱们常见的编程范式有：
- 命令式编程：
- 首要思维为：重视核算机履行的步骤，也便是一步一步告知核算机先做什么再做什么。
- 先把解决问题步骤规范化，笼统为某种算法，然后编写具体的算法去完成，一般只需支撑进程化编程范式的言语，咱们都能够称为进程化编程言语，比方 BASIC，C 等。
- 声明式编程：
- 首要思维为：告知核算机应该做什么，可是不指定具体要怎样做，比方 SQL，网页编程的 HTML，CSS。
- 函数式编程：
- 只重视做什么而不重视怎样做，有一丝丝声明式编程的影子，可是更加侧重于”函数是第一位“的准则，也便是函数能够呈现在任何地方，参数、变量、回来值等等。
函数式编程能够以为是面向目标编程的对立面，一般只需一些编程言语会强调一种特定的编程办法，大大都的言语都是多范式言语，能够支撑多种不同的编程办法，比方 JavaScript ，Go 等。
函数式编程是一种思维办法，将电脑运算视为函数的核算，是一种写代码的办法论，其实我应该聊函数式编程，然后再聊到闭包，由于闭包自身便是函数式编程里边的一个特色之一。
在函数式编程中，函数是头等目标，意思是说一个函数，既能够作为其它函数的输入参数值，也能够从函数中回来值，被修正或许被分配给一个变量。(维基百科)
一般纯函数编程言语是不允许直接运用程序状况以及可变目标的，函数式编程自身便是要防止运用 同享状况，可变状况，尽或许防止产生 副效果。
函数式编程一般具有以下特色：
-
函数是第一等公民：函数的位置放在第一位，能够作为参数，能够赋值，能够传递，能够作为回来值。
-
没有副效果：函数要坚持纯粹独立，不能修正外部变量的值，不修正外部状况。
-
引证通明：函数运转不依赖外部变量或许状况，相同的输入参数，任何情况，所得到的回来值都应该是相同的。
1.2.2 函数效果域
效果域（scope），程序规划概念，通常来说，一段程序代码中所用到的名字并不总是有用/可用的，而约束这个名字的可用性的代码规模便是这个名字的效果域。
通俗易懂的说，函数效果域是指函数能够起效果的规模。函数有点像盒子，一层套一层，效果域咱们能够了解为是个关闭的盒子，也便是函数的部分变量，只能在盒子内部运用，成为独立效果域。
函数内的部分变量，出了函数就跳出了效果域，找不到该变量。（里层函数能够运用外层函数的部分变量，由于外层函数的效果域包括了里层函数），比方下面的 innerTmep 出了函数效果域就找不到该变量，可是 outerTemp 在内层函数里边仍是能够运用。
不论是任何言语，基本存在必定的内存收回机制，也便是收回用不到的内存空间，收回的机制一般和上面说的函数的效果域是相关的，部分变量出了其效果域，就有或许被收回，假如还被引证着，那么就不会被收回。
1.2.3 效果域的承继关系
所谓效果域承继，便是前面说的小盒子能够承继外层大盒子的效果域，在小盒子能够直接取出大盒子的东西，可是大盒子不能取出小盒子的东西，除非产生了逃逸（逃逸能够了解为小盒子的东西给出了引证，大盒子拿到就能够运用）。一般而言，变量的效果域有以下两种：
-
全局效果域：效果于任何地方
-
部分效果域：一般是代码块，函数、包内，函数内部声明/界说的变量叫部分变量，效果域仅限于函数内部
1.2 闭包的界说
“大都情况下咱们并不是先了解后界说，而是先界说后了解“，先下界说，读不懂不要紧：
闭包（closure）是一个函数以及其绑缚的周边环境状况（lexical environment，词法环境）的引证的组合。 换而言之，闭包让开发者能够从内部函数拜访外部函数的效果域。 闭包会随着函数的创立而被一同创立。
一句话表述：
以上界说找不到 Go言语 这几个字眼，聪明的同学必定知道，闭包是和言语无关的，不是 JavaScript 特有的，也不是 Go 特有的，而是函数式编程言语的特有的，是的，你没有看错，任何支撑函数式编程的言语都支撑闭包，Go 和 JavaScript 便是其中之二， 现在 Java 现在版别也是支撑闭包的，可是有些人或许以为不是完美的闭包，详细情况文中讨论。
1.3 闭包的写法
1.3.1 初看闭包
下面是一段闭包的代码：
import "fmt"
func main() {
sumFunc := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
}
func lazySum(arr []int) func() int {
fmt.Println("先获取函数，不求成果")
var sum = func() int {
fmt.Println("求成果...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
return sum
}
输出的成果：
先获取函数，不求成果
等候一会
求成果...
成果： 15
能够看出，里边的 sum() 办法能够引证外部函数 lazySum() 的参数以及部分变量，在lazySum()回来函数 sum() 的时分，相关的参数和变量都保存在回来的函数中，能够之后再进行调用。
上面的函数或许还能够更进一步，体现出绑缚函数和其周围的状况，咱们加上一个次数 count：
import "fmt"
func main() {
sumFunc := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
fmt.Println("成果：", sumFunc())
fmt.Println("成果：", sumFunc())
}
func lazySum(arr []int) func() int {
fmt.Println("先获取函数，不求成果")
count := 0
var sum = func() int {
count++
fmt.Println("第", count, "次求成果...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
return sum
}
上面代码输出什么呢？次数 count 会不会产生变化，count明显是外层函数的部分变量，可是在内存函数引证（绑缚），内层函数被露出出去了，履行成果如下：
先获取函数，不求成果
等候一会
第 1 次求成果...
成果： 15
第 2 次求成果...
成果： 15
第 3 次求成果...
成果： 15
成果是 count 其实每次都会变化，这种情况总结一下：
- 函数体内嵌套了另外一个函数，而且回来值是一个函数。
- 内层函数被露出出去，被外层函数以外的地方引证着，形成了闭包。
此时有人或许有疑问了，前面是lazySum（）被创立了 1 次，履行了 3 次，可是假如是 3 次履行都是不同的创立，会是怎样样呢？试验一下：
import "fmt"
func main() {
sumFunc := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
sumFunc1 := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc1())
sumFunc2 := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc2())
}
func lazySum(arr []int) func() int {
fmt.Println("先获取函数，不求成果")
count := 0
var sum = func() int {
count++
fmt.Println("第", count, "次求成果...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
return sum
}
履行的成果如下，每次履行都是第 1 次：
先获取函数，不求成果
等候一会
第 1 次求成果...
成果： 15
先获取函数，不求成果
等候一会
第 1 次求成果...
成果： 15
先获取函数，不求成果
等候一会
第 1 次求成果...
成果： 15
从以上的履行成果能够看出：
闭包被创立的时分，引证的外部变量count就现已被创立了 1 份，也便是各自调用是没有关系的。
持续抛出一个问题，**假如一个函数回来了两个函数，这是一个闭包仍是两个闭包呢？**下面咱们实践一下：
一次回来两个函数，一个用于核算加和的成果，一个核算乘积：
import "fmt"
func main() {
sumFunc, productSFunc := lazyCalculate([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
fmt.Println("成果：", productSFunc())
}
func lazyCalculate(arr []int) (func() int, func() int) {
fmt.Println("先获取函数，不求成果")
count := 0
var sum = func() int {
count++
fmt.Println("第", count, "次求加和...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
var product = func() int {
count++
fmt.Println("第", count, "次求乘积...")
result := 0
for _, v := range arr {
result = result * v
}
return result
}
return sum, product
}
运转成果如下：
先获取函数，不求成果
等候一会
第 1 次求加和...
成果： 15
第 2 次求乘积...
成果： 0
从上面成果能够看出，闭包是函数回来函数的时分，不论多少个回来值(函数)，都是一次闭包，假如回来的函数有运用外部函数变量，则会绑定到一同，相互影响：
闭包绑定了周围的状况，我了解此时的函数就具有了状况，让函数具有了目标一切的能力，函数具有了状况。
1.3.2 闭包中的指针和值
上面的比如，咱们闭包中用到的都是数值，假如咱们传递指针，会是怎样样的呢？
import "fmt"
func main() {
i := 0
testFunc := test(&i)
testFunc()
fmt.Printf("outer i = %d\n", i)
}
func test(i *int) func() {
*i = *i + 1
fmt.Printf("test inner i = %d\n", *i)
return func() {
*i = *i + 1
fmt.Printf("func inner i = %d\n", *i)
}
}
运转成果如下：
test inner i = 1
func inner i = 2
outer i = 2
能够看出假如是指针的话，闭包里边修正了指针对应的地址的值，也会影响闭包外面的值。这个其实很容易了解，Go 里边没有引证传递，只需值传递，那咱们传递指针的时分，也是值传递，这儿的值是指针的数值（能够了解为地址值）。
当咱们函数的参数是指针的时分，参数会复制一份这个指针地址，作为参数进行传递，由于本质仍是地址，所以内部修正的时分，仍然能够对外部产生影响。
闭包里边的数据其实地址也是相同的，下面的试验能够证明：
func main() {
i := 0
testFunc := test(&i)
testFunc()
fmt.Printf("outer i address %v\n", &i)
}
func test(i *int) func() {
*i = *i + 1
fmt.Printf("test inner i address %v\n", i)
return func() {
*i = *i + 1
fmt.Printf("func inner i address %v\n", i)
}
}
输出如下, 因此能够推断出，闭包假如引证外部环境的指针数据，仅仅会复制一份指针地址数据，而不是复制一份实在的数据(==先留个问题：复制的时机是什么时分呢==)：
test inner i address 0xc0003fab98
func inner i address 0xc0003fab98
outer i address 0xc0003fab98
1.3.2 闭包推迟化
上面的比如似乎都在告知咱们，闭包创立的时分，数据就现已复制了，可是真的是这样么？
下面是持续前面的试验：
func main() {
i := 0
testFunc := test(&i)
i = i + 100
fmt.Printf("outer i before testFunc %d\n", i)
testFunc()
fmt.Printf("outer i after testFunc %d\n", i)
}
func test(i *int) func() {
*i = *i + 1
fmt.Printf("test inner i = %d\n", *i)
return func() {
*i = *i + 1
fmt.Printf("func inner i = %d\n", *i)
}
}
咱们在创立闭包之后，把数据改了，之后履行闭包，答案必定是实在影响闭包的履行，由于它们都是指针，都是指向同一份数据：
test inner i = 1
outer i before testFunc 101
func inner i = 102
outer i after testFunc 102
假设咱们换个写法，让闭包外部环境中的变量在声明闭包函数的之后，进行修正：
import "fmt"
func main() {
sumFunc := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
}
func lazySum(arr []int) func() int {
fmt.Println("先获取函数，不求成果")
count := 0
var sum = func() int {
fmt.Println("第", count, "次求成果...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
count = count + 100
return sum
}
实践履行成果，count 会是修正后的值：
等候一会
第 100 次求成果...
成果： 15
这也证明了，实践上闭包并不会在声明var sum = func() int {...}这句话之后，就将外部环境的 count绑定到闭包中，而是在函数回来闭包函数的时分，才绑定的，这便是推迟绑定。
假如还没看明白不要紧，咱们再来一个比如：
func main() {
funcs := testFunc(100)
for _, v := range funcs {
v()
}
}
func testFunc(x int) []func() {
var funcs []func()
values := []int{1, 2, 3}
for _, val := range values {
funcs = append(funcs, func() {
fmt.Printf("testFunc val = %d\n", x+val)
})
}
return funcs
}
上面的比如，咱们闭包回来的是函数数组，本意咱们想入每一个 val 都不相同，可是实践上 val都是一个值，==也便是履行到return funcs 的时分（或许实在履行闭包函数的时分）才绑定的 val值==（关于这一点，后边还有个Demo能够证明），此时 val的值是终究一个 3,终究输出成果都是 103:
testFunc val = 103
testFunc val = 103
testFunc val = 103
以上两个比如，都是闭包推迟绑定的问题导致，这也能够说是 feature，到这儿或许不少同学仍是对闭包绑定外部变量的时机有疑问，到底是回来闭包函数的时分绑定的呢？仍是实在履行闭包函数的时分才绑定的呢？
下面的比如能够有用的解答：
import (
"fmt"
"time"
)
func main() {
sumFunc := lazySum([]int{1, 2, 3, 4, 5})
fmt.Println("等候一会")
fmt.Println("成果：", sumFunc())
time.Sleep(time.Duration(3) * time.Second)
fmt.Println("成果：", sumFunc())
}
func lazySum(arr []int) func() int {
fmt.Println("先获取函数，不求成果")
count := 0
var sum = func() int {
count++
fmt.Println("第", count, "次求成果...")
result := 0
for _, v := range arr {
result = result + v
}
return result
}
go func() {
time.Sleep(time.Duration(1) * time.Second)
count = count + 100
fmt.Println("go func 修正后的变量 count：", count)
}()
return sum
}
输出成果如下：
先获取函数，不求成果
等候一会
第 1 次求成果...
成果： 15
go func 修正后的变量 count： 101
第 102 次求成果...
成果： 15
第二次履行闭包函数的时分，明显 count被里边的 go func()修正了，也便是调用的时分，才实在的获取最新的外部环境，可是在声明的时分，就会把环境预留保存下来。
其实本质上，Go Routine的匿名函数的推迟绑定便是闭包的推迟绑定，上面的比如中，go func(){}获取到的便是最新的值，而不是原始值0。
总结一下上面的验证点：
- 闭包每次回来都是一个新的实例，每个实例都有一份自己的环境。
- 同一个实例屡次履行，会运用相同的环境。
- 闭包假如逃逸的是指针，会相互影响，由于绑定的是指针，相同指针的内容修正会相互影响。
- 闭包并不是在声明时绑定的值，声明后仅仅预留了外部环境（逃逸剖析），实在履行闭包函数时，会获取最新的外部环境的值（也称为推迟绑定）。
- Go Routine的匿名函数的推迟绑定本质上便是闭包的推迟绑定。
2、闭包的优点与坏处？
2.1 优点
纯函数没有状况，而闭包则是让函数轻松具有了状况。可是凡事都有两面性，一旦具有状况，屡次调用，或许会呈现不相同的成果，就像是前面测试的 case 中相同。那么问题来了：
Q：假如不支撑闭包的话，咱们想要函数具有状况，需求怎样做呢？
A： 需求运用全局变量，让一切函数同享同一份变量。
可是咱们都知道全局变量有以下的一些特色（在不同的场景，优点会变成缺陷）：
- 常驻于内存之中，只需程序不断会一直在内存中。
- 污染全局，我们都能够拜访，同享的一同不知道谁会改这个变量。
闭包能够必定程度优化这个问题：
- 不需求运用全局变量，外部函数部分变量在闭包的时分会创立一份，生命周期与函数生命周期共同，闭包函数不再被引证的时分，就能够收回了。
- 闭包露出的部分变量，外界无法直接拜访，只能经过函数操作，能够防止滥用。
除了以上的优点，像在 JavaScript 中，没有原生支撑私有办法，能够靠闭包来模仿私有办法，由于闭包都有自己的词法环境。
2.2 坏处
函数具有状况，假如处理不妥，会导致闭包中的变量被误改，但这是编码者应该考虑的问题，是预期中的场景。
闭包中假如随意创立，引证被持有，则无法毁掉，一同闭包内的部分变量也无法毁掉，过度运用闭包会占有更多的内存，导致性能下降。一般而言，能同享一份闭包（同享闭包部分变量数据），不需求屡次创立闭包函数，是比较高雅的办法。
3、闭包怎样完成的？
从上面的试验中，咱们能够知道，闭包实践上便是外部环境的逃逸，跟随着闭包函数一同露出出去。
咱们用以下的程序进行剖析：
import "fmt"
func testFunc(i int) func() int {
i = i * 2
testFunc := func() int {
i++
return i
}
i = i * 2
return testFunc
}
func main() {
test := testFunc(1)
fmt.Println(test())
}
履行成果如下：
5
先看看逃逸剖析，用下面的命令行能够查看：
go build --gcflags=-m main.go
能够看到 变量 i被移到堆中，也便是本来是部分变量，可是产生逃逸之后，从栈里边放到堆里边，同样的 test()函数由于是闭包函数，也逃逸到堆上。
下面咱们用命令行来看看汇编代码：
go tool compile -N -l -S main.go
生成代码比较长，我截取一部分：
"".testFunc STEXT size=218 args=0x8 locals=0x38 funcid=0x0 align=0x0
0x0000 00000 (main.go:5) TEXT "".testFunc(SB), ABIInternal, $56-8
0x0000 00000 (main.go:5) CMPQ SP, 16(R14)
0x0004 00004 (main.go:5) PCDATA $0, $-2
0x0004 00004 (main.go:5) JLS 198
0x000a 00010 (main.go:5) PCDATA $0, $-1
0x000a 00010 (main.go:5) SUBQ $56, SP
0x000e 00014 (main.go:5) MOVQ BP, 48(SP)
0x0013 00019 (main.go:5) LEAQ 48(SP), BP
0x0018 00024 (main.go:5) FUNCDATA $0, gclocals69c1753bd5f81501d95132d08af04464(SB)
0x0018 00024 (main.go:5) FUNCDATA $1, gclocalsd571c0f6cf0af59df28f76498f639cf2(SB)
0x0018 00024 (main.go:5) FUNCDATA $5, "".testFunc.arginfo1(SB)
0x0018 00024 (main.go:5) MOVQ AX, "".i+64(SP)
0x001d 00029 (main.go:5) MOVQ $0, "".~r0+16(SP)
0x0026 00038 (main.go:5) LEAQ type.int(SB), AX
0x002d 00045 (main.go:5) PCDATA $1, $0
0x002d 00045 (main.go:5) CALL runtime.newobject(SB)
0x0032 00050 (main.go:5) MOVQ AX, "".&i+40(SP)
0x0037 00055 (main.go:5) MOVQ "".i+64(SP), CX
0x003c 00060 (main.go:5) MOVQ CX, (AX)
0x003f 00063 (main.go:6) MOVQ "".&i+40(SP), CX
0x0044 00068 (main.go:6) MOVQ "".&i+40(SP), DX
0x0049 00073 (main.go:6) MOVQ (DX), DX
0x004c 00076 (main.go:6) SHLQ $1, DX
0x004f 00079 (main.go:6) MOVQ DX, (CX)
0x0052 00082 (main.go:7) LEAQ type.noalg.struct { F uintptr; "".i *int }(SB), AX
0x0059 00089 (main.go:7) PCDATA $1, $1
0x0059 00089 (main.go:7) CALL runtime.newobject(SB)
0x005e 00094 (main.go:7) MOVQ AX, ""..autotmp_3+32(SP)
0x0063 00099 (main.go:7) LEAQ "".testFunc.func1(SB), CX
0x006a 00106 (main.go:7) MOVQ CX, (AX)
0x006d 00109 (main.go:7) MOVQ ""..autotmp_3+32(SP), CX
0x0072 00114 (main.go:7) TESTB AL, (CX)
0x0074 00116 (main.go:7) MOVQ "".&i+40(SP), DX
0x0079 00121 (main.go:7) LEAQ 8(CX), DI
0x007d 00125 (main.go:7) PCDATA $0, $-2
0x007d 00125 (main.go:7) CMPL runtime.writeBarrier(SB), $0
0x0084 00132 (main.go:7) JEQ 136
0x0086 00134 (main.go:7) JMP 142
0x0088 00136 (main.go:7) MOVQ DX, 8(CX)
0x008c 00140 (main.go:7) JMP 149
0x008e 00142 (main.go:7) CALL runtime.gcWriteBarrierDX(SB)
0x0093 00147 (main.go:7) JMP 149
0x0095 00149 (main.go:7) PCDATA $0, $-1
0x0095 00149 (main.go:7) MOVQ ""..autotmp_3+32(SP), CX
0x009a 00154 (main.go:7) MOVQ CX, "".testFunc+24(SP)
0x009f 00159 (main.go:11) MOVQ "".&i+40(SP), CX
0x00a4 00164 (main.go:11) MOVQ "".&i+40(SP), DX
0x00a9 00169 (main.go:11) MOVQ (DX), DX
0x00ac 00172 (main.go:11) SHLQ $1, DX
0x00af 00175 (main.go:11) MOVQ DX, (CX)
0x00b2 00178 (main.go:12) MOVQ "".testFunc+24(SP), AX
0x00b7 00183 (main.go:12) MOVQ AX, "".~r0+16(SP)
0x00bc 00188 (main.go:12) MOVQ 48(SP), BP
0x00c1 00193 (main.go:12) ADDQ $56, SP
0x00c5 00197 (main.go:12) RET
0x00c6 00198 (main.go:12) NOP
0x00c6 00198 (main.go:5) PCDATA $1, $-1
0x00c6 00198 (main.go:5) PCDATA $0, $-2
0x00c6 00198 (main.go:5) MOVQ AX, 8(SP)
0x00cb 00203 (main.go:5) CALL runtime.morestack_noctxt(SB)
0x00d0 00208 (main.go:5) MOVQ 8(SP), AX
0x00d5 00213 (main.go:5) PCDATA $0, $-1
0x00d5 00213 (main.go:5) JMP 0
能够看到闭包函数实践上底层也是用结构体new创立出来的：
运用的便是堆上面的 i：
也便是回来函数的时分，实践上回来结构体，结构体里边记录了函数的引证环境。
4、浅聊一下
4.1 Java 支不支撑闭包？
网上有许多种观点，实践上 Java 尽管暂时不支撑回来函数作为返参，可是Java 本质上仍是完成了闭包的概念的，所运用的的办法是内部类的方式，由于是内部类，所以相当于自带了一个引证环境，算是一种不完整的闭包。
现在有必定约束，比方是 final 声明的，或许是明确界说的值，才能够进行传递：
Stack Overflow上有相关答案：stackoverflow.com/questions/5…
4.2 函数式编程的前景怎样样？
下面是Wiki的内容：
函数式编程长期以来在学术界盛行，但几乎没有工业运用。造成这种局势的主因是函数式编程常被以为严峻耗费CPU和存储器资源[18] ，这是由于在前期完成函数式编程言语时并没有考虑过效率问题，而且面向函数式编程特性，如保证参照通明性等，要求独特的数据结构和算法。[19]
可是，最近几种函数式编程言语现已在商业或工业体系中运用[20]，例如：
- Erlang，它由瑞典公司爱立信在20世纪80年代后期开发，最初用于完成容错电信体系。此后，它已在Nortel、Facebook、lectricit de France和WhatsApp等公司作为盛行言语创立一系列运用程序。[21][22]
- Scheme，它被用作前期Apple Macintosh核算机上的几个运用程序的基础，而且最近已运用于诸如练习模仿软件和望远镜操控等方向。
- OCaml，它于20世纪90年代中期推出，现已在金融剖析，驱动程序验证，工业机器人编程和嵌入式软件静态剖析等范畴得到了商业运用。
- Haskell，它尽管最初是作为一种研讨言语，也已被一系列公司运用于航空航天体系，硬件规划和网络编程等范畴。
其他在工业中运用的函数式编程言语包括多范型的Scala[23]、F#，还有Wolfram言语、Common Lisp、Standard ML和Clojure等。
从我个人的观点，不看好纯函数编程，可是函数式编程的思维，我信任今后几乎每门高级编程需求都会具有，特别期待 Java 拥抱函数式编程。从我自己了解的言语看，像 Go，JavaScript 中的函数式编程的特性，都让开发者深爱不已（当然，假如写出了bug，便是深恶痛疾）。
最近忽然火了一波的原因，也是由于国际不断的发展，内存也越来越大，这个因素的约束几乎要解放了。
我信任，国际便是绚丽多彩的，要是一种事物控制国际，绝无或许，更多的是百家争鸣，编程言语或许编程范式也相同，后续或许有集大成者，终究终究历史会筛选出终究符合人类社会发展的。
【作者简介】：
秦怀，大众号【秦怀杂货店】作者，个人网站：aphysia.cn，技术之路不在一时，山高水长，纵使缓慢，驰而不息。
