groovy-闭包

时间 2019-11-18

标签 groovy 闭包栏目 Groovy 繁體版

原文原文链接

什么是闭包

一个groovy闭包就像一个代码块或者方法指针，他是定义而后执行的一段代码，可是他有一些特性：隐含变量，支持自由变量，支持currying 。java

咱们先来看看一些例子：闭包

 
       1 
       def clos = { println "hello!" } 
      
       2 
         
       3 
       println "Executing the Closure:" 
      
       4 
       clos() //prints "hello!"

在上面的例子中”hello!”是由于调用clos（）函数才打印出来的，而不是在定义的时候打印出来的。ide

参数

闭包的参数在->以前列出，好比：函数

 
       1 
       def printSum = { a, b -> print a+b } 
      
       2 
       printSum( 5, 7 ) //prints "12"

若是闭包的参数是少于2个的话，那么 ->是能够省略的。ui

Parameter notes

A Closure without -> , i.e. {} , is a Closure with one argument that is implicitly named as ‘it’. (see below for details) In some cases, you need to construct a Closure with zero arguments, e.g. using GString for templating, defining EMC Property etc. You have to explicity define your Closure as { -> } instead of just { }this

You can also use varargs as parameters, refer to the Formal Guide for details. A JavaScript-style dynamic args could be simulated, refer to the Informal Guide.spa

自由变量

闭包能引用在参数列表中没有列出的变量，这些变量成为自由变量，他们的做用范围在他们定义的范围内：指针

 
       1 
       def myConst = 5 
      
       2 
       def incByConst = { num -> num + myConst } 
      
       3 
       println incByConst(10) // => 15

另一个例子：code

 
       1 
       def localMethod() { 
      
       2 
        def localVariable = new java.util.Date() 
      
       3 
        return { println localVariable } 
      
       4 
       } 
      
       5 
         
       6 
       def clos = localMethod() 
      
       7 
         
       8 
       println "Executing the Closure:" 
      
       9 
       clos() //prints the date when "localVariable" was defined

隐式变量

it

若是你有一个闭包可是只有一个参数，那么你能够省略这个参数，好比：orm

 
       1 
       def clos = { print it } 
      
       2 
       clos( "hi there" ) //prints "hi there"

this, owner, and delegate

this : 和java中是同样的, this refers to the instance of the enclosing class where a Closure is defined

owner : the enclosing object (this or a surrounding Closure)

delegate : by default the same as owner, but changeable for example in a builder or ExpandoMetaClass

 
       1 
       class Class1 { 
      
       2 
        def closure = { 
      
       3 
        println this.class.name 
      
       4 
        println delegate.class.name 
      
       5 
        def nestedClos = { 
      
       6 
        println owner.class.name 
      
       7 
        } 
      
       8 
        nestedClos() 
      
       9 
        } 
      
       10 
       } 
      
       11 
         
       12 
       def clos = new Class1().closure 
      
       13 
       clos.delegate = this 
      
       14 
       clos() 
      
       15 
       /* prints: 
      
       16 
        Class1 
      
       17 
        Script1 
      
       18 
        Class1$_closure1 */

闭包做为方法参数

当一个方法使用闭包做为最后一个参数的话，那么就能够内嵌一个闭包，好比：

 
       1 
       def list = ['a','b','c','d'] 
      
       2 
       def newList = [] 
      
       3 
         
       4 
       list.collect( newList ) { 
      
       5 
        it.toUpperCase() 
      
       6 
       } 
      
       7 
       println newList // ["A", "B", "C", "D"]

在上面的collect方法中，他接受一个一个List和闭包，上面的代码等价于下面的代码：

 
       1 
       def list = ['a','b','c','d'] 
      
       2 
       def newList = [] 
      
       3 
         
       4 
       def clos = { it.toUpperCase() } 
      
       5 
       list.collect( newList, clos ) 
      
       6 
         
       7 
       assert newList == ["A", "B", "C", "D"]

更多的信息：

Groovy继承了 java.lang.Object而且许多的 Collection 和Map 的许多方法都接受闭包做为参数的 See GDK Extensions to Object for practical uses of Groovy's Closures.