blocks|key|356527|text|使用散点运算符的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356528|def+animals+=+['ant',+'buffalo',+'canary',+'dog']
assert+animals.size()+==+4
assert+animals*.size()+==+[3,+7,+6,+3]|code-block|syntax|javascript|356529|这是animals.collect+{+it.size()+}的快捷方式。|offset|length|style|BOLD|CODE|356530|entityMap^0|0|0|0|11|2|T|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@$I|S|J|T|K|L]|$I|U|J|V|K|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Using the spread-dot operator

<pre><code>def animals = ['ant', 'buffalo', 'canary', 'dog']
assert animals.size() == 4
assert animals*.size() == [3, 7, 6, 3]
</code></pre>

This is a shortcut for <code>animals.collect { it.size() }</code>.

blocks|key|3355135|text|使用带有的方法可以实现以下功能：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3355136|+myObj1.setValue(10)
+otherObj.setTitle(myObj1.getName())
+myObj1.setMode(Obj1.MODE_NORMAL)|code-block|syntax|javascript|3355137|进入到这个|3355138|+myObj1.with+{
++++value+=+10
++++otherObj.title+=+name
++++mode+=+MODE_NORMAL
+}|3355139|entityMap^0|5|B|0|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

The with method allows to turn this:

<pre><code> myObj1.setValue(10)
 otherObj.setTitle(myObj1.getName())
 myObj1.setMode(Obj1.MODE_NORMAL)
</code></pre>

into this

<pre><code> myObj1.with {
 value = 10
 otherObj.title = name
 mode = MODE_NORMAL
 }
</code></pre>

blocks|key|359827|text|使用散列作为伪对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|359828|def+x+=+[foo:1,+bar:{->+println+"Hello,+world!"}]
x.foo
x.bar()|code-block|syntax|javascript|359829|结合使用鸭子类型，您可以使用此方法走很长一段路。甚至不需要去掉"as“操作符。|359830|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Using hashes as pseudo-objects.

<pre><code>def x = [foo:1, bar:{-&gt; println "Hello, world!"}]
x.foo
x.bar()
</code></pre>

Combined with duck typing, you can go a long way with this approach. Don't even need to whip out the "as" operator.

blocks|key|3142061|text|有人知道Elvis吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3142062|def+d+=+"hello";
def+obj+=+null;

def+obj2+=+obj+?:+d;+++//+sets+obj2+to+default
obj+=+"world"

def+obj3+=+obj+?:+d;++//+sets+obj3+to+obj+(since+it's+non-null)|code-block|syntax|javascript|3142063|entityMap^0|4|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Anyone know about Elvis?

<pre><code>def d = "hello";
def obj = null;

def obj2 = obj ?: d; // sets obj2 to default
obj = "world"

def obj3 = obj ?: d; // sets obj3 to obj (since it's non-null)
</code></pre>

blocks|key|360055|text|找出对象上有哪些方法就像询问metaClass一样简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360056|"foo".metaClass.methods.name.sort().unique()|code-block|syntax|javascript|360057|打印：|360058|["charAt",+"codePointAt",+"codePointBefore",+"codePointCount",+"compareTo",
+"compareToIgnoreCase",+"concat",+"contains",+"contentEquals",+"copyValueOf",+
+"endsWith",+"equals",+"equalsIgnoreCase",+"format",+"getBytes",+"getChars",+
+"getClass",+"hashCode",+"indexOf",+"intern",+"lastIndexOf",+"length",+"matches",+
+"notify",+"notifyAll",+"offsetByCodePoints",+"regionMatches",+"replace",+
+"replaceAll",+"replaceFirst",+"split",+"startsWith",+"subSequence",+"substring",+
+"toCharArray",+"toLowerCase",+"toString",+"toUpperCase",+"trim",+"valueOf",+"wait"]|360059|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Finding out what methods are on an object is as easy as asking the metaClass:

<pre><code>"foo".metaClass.methods.name.sort().unique()
</code></pre>

prints: 

<pre><code>["charAt", "codePointAt", "codePointBefore", "codePointCount", "compareTo",
 "compareToIgnoreCase", "concat", "contains", "contentEquals", "copyValueOf", 
 "endsWith", "equals", "equalsIgnoreCase", "format", "getBytes", "getChars", 
 "getClass", "hashCode", "indexOf", "intern", "lastIndexOf", "length", "matches", 
 "notify", "notifyAll", "offsetByCodePoints", "regionMatches", "replace", 
 "replaceAll", "replaceFirst", "split", "startsWith", "subSequence", "substring", 
 "toCharArray", "toLowerCase", "toString", "toUpperCase", "trim", "valueOf", "wait"]
</code></pre>

blocks|key|3355337|text|要截获缺少的静态方法，请使用以下方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3355338|+Foo+{
++++static+A()+{+println+"I'm+A"}

+++++static+$static_methodMissing(String+name,+args)+{
++++++++println+"Missing+static+$name"
+++++}
+}

Foo.A()++//prints+"I'm+A"
Foo.B()++//prints+"Missing+static+B"|code-block|syntax|javascript|3355339|-Ken|3355340|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

To intercept missing static methods use the following 

<pre><code> Foo {
 static A() { println "I'm A"}

 static $static_methodMissing(String name, args) {
 println "Missing static $name"
 }
 }

Foo.A() //prints "I'm A"
Foo.B() //prints "Missing static B"
</code></pre>

-Ken

blocks|key|3355398|text|解构|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3355399|在Groovy中它可能被称为其他东西；在clojure中它被称为解构。你永远不会相信它会变得多么方便。|3355400|def+list+=+[1,+'bla',+false]
def+(num,+str,+bool)+=+list
assert+num+==+1
assert+str+==+'bla'
assert+!bool|code-block|syntax|javascript|3355401|entityMap^0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Destructuring

It might be called something else in Groovy; it's called destructuring in clojure. You'll never believe how handy it can come.

<pre><code>def list = [1, 'bla', false]
def (num, str, bool) = list
assert num == 1
assert str == 'bla'
assert !bool
</code></pre>

blocks|key|355136|text|对于使用groovy测试java代码，对象图构建器是非常棒的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355137|def+company+=+builder.company(+name:+'ACME'+)+{
+++address(+id:+'a1',+line1:+'123+Groovy+Rd',+zip:+12345,+state:+'JV'+)
+++employee(++name:+'Duke',+employeeId:+1+){
++++++address(+refId:+'a1'+)
+++}
}|code-block|syntax|javascript|355138|标准功能，但仍然很好。|355139|ObjectGraphBuilder|offset|length|355140|(您确实需要为List的POJO属性提供空列表的默认值，而不是null，这样构建器支持才能正常工作。)|style|CODE|355141|entityMap|0|LINK|mutability|MUTABLE|url|http://webcache.googleusercontent.com/search?q=cache:groovy.codehaus.org/ObjectGraphBuilder^0|0|0|0|0|I|0|0|7|4|V|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@$K|12|L|13|1|14]]|A|$]]|$1|M|3|N|5|6|7|15|8|@$K|16|L|17|O|P]|$K|18|L|19|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

For testing java code with groovy, object graph builder is amazing:

<pre><code>def company = builder.company( name: 'ACME' ) {
 address( id: 'a1', line1: '123 Groovy Rd', zip: 12345, state: 'JV' )
 employee( name: 'Duke', employeeId: 1 ){
 address( refId: 'a1' )
 }
}
</code></pre>

Standard feature, but still really nice.

<a href="http://webcache.googleusercontent.com/search?q=cache:groovy.codehaus.org/ObjectGraphBuilder" rel="nofollow noreferrer">ObjectGraphBuilder</a>

(You do need to give any properties of your POJO that are <code>List</code>s a default value of an empty list rather than <code>null</code> for builder support to work.)

blocks|key|3142129|text|println+
"""
Groovy+has+"multi-line"+strings.
Hooray!
"""|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3142130|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>println 
"""
Groovy has "multi-line" strings.
Hooray!
"""
</code></pre>

blocks|key|3355127|text|与Java不同，在Groovy中，任何东西都可以在switch语句中使用，而不仅仅是原始类型。在典型的eventPerformed方法中|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3355128|switch(event.source)+{
+++case+object1:
++++++++//+do+something
++++++++break
+++case+object2:
++++++++//+do+something
++++++++break
}|code-block|syntax|javascript|3355129|entityMap^0|P|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Unlike Java, in Groovy, anything can be used in a switch statement, not just primitive types.
In a typical eventPerformed method

<pre><code>switch(event.source) {
 case object1:
 // do something
 break
 case object2:
 // do something
 break
}
</code></pre>

blocks|key|356633|text|在groovy+1.6中，正则表达式可以使用所有的闭包迭代器(如each、collect、inject等)，并允许您轻松地使用捕获组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356634|def+filePaths+=+"""
/tmp/file.txt
/usr/bin/dummy.txt
"""

assert+(filePaths+=~+/(.*)\/(.*)/).collect+{+full,+path,+file+->+
++++++++"$file+->+$path"
++++}+==++["file.txt+->+/tmp",+"dummy.txt+->+/usr/bin"]|code-block|syntax|javascript|356635|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In groovy 1.6, regular expressions work with all of the closure iterators (like each, collect, inject, etc) and allow you to easily work with the capture groups:

<pre><code>def filePaths = """
/tmp/file.txt
/usr/bin/dummy.txt
"""

assert (filePaths =~ /(.*)\/(.*)/).collect { full, path, file -&gt; 
 "$file -&gt; $path"
 } == ["file.txt -&gt; /tmp", "dummy.txt -&gt; /usr/bin"]
</code></pre>

blocks|key|357426|text|使用宇宙飞船操作符的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357427|我喜欢Spaceship+operator，它对各种自定义排序场景都很有用。用法的一些例子是here。它特别有用的一种情况是使用多个字段动态创建一个对象的比较器。例如：|offset|length|style|BOLD|357428|def+list+=+[
++++[+id:0,+first:+'Michael',+last:+'Smith',+age:+23+],
++++[+id:1,+first:+'John',+last:+'Smith',+age:+30+],
++++[+id:2,+first:+'Michael',+last:+'Smith',+age:+15+],++++
++++[+id:3,+first:+'Michael',+last:+'Jones',+age:+15+],+++
]

//+sort+list+by+last+name,+then+first+name,+then+by+descending+age
assert+(list.sort+{+a,b+->+a.last+<=>+b.last+?:+a.first+<=>+b.first+?:+b.age+<=>+a.age+})*.id+==+[+3,1,0,2+]|code-block|syntax|javascript|357429|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Spaceship_operator|1|http://mrhaki.blogspot.com/2009/08/groovy-goodness-spaceship-operator.html^0|0|0|2C|3|I|0|1A|4|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@$D|10|E|11|1|12]|$D|13|E|14|1|15]]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

Using the Spaceship Operator

I like the <a href="http://en.wikipedia.org/wiki/Spaceship_operator" rel="noreferrer">Spaceship operator</a>, useful for all sorts of custom sorting scenarios. Some examples of usage are <a href="http://mrhaki.blogspot.com/2009/08/groovy-goodness-spaceship-operator.html" rel="noreferrer">here</a>. One situation in which it's particularly helpful is in creating a comparator on the fly of an object using multiple fields. e.g.

<pre><code>def list = [
 [ id:0, first: 'Michael', last: 'Smith', age: 23 ],
 [ id:1, first: 'John', last: 'Smith', age: 30 ],
 [ id:2, first: 'Michael', last: 'Smith', age: 15 ], 
 [ id:3, first: 'Michael', last: 'Jones', age: 15 ], 
]

// sort list by last name, then first name, then by descending age
assert (list.sort { a,b -&gt; a.last &lt;=&gt; b.last ?: a.first &lt;=&gt; b.first ?: b.age &lt;=&gt; a.age })*.id == [ 3,1,0,2 ]
</code></pre>

blocks|key|360030|text|闭包可以让资源管理的所有旧的try-+all游戏消失。文件流在块的末尾自动关闭：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360031|new+File("/etc/profile").withReader+{+r+->
++++System.out+<<+r
}|code-block|syntax|javascript|360032|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Closures can make all the old try-finally games of resource management go away. The file stream is automatically closed at the end of the block:

<pre><code>new File("/etc/profile").withReader { r -&gt;
 System.out &lt;&lt; r
}
</code></pre>

blocks|key|355376|text|GDK的groovy.transform包中的转换所提供的特性，例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|355377|355378|@Immutable：@Immutable注解指示编译器执行AST转换，该转换添加必要的getter、构造函数、equals、hashCode和其他辅助方法，这些方法通常是在使用定义的properties.|unordered-list-item|355379|@CompileStatic：创建不可变的类时编写的。这将允许Groovy编译器使用Java风格的编译时检查，然后执行静态编译，从而绕过Groovy元对象protocol.|355380|@Canonical：@Canonical注解指示编译器执行AST转换，该转换将位置构造函数、equals、hashCode和pretty+print+toString添加到类中。|355381|355382|其他：|355383|355384|@Slf4j此本地转换使用LogBack日志记录向您的程序添加日志记录功能。对名为log的非绑定变量的每个方法调用都将映射到对logger.|355385|Groovy's+XML+Slurper：的轻松解析的调用。杀手级功能！|355386|355387|entityMap|0|LINK|mutability|MUTABLE|url|http://groovy.codehaus.org/gapi/groovy/transform/Immutable.html|1|http://groovy.codehaus.org/gapi/groovy/transform/CompileStatic.html|2|http://groovy.codehaus.org/gapi/groovy/transform/Canonical.html|3|http://groovy.codehaus.org/gapi/groovy/util/logging/Slf4j.html|4|http://groovy.codehaus.org/Reading%2BXML%2Busing%2BGroovy%2527s%2BXmlSlurper^0|4|G|0|0|0|A|0|A|0|0|0|E|0|E|1|0|0|A|0|A|2|0|0|0|0|0|6|0|6|3|0|0|K|4|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1G|8|@$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|J|3|K|5|I|7|1M|8|@$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|L|3|M|5|I|7|1S|8|@$9|1T|A|1U|B|C]]|D|@$9|1V|A|1W|1|1X]]|E|$]]|$1|N|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|20|8|@]|D|@]|E|$]]|$1|R|3|S|5|I|7|21|8|@$9|22|A|23|B|C]]|D|@$9|24|A|25|1|26]]|E|$]]|$1|T|3|U|5|I|7|27|8|@]|D|@$9|28|A|29|1|2A]]|E|$]]|$1|V|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]|16|$5|Z|10|11|E|$12|17]]|18|$5|Z|10|11|E|$12|19]]|1A|$5|Z|10|11|E|$12|1B]]]]

The features provided by the transformations inside the GDK's <code>groovy.transform</code> package, such as:

<ul>
<li><a href="http://groovy.codehaus.org/gapi/groovy/transform/Immutable.html"><code>@Immutable</code></a>: The @Immutable annotation instructs the compiler to execute an AST transformation which adds the necessary getters, constructors, equals, hashCode and other helper methods that are typically written when creating immutable classes with the defined properties.</li>
<li><a href="http://groovy.codehaus.org/gapi/groovy/transform/CompileStatic.html"><code>@CompileStatic</code></a>: This will let the Groovy compiler use compile time checks in the style of Java then perform static compilation, thus bypassing the Groovy meta object protocol.</li>
<li><a href="http://groovy.codehaus.org/gapi/groovy/transform/Canonical.html"><code>@Canonical</code></a>: The @Canonical annotation instructs the compiler to execute an AST transformation which adds positional constructors, equals, hashCode and a pretty print toString to your class.</li>
</ul>

Others:

<ul>
<li><a href="http://groovy.codehaus.org/gapi/groovy/util/logging/Slf4j.html"><code>@Slf4j</code></a> This local transform adds a logging ability to your program using LogBack logging. Every method call on a unbound variable named log will be mapped to a call to the logger.</li>
<li><a href="http://groovy.codehaus.org/Reading+XML+using+Groovy%27s+XmlSlurper">Groovy's XML Slurper</a>: easy parsing of XML. Killer feature!</li>
</ul>

blocks|key|356712|text|基于闭包的接口实现|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|356713|如果您有一个类型化的引用，如：|356714|MyInterface+foo|code-block|syntax|javascript|356715|您可以使用以下方法实现整个接口：|356716|foo+=+{Object[]+args+->+println+"This+closure+will+be+called+by+ALL+methods"}+as+MyInterface|356717|或者，如果您想单独实现每个方法，您可以使用：|356718|foo+=+[bar:+{->+println+"bar+invoked"},+
++++baz:+{param1+->+println+"baz+invoked+with+param+$param1"}]+as+MyInterface|356719|entityMap^0|2|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|V|$]]

Closure-Based Interface Implementation

If you have a typed reference such as:

<pre><code>MyInterface foo
</code></pre>

You can implement the entire interface using:

<pre><code>foo = {Object[] args -&gt; println "This closure will be called by ALL methods"} as MyInterface
</code></pre>

Alternatively, if you want to implement each method separately, you can use:

<pre><code>foo = [bar: {-&gt; println "bar invoked"}, 
 baz: {param1 -&gt; println "baz invoked with param $param1"}] as MyInterface
</code></pre>

blocks|key|3142483|text|您可以使用toSpreadMap()将列表转换为映射，当列表中的顺序足以确定键和与其关联的值时，此方法非常方便。请参见下面的示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142484|def+list+=+['key',+'value',+'foo',+'bar']+as+Object[]
def+map+=+list.toSpreadMap()

assert+2+==+map.size()
assert+'value'+==+map.key
assert+'bar'+==+map['foo']|code-block|syntax|javascript|3142485|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can convert a list to a map by using toSpreadMap(), convenient at times when the order in the list is enough to determine the keys and the values associated with them. See example below.

<pre><code>def list = ['key', 'value', 'foo', 'bar'] as Object[]
def map = list.toSpreadMap()

assert 2 == map.size()
assert 'value' == map.key
assert 'bar' == map['foo']
</code></pre>

blocks|key|360202|text|从列表中删除null值|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|360203|def+list+=+[obj1,+obj2,+null,+obj4,+null,+obj6]
list+-=+null
assert+list+==+[obj1,+obj2,+obj4,+obj6]|code-block|syntax|javascript|360204|entityMap^0|6|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Remove <code>null</code> values from list

<pre><code>def list = [obj1, obj2, null, obj4, null, obj6]
list -= null
assert list == [obj1, obj2, obj4, obj6]
</code></pre>

blocks|key|3355475|text|@Delegate|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3355476|class+Foo+{
++++def+footest()+{+return+"footest"}+++
}

class+Bar+{
++++@Delegate+Foo+foo+=+new+Foo()+++++
}

def+bar+=+new+Bar()

assert+"footest"+==+bar.footest()|code-block|syntax|javascript|3355477|entityMap|0|LINK|mutability|MUTABLE|url|http://webcache.googleusercontent.com/search?q=cache:groovy.codehaus.org/Delegate%252Btransformation^0|0|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="http://webcache.googleusercontent.com/search?q=cache:groovy.codehaus.org/Delegate%2Btransformation" rel="nofollow">@Delegate</a>

<pre><code>class Foo {
 def footest() { return "footest"} 
}

class Bar {
 @Delegate Foo foo = new Foo() 
}

def bar = new Bar()

assert "footest" == bar.footest()
</code></pre>

blocks|key|3355498|text|我知道我有点晚了，但我认为这里缺少一些很好的功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3355499|集合加/减运算符|offset|length|style|BOLD|3355500|def+l+=+[1,+2,+3]+%2B+[4,+5,+6]+-+[2,+5]+-+3+%2B+(7..9)
assert+l+==+[1,+4,+6,+7,+8,+9]

def+m+=+[a:+1,+b:+2]+%2B+[c:+3]+-+[a:+1]
assert+m+==+[b:+2,+c:+3]|code-block|syntax|javascript|3355501|Switch语句|3355502|switch+(42)+{
++case+0:+..+break
++case+1..9:+..+break
++case+Float:+..+break
++case+{+it+%25+4+==+0+}:+..+break
++case+~/\d%2B/:+..+break
}|3355503|范围和索引|3355504|assert+(1..10).step(2)+==+[1,+3,+5,+7,+9]
assert+(1..10)[1,+4..8]+==+[2,+5,+6,+7,+8,+9]
assert+('a'..'g')[-4..-2]+==+['d',+'e',+'f']|3355505|Unicode变量名|3355506|def+α+=+123
def+β+=+456
def+Ω+=+α+*+β
assert+Ω+==+56088|3355507|entityMap^0|0|0|8|0|0|0|8|0|0|0|5|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|Y|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|Z|$]]

I know I'am a bit late but I think there are some nice features missing here:

Collection plus/minus operators

<pre><code>def l = [1, 2, 3] + [4, 5, 6] - [2, 5] - 3 + (7..9)
assert l == [1, 4, 6, 7, 8, 9]

def m = [a: 1, b: 2] + [c: 3] - [a: 1]
assert m == [b: 2, c: 3]
</code></pre>

Switch statement

<pre><code>switch (42) {
 case 0: .. break
 case 1..9: .. break
 case Float: .. break
 case { it % 4 == 0 }: .. break
 case ~/\d+/: .. break
}
</code></pre>

Ranges and indexing

<pre><code>assert (1..10).step(2) == [1, 3, 5, 7, 9]
assert (1..10)[1, 4..8] == [2, 5, 6, 7, 8, 9]
assert ('a'..'g')[-4..-2] == ['d', 'e', 'f']
</code></pre>

Unicode variable names

<pre><code>def α = 123
def β = 456
def Ω = α * β
assert Ω == 56088
</code></pre>

blocks|key|360252|text|文字中的下划线|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|360253|当编写长的文字数字时，很难弄清楚一些数字是如何组合在一起的，例如数千个单词的分组，等等。通过允许您在数字文本中放置下划线，更容易发现这些组：|360254|long+creditCardNumber+=+1234_5678_9012_3456L
long+socialSecurityNumbers+=+999_99_9999L
double+monetaryAmount+=+12_345_132.12
long+hexBytes+=+0xFF_EC_DE_5E
long+hexWords+=+0xFFEC_DE5E
long+maxLong+=+0x7fff_ffff_ffff_ffffL
long+alsoMaxLong+=+9_223_372_036_854_775_807L
long+bytes+=+0b11010010_01101001_10010100_10010010|code-block|syntax|javascript|360255|entityMap^0|4|3|0|0|1Y|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Underscore in literals

When writing long literal numbers, it’s harder on the eye to figure out how some numbers are grouped together, for example with groups of thousands, of words, etc. By allowing you to place underscore in number literals, it’s easier to spot those groups:

<pre><code>long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
double monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010
</code></pre>

blocks|key|3142049|text|带隐式参数的参数重新排序是另一个很好的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142050|这段代码：|3142051|def+foo(Map+m=[:],+String+msg,+int+val,+Closure+c={})+{
++[...]
}|code-block|syntax|javascript|3142052|创建所有这些不同的方法：|3142053|foo("msg",+2,+x:1,+y:2)
foo(x:1,+y:2,+"blah",+2)
foo("blah",+x:1,+2,+y:2)+{+[...]+}
foo("blah",+2)+{+[...]+}|3142054|还有更多。把命名参数和序号参数放在错误的顺序/位置是不可能搞砸的。|3142055|当然，在"foo“的定义中，可以将"String”和"int“从"String+msg”和"int+val“中去掉--为了清楚起见，我把它们留在了其中。|3142056|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Argument reordering with implicit arguments is another nice one.

This code:

<pre><code>def foo(Map m=[:], String msg, int val, Closure c={}) {
 [...]
}
</code></pre>

Creates all these different methods:

<pre><code>foo("msg", 2, x:1, y:2)
foo(x:1, y:2, "blah", 2)
foo("blah", x:1, 2, y:2) { [...] }
foo("blah", 2) { [...] }
</code></pre>

And more. It's impossible to screw up by putting named and ordinal arguments in the wrong order/position.

Of course, in the definition of "foo", you can leave off "String" and "int" from "String msg" and "int val" -- I left them in just for clarity.

blocks|key|357431|text|我认为它是闭包作为参数和参数默认值的组合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357432|public+void+buyItems(Collection+list,+Closure+except={it+>+0}){
++list.findAll(){except(it)}.each(){print+it}
}
buyItems([1,2,3]){it+>+2}
buyItems([0,1,2])|code-block|syntax|javascript|357433|印刷品："312“|357434|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think it's a combination of closures as parameter and parameter-default-values:

<pre><code>public void buyItems(Collection list, Closure except={it &gt; 0}){
 list.findAll(){except(it)}.each(){print it}
}
buyItems([1,2,3]){it &gt; 2}
buyItems([0,1,2])
</code></pre>

prints: "312"

blocks|key|356765|text|在方法参数中使用扩展运算符的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356766|在将代码转换为数据时，这是一个很大的帮助：|offset|length|style|BOLD|356767|def+exec(operand1,operand2,Closure+op)+{
++++op.call(operand1,operand2)
}

def+addition+=+{a,b->a%2Bb}
def+multiplication+=+{a,b->a*b}

def+instructions+=+[
+++++[1,2,addition],
+++++[2,2,multiplication]
]

instructions.each{instr->
++++println+exec(*instr)
}|code-block|syntax|javascript|356768|下面的用法也很有用：|356769|String+locale="en_GB"

//this+invokes+new+Locale('en','GB')
def+enGB=new+Locale(*locale.split('_'))|356770|entityMap^0|0|0|L|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Using the spread operator in method parameters

This is a great help when converting code to data:

<pre><code>def exec(operand1,operand2,Closure op) {
 op.call(operand1,operand2)
}

def addition = {a,b-&gt;a+b}
def multiplication = {a,b-&gt;a*b}

def instructions = [
 [1,2,addition],
 [2,2,multiplication]
]

instructions.each{instr-&gt;
 println exec(*instr)
}
</code></pre>

Also helpful is this usage:

<pre><code>String locale="en_GB"

//this invokes new Locale('en','GB')
def enGB=new Locale(*locale.split('_'))
</code></pre>

blocks|key|360265|text|Memoization|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|360266|Memoization是一种优化技术，它存储代价高昂的函数调用的结果，并在每次使用相同的参数再次调用函数时返回缓存的结果。|360267|有一个无限的版本，它将缓存它将看到的每一对(输入参数，返回值)；还有一个有限的版本，它将使用LRU缓存缓存最后看到的N个输入参数及其结果。|360268|方法的记忆：|360269|import+groovy.transform.Memoized

@Memoized
Number+factorial(Number+n)+{
++++n+==+0+?+1+:+factorial(n+-+1)
}

@Memoized(maxCacheSize=1000)
Map+fooDetails(Foo+foo)+{
++++//+call+expensive+service+here
}|code-block|syntax|javascript|360270|闭包的记忆：|360271|def+factorial+=+{Number+n+->
++++n+==+0+?+1+:+factorial(n+-+1)
}.memoize()

fooDetails+=+{Foo+foo+->
++++//+call+expensive+service+here
}.memoizeAtMost(1000)|360272|The+Wikipedia+page有大量关于记忆在计算机科学中的使用的信息。我只会指出一个简单的实际用法。|360273|将常量的初始化推迟到最后可能的时刻|360274|有时，您有一个在类定义或创建时无法初始化的常量值。例如，常量表达式可能使用另一个常量或来自不同类的方法，这些常量或方法将在您的类初始化后由其他东西(Spring等)插入。|360275|在这种情况下，您可以将常量转换为getter并使用@Memoized对其进行修饰。它只会在第一次被访问时被计算一次，然后值被缓存和重用：|CODE|360276|import+groovy.transform.Memoized

@Memoized
def+getMY_CONSTANT()+{
++++//+compute+the+constant+value+using+any+external+services+needed
}|360277|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Memoization^0|0|B|0|0|0|0|0|0|0|0|I|0|0|0|H|0|0|P|9|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1G|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1H|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1I|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1J|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1K|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1L|8|@]|D|@]|E|$O|P]]|$1|U|3|V|5|6|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|W|3|X|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1T|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|1U|8|@$9|1V|A|1W|B|12]]|D|@]|E|$]]|$1|13|3|14|5|N|7|1X|8|@]|D|@]|E|$O|P]]|$1|15|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]]|16|$17|$5|18|19|1A|E|$1B|1C]]]]

Memoization

Memoization is an optimization technique that consists in storing the results of expensive function calls and returning the cached result whenever the function is called again with the same arguments.

There is an unlimited version, that will cache ever pair of (input arguments, return value) it will ever see; and a limited version, that will cache the last N input arguments seen and their results, using a LRU cache.

Memoization of methods:

<pre><code>import groovy.transform.Memoized

@Memoized
Number factorial(Number n) {
 n == 0 ? 1 : factorial(n - 1)
}

@Memoized(maxCacheSize=1000)
Map fooDetails(Foo foo) {
 // call expensive service here
}
</code></pre>

Memoization of closures:

<pre><code>def factorial = {Number n -&gt;
 n == 0 ? 1 : factorial(n - 1)
}.memoize()

fooDetails = {Foo foo -&gt;
 // call expensive service here
}.memoizeAtMost(1000)
</code></pre>

<a href="http://en.wikipedia.org/wiki/Memoization" rel="nofollow">The Wikipedia page</a> has extensive information on the uses of Memoization in Computer Science. I will just point out one simple practical use.

Deferring the initialization of a constant to the last possible moment

Sometimes you have a constant value that cannot be initialized at class definition or creation time. For example, the constant expression may make use of another constant or a method from a different class, which will be plugged in by something else (Spring or such) after the initialization of your class. 

In this case, you can convert your constant into a getter and decorate it with <code>@Memoized</code>. It will only be computed once, the first time it's accessed, and then the value cached and reused:

<pre><code>import groovy.transform.Memoized

@Memoized
def getMY_CONSTANT() {
 // compute the constant value using any external services needed
}
</code></pre>

blocks|key|3355403|text|Groovy可以像Javascript一样工作。您可以通过闭包获得私有变量和函数。您还可以使用闭包对函数进行curry操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3355404|class+FunctionTests+{

def+privateAccessWithClosure+=+{

++++def+privVar+=+'foo'

++++def+privateFunc+=+{+x+->+println+"${privVar}+${x}"}

++++return+{x+->+privateFunc(x)+}+
}


def+addTogether+=+{+x,+y+->
++++return+x+%2B+y
}

def+curryAdd+=+{+x+->
++++return+{+y->+addTogether(x,y)}
}

public+static+void+main(String[]+args)+{
++++def+test+=+new+FunctionTests()

++++test.privateAccessWithClosure()('bar')

++++def+curried+=+test.curryAdd(5)

++++println+curried(5)
}
}|code-block|syntax|javascript|3355405|输出：|3355406|foo+bar+10|3355407|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Groovy can work a lot like Javascript. You can have private vars and functions via closure.
You can also curry functions with closures.

<pre><code>class FunctionTests {

def privateAccessWithClosure = {

 def privVar = 'foo'

 def privateFunc = { x -&gt; println "${privVar} ${x}"}

 return {x -&gt; privateFunc(x) } 
}


def addTogether = { x, y -&gt;
 return x + y
}

def curryAdd = { x -&gt;
 return { y-&gt; addTogether(x,y)}
}

public static void main(String[] args) {
 def test = new FunctionTests()

 test.privateAccessWithClosure()('bar')

 def curried = test.curryAdd(5)

 println curried(5)
}
}
</code></pre>

output:

foo bar
10

blocks|key|357471|text|动态方法调用|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|357472|可以使用带有其名称的字符串调用方法|357473|class+Dynamic+{
++++def+one()+{+println+"method+one()"+}
++++def+two()+{+println+"method+two()"+}
}

def+callMethod(+obj,+methodName+)+{
++++obj."$methodName"()
}

def+dyn+=+new+Dynamic()

callMethod(+dyn,+"one"+)+++++++++++++++//prints+'method+one()'
callMethod(+dyn,+"two"+)+++++++++++++++//prints+'method+two()'
dyn."one"()++++++++++++++++++++++++++++//prints+'method+one()'|code-block|syntax|javascript|357474|entityMap^0|0|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Dynamic method invocation

You can invoke a method using a string with its name

<pre><code>class Dynamic {
 def one() { println "method one()" }
 def two() { println "method two()" }
}

def callMethod( obj, methodName ) {
 obj."$methodName"()
}

def dyn = new Dynamic()

callMethod( dyn, "one" ) //prints 'method one()'
callMethod( dyn, "two" ) //prints 'method two()'
dyn."one"() //prints 'method one()'
</code></pre>

blocks|key|357490|text|如何在groovy中用几行代码构建一个JSON树？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357491|1)使用自引用withDefault闭包定义树|offset|length|style|CODE|357492|def+tree+//+declare++first+before+using+a+self+reference
tree+=+{+->++[:].withDefault{+tree()+}+}|code-block|syntax|javascript|357493|2)创建自己的JSON树|357494|frameworks+=+tree()
frameworks.grails.language.name+=+'groovy'
frameworks.node.language.name+=+'js'

def+result+=++new+groovy.json.JsonBuilder(frameworks)|357495|这给出了：{"grails":{"language":{"name":"groovy"}},"node":{"language":{"name":"js"}}}|357496|entityMap^0|0|7|B|0|0|0|0|5|23|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

How to build a JSON tree in a couple of lines in groovy ?

1) define your tree with self-referential <code>withDefault</code> closure

<pre><code>def tree // declare first before using a self reference
tree = { -&gt; [:].withDefault{ tree() } }
</code></pre>

2) Create your own JSON tree

<pre><code>frameworks = tree()
frameworks.grails.language.name = 'groovy'
frameworks.node.language.name = 'js'

def result = new groovy.json.JsonBuilder(frameworks)
</code></pre>

Which gives: <code>{"grails":{"language":{"name":"groovy"}},"node":{"language":{"name":"js"}}}</code>

blocks|key|360257|text|安全导航运算符|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|360258|“安全导航”运算符用于避免NullPointerException。通常，当您拥有对某个对象的引用时，在访问该对象的方法或属性之前，可能需要验证它是否不为空。为了避免这种情况，安全导航操作符将简单地返回null，而不是抛出异常，如下所示：|360259|def+person+=+Person.find+{+it.id+==+123+}++++++++//+find+will+return+a+null+instance++++
def+name+=+person?.name++++++++++++++++++++++++++//+use+of+the+null-safe+operator+prevents+from+a+NullPointerException,+result+is+null|code-block|syntax|javascript|360260|entityMap^0|0|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Safe navigation operator

The Safe Navigation operator is used to avoid a NullPointerException. Typically when you have a reference to an object you might need to verify that it is not null before accessing methods or properties of the object. To avoid this, the safe navigation operator will simply return null instead of throwing an exception, like so:

<pre><code>def person = Person.find { it.id == 123 } // find will return a null instance 
def name = person?.name // use of the null-safe operator prevents from a NullPointerException, result is null
</code></pre>

blocks|key|360301|text|多变量减速|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360302|1)单行多变量声明|360303|def+(a,b,c)+=+[1,2,3]|code-block|syntax|javascript|360304|2)使用不同的类型声明。|360305|def+(String+a,+int+b)+=+['Groovy',+1]|360306|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>Multiple variables deceleration</h2>

1)Multiple variables declarations in single line

<pre><code>def (a,b,c) = [1,2,3]
</code></pre>

2)Using different type declarations.

<pre><code>def (String a, int b) = ['Groovy', 1]
</code></pre>

blocks|key|3142849|text|猫王运算符|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3142850|“猫王运算符”是三元运算符的缩写。这样做很方便的一个例子是，如果表达式解析为false，则返回一个“合理的默认值”(就像Groovy+truth中那样)。一个简单的示例可能如下所示：|3142851|使用三元运算符时，必须重复要赋值的值|3142852|displayCity+=+user.city+?+user.city:+'UnKnown+City'|code-block|syntax|javascript|3142853|使用Elvis运算符时，如果值不为false，则使用经过测试的值|3142854|displayCity+=+user.city+?:+'UnKnown+City'|3142855|entityMap^0|0|5|0|0|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

<h2>Elvis operator</h2>

"Elvis operator" is a shortening of the ternary operator. One instance of where this is handy is for returning a 'sensible default' value if an expression resolves to false(as in Groovy truth). A simple example might look like this:

with the ternary operator, you have to repeat the value you want to assign 

<pre><code>displayCity = user.city ? user.city: 'UnKnown City'
</code></pre>

with the Elvis operator, the value, which is tested, is used if it is not false

<pre><code>displayCity = user.city ?: 'UnKnown City'
</code></pre>

blocks|key|3355739|text|强制算符|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3355740|强制操作符(as)是强制转换的变体。强制将对象从一种类型转换为另一种类型，而不兼容赋值。让我们举个例子：|3355741|整数x=+123|3355742|字符串s=(字符串)x|3355743|Integer不能赋值给字符串，因此它将在运行时生成一个ClassCastException+，这可以通过使用强制来解决：|3355744|整数x=+123+String+s=+x+as+String|offset|length|style|BOLD|3355745|Integer不能赋值给字符串，但使用as会将其强制为字符串|3355746|entityMap^0|0|0|0|0|0|J|B|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@$L|Z|M|10|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

<h2>Coercion operator</h2>

The coercion operator (as) is a variant of casting. Coercion converts object from one type to another without them being compatible for assignment. Let’s take an example:

Integer x = 123 
String s = (String) x 
Integer is not assignable to a String, so it will produce a ClassCastException at runtime
This can be fixed by using coercion instead:

Integer x = 123
String s = x as String 
Integer is not assignable to a String, but use of as will coerce it to a String

It seems like Groovy was forgotten in this thread so I'll just ask the same question for Groovy.

<ul>
<li>Try to limit answers to Groovy core</li>
<li>One feature per answer</li>
<li>Give an example and short description of the feature, not just a link to documentation</li>
<li>Label the feature using bold title as the first line</li>
</ul>

See also:

<ol>
<li><a href="https://stackoverflow.com/questions/101268/hidden-features-of-python">Hidden features of Python</a></li>
<li><a href="https://stackoverflow.com/questions/63998/hidden-features-of-ruby">Hidden features of Ruby</a></li>
<li><a href="https://stackoverflow.com/questions/161872/hidden-features-of-perl">Hidden features of Perl</a></li>
<li><a href="https://stackoverflow.com/questions/15496/hidden-features-of-java">Hidden features of Java</a></li>
</ol>

Hidden features of Groovy?

编译器

JSON

Java

在这个帖子中似乎忘记了Groovy，所以我将向Groovy提出同样的问题。One feature answer给出该功能的示例和简短描述，而不仅仅是使用粗体标题作为第一行的粗体链接另请参阅：

问Groovy的隐藏功能？
EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Groovy的隐藏功能？EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Groovy的隐藏功能？
EN