groovy 閉包

語法規則

{ [closureParameters -> ] statements }

下面的語句都是正確的

 1 { item++ }
 2 { -> item++ }
 3 { println it }
 4 { it -> println it }
 5 { name -> println name }
 6 { String x, int y -> println "hey ${x} the value is ${y}" }
 7 { reader ->
 8     def line = reader.readLine()
 9     line.trim()
10 }

參數列表

1 def closureWithTwoArgsAndOptionalTypes = { a, int b -> a+b }
2 assert closureWithTwoArgsAndOptionalTypes(1,2) == 3

能夠看到參數列表使用逗號分隔，並且 typed 和 untyped 都可，-> 符號用以分隔參數列表和語句。值得提一下，若是閉包只有一個參數，那麼能夠省略參數列表，直接使用 it 代替參數。

委託策略

閉包有三個概念：this、owner 和 delegate

this 定義閉包的封閉類（enclosing class）

owner 定義閉包的封閉對象（enclosing object），多是類也多是對象

delegate 被調用方法或者引用屬性的第三方對象，這個須要具體參考代碼

this

 1 class Enclosing {
 2     void run() {
 3         def whatIsThisObject = { getThisObject() }          // 返回對象 this
 4         assert whatIsThisObject() == this
 5         def whatIsThis = { this }                           // 返回對象 this
 6         assert whatIsThis() == this
 7     }
 8 }
 9 class EnclosedInInnerClass {
10     class Inner {
11         Closure cl = { this }                               // Inner 類的對象 this
12     }
13     void run() {
14         def inner = new Inner()
15         assert inner.cl() == inner
16     }
17 }
18 class NestedClosures {
19     void run() {
20         def nestedClosures = {
21             def cl = { this }                              
22             cl()                                            // 仍是 this
23         }
24         assert nestedClosures() == this
25     }
26 }

能夠看出 groovy 閉包中的 this 和 java 是一致的。

owner

 1 class Enclosing {
 2     void run() {
 3         def whatIsOwnerMethod = { getOwner() }                  // 對象的 this
 4         assert whatIsOwnerMethod() == this
 5         def whatIsOwner = { owner }                             // 一樣是對象的 this                   
 6         assert whatIsOwner() == this
 7     }
 8 }
 9 class EnclosedInInnerClass {
10     class Inner {
11         Closure cl = { owner }                                  // 本質上仍是對象的 this
12     }
13     void run() {
14         def inner = new Inner()
15         assert inner.cl() == inner                           
16     }
17 }
18 class NestedClosures {
19     void run() {
20         def nestedClosures = {
21             def cl = { owner }                               
22             cl()
23         }
24         assert nestedClosures() == nestedClosures            // 此處就是 this 就有區別了，和 owner 的語義一致
25     }
26 }

delegate

上面的 this 和 owner 引用的都是閉包 scope 的內容，可是 delegate 能夠引用第三方對象的內容，默認 delegate 被設置爲 owner，由於第三方對象不必定被設置。

 1 class Person {
 2     String name
 3 }
 4 class Thing {
 5     String name
 6 }
 7 
 8 def p = new Person(name: 'Norman')
 9 def t = new Thing(name: 'Teapot')
10 
11 def upperCasedName = { delegate.name.toUpperCase() } // delegate 能夠省略 name.toUpperCase() 也是正確的
12 
13 upperCasedName.delegate = p
14 assert upperCasedName() == 'NORMAN'
15 upperCasedName.delegate = t
16 assert upperCasedName() == 'TEAPOT'
17 
18 // 和引用外部變量有本質區別，下面的 target 不可能被省略
19 def target = p
20 def upperCasedNameUsingVar = { target.name.toUpperCase() }
21 assert upperCasedNameUsingVar() == 'NORMAN'

修改策略

「默認 delegate 被設置爲 owner」，這句話隱含意思就是 delegate 的策略能夠被調整，有下面四種策略，

Closure.OWNER_FIRST 默認的
Closure.DELEGATE_FIRST delegate 優先
Closure.OWNER_ONLY 只取 owner
Closure.DELEGATE_ONLY 只取 delegate
Closure.TO_SELF 若是用戶本身實現 Closure 的子類，這個纔有意義

 1 class Person {
 2     String name
 3     int age
 4     def fetchAge = { age }
 5 }
 6 class Thing {
 7     String name
 8 }
 9 
10 def p = new Person(name:'Jessica', age:42)
11 def t = new Thing(name:'Printer')
12 def cl = p.fetchAge
13 cl.delegate = p
14 assert cl() == 42
15 cl.delegate = t
16 assert cl() == 42                   // 默認狀況下 Closure.OWNER_FIRST，因此此處斷言是經過的
17 cl.resolveStrategy = Closure.DELEGATE_ONLY
18 cl.delegate = p
19 assert cl() == 42
20 cl.delegate = t
21 try {
22     cl()                            // 只取 delegate，Thing 類無 age 字段，異常
23     assert false
24 } catch (MissingPropertyException ex) {
25     // 異常會在這裏被捕獲
26 }

以上內容均參考 http://www.groovy-lang.org/closures.html，文檔中還講到了 closures in GStrings、currying 等頗有意思的內容。