Groovy学习笔记

Scala适用于需要高性能的多线程环境，Groovy适用于DSL、测试、快速开发等

在脚本中解析脚本
evaluate(expression)
Eval.me(expression)
Eval.x(param1,expression)
Eval.xy(param1,param2,expression)
Eval.xyz(param1,param2,param3,expression)
有一个问题就是用Eval解析的表达式作用域的问题，如果要使用当前域下的函数，需要结合闭包和委托指向来实现

def c=evaluate("{->${expression}}")
c.delegate=this
c()

一个具体的Demo：

def power(x){x*x}
println power(2)
//evaluate("println power(2)") // 这样写会出错的
def expression = "println power(2)"
def closure1 = evaluate("return {->${expression}}")
closure1.delegate=this
closure1()
def test(String ex){
  def closure = evaluate("return {->${ex}}")
  closure.delegate = this
  closure()
}
test(expression)

java执行groovy脚本为了防止前面的表达式污染，可以在下一条表达式执行前对bindings进行清理

ScriptEngine engine = new ScriptEngineManager().getEngineByName("groovy");
final Bindings bds=engine.getBindings(ScriptContext.ENGINE_SCOPE);
bds.clear();  //在执行前将bings进行清理，可以防止前面的表达式污染
engine.eval(scripts);

实用代码

('a'..'z') // [a,b,..z]
0.upto(10){print it}
10.times{print it}
0.step(11,2){print it}
s="""
我是带格式的文本
两行
"""

Map

def map= [1:3,2:2,3:1] //[默认是LinkedHashMap
def sorted1 = map.sort{ it.value }  // 根据value对map进行排序
def sorted2 = map.sort{ a, b -> a.value <=> b.value } // 和it.value等价
def sorted3 = map.sort({a, b -> a.value <=> b.value } as  Comparator)
(1..20).collectEntries{[it, it]} // 生成一个[1:1,2:2,3:3...,20:20]这样的map
println map*.key // 等价于 map.keySet()
println map*.value // 等价于 map.values()

List

(1..26).collect({e->(char)(e+96)})   // a-z
('a'..'z')  //a-z
(1..26).collect({e->return (char)(e+64)})  // A-Z
('A'..'Z') //A-Z
('a'..'c')*.concat("1") //a1,b1,c1
('1'..'3').collect({e->"a"+e}) //a1,a2,a3