跨界闭包之javascript，java，groovy
一提闭包，前端首先想到的肯定就是javascript的闭包，接着就是其特性，闭包里的变量常驻内存不会消失，外部函数可以访问内部函数的变量，似乎是摆脱了作用域的限制。 那么就先说说前端js的闭包，最简单的一个例子 function closure1() { var tmp = 'hello world'; return function() { return 'this say ' + tmp; } } //运行 var result1 = closure1(); //result1 等于 this say hello world 这样函数的局部变量就不限于函数体内，同时局部变量也不是唯一可以返回的，函数的参数也可以被返回捕获 //数组每一项乘以multiple， multiple被捕获 function closure2(multiple) { return function(ary) { return ary.map(function(item, i) { return item * multiple }) } } var multipleClosure = closure2(9); var result = multipleClosure([1,2,4,5,7]); //或者 result = closure2(9)([1,2,4,5,7]); console.log(result) //result == [9, 18, 36, 45, 63] multiple变量一直保存在返回的函数体内，必能在调用返回的multipleClosure是访问到。 基于对html元素的访问时闭包也是个好东西，尤其是通过getElementsByTagName或这个getElementsByClassName时 <p class="closure">closure1</p> <p class="closure">closure2</p> <p class="closure">closure3</p> <p class="closure">closure4</p> <p class="closure">closure5</p> function init() { var pAry = document.getElementsByClassName("closure"); for( var i = 0, item; item = pAry[i++]; ) { item.onclick = function() { console.log(i) // i 永远输出6 } } } init() 以上无论你点击哪个p元素都是输出6，这样情况下在事件上包裹一层匿名闭包，让i以局部变量方式访问到 function init() { var pAry = document.getElementsByClassName("closure"); for( var i = 0, item; item = pAry[i++]; ) { (function() { var tmp = i item.onclick = function() { console.log(tmp) } })() } } 有时需要实现一个类让其具有私有属性，并能对操作访问，比如实现一个Stack const items = new WeakMap(); class Stack { constructor() { items.set(this, []) } push(ele) { let s = items.get(this); s.push(ele) } pop() { let s = items.get(this); let r = s.pop(); return r; } } let stack = new Stack() stack.push(121) console.log(items) 这样做items不是私有属性任何一个方法都可以改动他，于是可以在外Stack用闭包包起来 let Stack = (function() { const items = new WeakMap(); class Stack { constructor() { items.set(this, []) } push(ele) { let s = items.get(this); s.push(ele) } pop() { let s = items.get(this); let r = s.pop(); return r; } getItems() { return items; } } return Stack; })(); let stack = new Stack() stack.push(121) console.log(stack.getItems()) 这样做有个弊端，扩展无法继承私有属性 前端或以为闭包只是js的专利，其实不然，闭包轻量级，短小，简洁的特性在其他语言中更具有优越性，尤其是在函数式编程中，可以避免代码冗长如下面java实现的闭包 public class closureTest { public static Runnable closure() { String string = "hello closure"; Runnable runnable = () -> System.out.println(string); System.out.println("exiting closure"); return runnable; } public static void main(String[] args) { Runnable runnable = closure(); System.out.println("go to closure"); runnable.run(); } } 上列中，closure 方法有一个局部变量 value，该变量的寿命很短：只要我们退出 closure，它就会消失。closure 内创建的闭包在其词法范围中引用了这个变量。在完成 closure 方法后，该方法将闭包返回给 main 中的调用方。在此过程中，它从自己的堆栈中删除变量 value，但是lambda 表达式将会执行。 exiting closurego to closurehello closure 有时需要数值计算，比如计算数值的能否被整除，和倍数 import static java.util.stream.Collectors.toList; import java.util.Arrays; import java.util.List; public class test { public static void call() { // numbers } public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 3, 5, 6, 8); List result = numbers.stream() .filter(e -> e % 2 == 0) //过滤出可以被2整除的 .map(e -> e * 2) //过滤出返回的 在乘以2 .collect(toList()); System.out.println(result); } } map接收的是一个单纯的lambda表达式，通常倍数是变化的，就需一种方式把变量传递给lambda表达式，那换成闭包如下 import static java.util.stream.Collectors.toList; import java.util.Arrays; import java.util.List; public class test { public static void call() { // numbers } public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 3, 5, 6, 8); int factor = 5; List result = numbers.stream() .filter(e -> e % 2 == 0) .map(e -> e * factor) //map接受一个闭包。 闭包接收参数e ，同时捕获携带 factor 变量的状态 .collect(toList()); System.out.println(result); } } 运行 javap -p test.class Compiled from "test.java" public class test { public test(); public static void main(java.lang.String[]); private static java.lang.Integer lambda$main$1(int, java.lang.Integer); private static boolean lambda$main$0(java.lang.Integer); } 可以看出java编译器为闭包创建一个 lambda$main$ 方法捕获一个int类型数据，在看看字节码javap -c -p test.class 来检查字节码 public static void main(java.lang.String[]); Code: 0: iconst_1 1: anewarray #2 // class java/lang/Integer 4: dup 5: iconst_0 6: bipush 6 8: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 11: aastore 12: invokestatic #4 // Method java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List; 15: astore_1 16: bipush 9 18: istore_2 19: aload_1 后面省略。。。。。 private static java.lang.Integer lambda$main$1(int, java.lang.Integer); Code: 0: aload_1 1: invokevirtual #15 // Method java/lang/Integer.intValue:()I 4: iload_0 5: imul 6: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 9: areturn 把变量9 int类型值存入局部变量2，从局部变量1中装载引用类型值，然后状态变量被lambda$main$1加载并传递到为闭包创建的函数中。可以看出闭包能捕获并携带状态，并将状态从定义上下文携带到执行点 再看看groovy的闭包实现 //计算1-n的和 def sum(n) { total = 0 for (int i = 1; i <= n; i++) { total += i } total } //输出3 println sum(2) //计算1-n的乘 def multi(n) { total = 1 for (int i = 1; i <= n; i++) { total *= i; } //return 可以省略 return total } //输出6 println multi(3) 上面的运算中，都有一个共同的循环，循环内部不一样，修改下我们把 def com(n, inside) { for (int i = 1; i <= n; i++) { inside(i) } } total = 0 com(2, { total += it }) println total 求和如此，那么求乘积如下 total = 1 com(3, { total *= it }) println total 可以看出，com方法是以一个函数作为参数，返回函数作为结果。以上方法把中在循环时，把i值传递给了匿名代码块。在Groovy中就称这类匿名代码块为闭包。可以换种写法 com(2) { total += it } 这个看着像不像前面js的 closure2()() inside中保存了一个指向闭包的引用，{}内部的代码又被传递给了inside 给闭包传递多个参数 def parames(closure) { closure 20, "dollars, so rich" } parames() { money, msg -> println "I have ${money} ${msg} " } 调用closure中，parames有一个数字，一个字符串参数，闭包分别用 money和msg引用指向它们输出 I have 20 dollars, so rich 复合闭包 def filterAryValue(closure) { def ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def len = ary.size() - 1 for (int i = 0; i <= len; i++) { ary[i] = closure(ary[i]) } ary } def subtract = {it -> it - 1} def multi = {it -> it * 2 } println filterAryValue({it -> multi(subtract(it)) }) //[0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 第一次使用闭包subtract 返回的值再传递给multi闭包 闭包的特性也不止于此，包括函数科里化，递归中也有使用等
