开发者社区> 西游不取经> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

跨界闭包之javascript,java,groovy

简介: 闭包之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 closure
go to closure
hello 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闭包


闭包的特性也不止于此,包括函数科里化,递归中也有使用等

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
JAVA转为wasm/JavaScript,可以考虑CheerpJ
JAVA转为wasm/JavaScript,可以考虑CheerpJ
0 0
Java细节:单等于号、双等于号、三等于号(js中才有)的作用及双等于号和equals(源码)的区别
Java细节:单等于号、双等于号、三等于号(js中才有)的作用及双等于号和equals(源码)的区别
0 0
关于Java的常识与误解,JavaScript和Java是一个妈生的吗?
关于Java的常识与误解,JavaScript和Java是一个妈生的吗?
0 0
知识分享之Java——JS中展示字符串根据限定长度截取并拼接...
使用java编写jsp时有时我们需要对其内容在前端进行截取,这时就需要使用到js的一些字符串操作函数了,下面是我整理的一个标题显示截取的小工具,有需要的可以直接使用,当然有的小伙伴直接将其简化为三目运算符的方式,但我用自动扫描工具显示不推荐使用,因此还是老实使用这个if写法了。
0 0
Java如何优雅地执行js
Java如何优雅地执行js
0 0
Java和JavaScript的区别
Java和JavaScript的区别自制脑图
0 0
JAVA Web入门之脚本语言javaScript的详细介绍及实战
JAVA Web入门之脚本语言javaScript的详细介绍及实战
0 0
java调用js实现富文本过滤
java调用js实现富文本过滤
0 0
Java:ScriptEngine执行js代码
Java:ScriptEngine执行js代码
0 0
+关注
西游不取经
其实呢,我只是一个前端
文章
问答
文章排行榜
最热
最新
相关电子书
更多
Javascript中的函数
立即下载
Javascript异步编程
立即下载
JS零基础入门教程(上册)
立即下载