详解 groovy 的闭包（上）

groovy 的闭包特点

在 groovy 中的闭包。groovy 中的闭包是一个开放的匿名代码块，可以接受参数，返回值可以赋值给变量。
我们通常学习的 lamb 表达式是有一定封闭空间，无法访问闭包的变量

def greeting = { x -> x + 3}
println greeting(3) 

而在 groovy 的闭包是可以访问到外部变量的。虽然这样更自由但是也打破这个封闭空间

def factor = 3
def greeting = { x -> x + factor}
println greeting(3)

groovy 的闭包的定义

可以接受不同类型参数

def info = { String name,int age -> name + "," + age}
println info("matthew",30)

闭包中使用隐含变量 it

def greeting =  { it ->  "hey $it" } 
println greeting("matthew")

闭包可以作为一个对象使用

可以通过 def 或 Closure 来定义闭包

Closure callback = { println 'Done!' } 
callback()

Closure<Boolean> callback = { it==1 } 
println callback(1)

闭包的调用

上面我们已经了解到了如何调用闭包，除了上面方法也可以通过call方法进行调用

Closure<Boolean> callback = { it==1 } 
println callback.call(1)

闭包的参数

• 参数是可以有类型也可以不定义类型
• 有一个隐含参数 it
• 接受可变参数

    def greeting =  { String ...name ->  "hey ${name.join(" ")}" } 
    println greeting("matthew","jerry")

代理是 groovy 闭包的关键，为 groovy 成 SDL 语言提供基础。怎么理解呢，如果你是 web 前端开发者，使用过 javascript 这个就应该不难理解了。其实可以将他理解为 javascript 的原型链的 property 我们可以通过原型链向上查找自己需要方法。

闭包中的 this

class Enclosing {
    void run() {
        println "run..."
        def whatIsThisObject = { getThisObject() }          
        assert whatIsThisObject() == this                   
        def whatIsThis = { this }                           
        assert whatIsThis() == this                         
    }
}

我们可以看一看在 groovy 中闭包的中 this 是什么， whatIsThisObject 是一个闭包 getThisObject() 可以获取 this，或者直接用 this

我们在看一看类中的内部类的情况

class EnclosedInInnerClass {
    class Inner {
        Closure cl = { this }                               
    }
    void run() {
        def inner = new Inner()
        assert inner.cl() == inner                          
    }
}

这里 this 会返回 inner 而不是 EnclosedInInnerClass，这不就是 javascript 的原型吗？向上查找查找最近。

class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { this }                               
            cl()
        }
        assert nestedClosures() == this                     
    }
}

这里 this 没有指向这个 nestedClosures 而是指代了外层的 NestedClosures

闭包的Owner

闭包的 owner 与闭包中的 this 非常相似，但有细微的区别：owner 将返回直接封闭对象，可能是是闭包也可能是类

class Enclosing {
    void run() {
        def whatIsOwnerMethod = { getOwner() }               
        assert whatIsOwnerMethod() == this                   
        def whatIsOwner = { owner }                          
        assert whatIsOwner() == this                         
    }
}
class EnclosedInInnerClass {
    class Inner {
        Closure cl = { owner }                               
    }
    void run() {
        def inner = new Inner()
        assert inner.cl() == inner                           
    }
}

没有啥区别，不解释了。

class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { owner }                               
            cl()
        }
        assert nestedClosures() == nestedClosures            
    }
}

这里在nestedClosures 一个封闭空间所以这里有点差别，这里注意一下这里返回的 owner 是 nestedClosures 闭包而不是外面的 NestedClosures 这点与 this 不同。