Groovy学习笔记之块、闭包与函数

 一、代码块
在代码块中用def关键字定义的变量不能在外部访问，如:

 try{
  def msg="Hello,world!";
 }
 //pringln msg;
 
 如果运行最后一行"println msg;"，则会报错。
 
但是，在代码块中没有用def关键字声明的变量，就可以在外部访问，如:

try{
 msg="Hello,world!";
}
println msg;
 
已经使用def定义的变量，不能再次用def定义: 
def a=10;
//def a=20;

代码块是可以嵌套的:

try{
 try{
  try{
   println "Hello,world!";
  }
 }
}

二、闭包
闭包是可以引用外部上下文环境的一系列语句。可以将闭包赋予一个变量，并在稍后执行。

 每个闭包都有一个返回值，默认的返回值就是该闭包中最后一行语句的结果
 
闭包可以访问外部的变量
def x=1;

def b={
 x*2;//闭包可以访问外部的变量 
}

将闭包赋予一个变量将记住该闭包创建时的上下文环境，即使运行时已经超出了原来的作用域:
def c;

try{
 def m=10;
 c={m};
} 

println c();
在此处调用c()，即使已经超出了block的作用域，但仍能输出m的值

将一个闭包放入另一个闭包，可以创建它的两个实例:
 
c={e={"Hello,World";};e;}
v1=c();
v2=c();
println v1==v2//在此得出false，说明c()返回了不同的实例

可以在定义闭包时声明一些参数，之后在调用闭包时将这些参数值传入闭包:

c={n-> println "Parameter="+n;}

c(10);

可以利用参数将信息从包内导出，也就是所谓的“输出参数”

c={o,p-> o<<p};
x=[];
c(x,1);
c(x,2);
c(x,3);
println x;

在闭包中，总是可以用到一个叫做it的变量，如果没有显式的定义参数，则可以用it来引用

c={"Parameter=${it}"};
println c(10);

如果没有传入任何参数，it仍然存在，但是为null

闭包的参数不能使用作用域中已存在变量的名字，除了隐式变量it：
def it=10;

c={it*it};

println c(5);//在此，隐式变量it仍然引用参数5，而非外部定义的10

参数在调用闭包时可以被命名。这些被命名的参数将被组装进一个Map，并指定给闭包的第一个参数：
def x={a,b,c->a.m+a.n+a.o-b+c;};

println x(m:10,5,n:15,6,o:20);

在调用闭包x的时候,参数m:10,n:15,o:20被组装进Map赋予形参a,5、6按顺序分别赋予形参b和c，结果是46。

我们可以在闭包内部和外部查询参数的个数:

def c={a,b,c->getMaximumNumberOfParameters();}

println c(1,2,3);

println c.getMaximumNumberOfParameters();

调用闭包的时候，可以对最后的一个或几个参数应用默认值:

def c={a,b=2,c=3->a+b+c;};

println c(1);

结果输出6

一个闭包可以在最后一个参数前添加Object[]前缀来创建可变长度的参数:

def c={a,Object[] b->a+b[0]+b[1];}

println c(1,2,3);

我们可以使用一个list参数调用闭包。如果闭包没有定义一个list类型的参数，则此参数将作为分解的参数传入闭包:

def c={a,b,c->a+b+c};

println c([1,2,3]);

闭包可以通过将第一个或前几个参数固化为常量，使用curry方法进行拷贝:

def c={a,b,c->a+b+c};

def d=c.curry(1);//拷贝闭包c,并将第一个参数a固化为常量1

println d(2,3);//调用闭包d，只需要给出剩余的参数。实际使用的参数仍然是1,2,3

在闭包中，可以结合使用curry和不定长度参数:

def c={a,Object[] b->b.each({m->a=a+m;});a;};

def d=c.curry(1);

def e=d.curry(2,3);//实际参数为1,[2,3]

def f=e.curry(4);//实际参数为1,[2,3,4]

println f(5);//实际参数为1,[2,3,4,5]

闭包可以递归调用

三、函数

首先，必须使用def关键字定义函数,函数也不能嵌套使用；

其次，函数不能访问在外部通过def定义的变量:

def c=10;

def f(){
 println c;//编译通过
}

//f();//运行时报错

还可以使用特殊的语法标记&将函数赋予新的命名：

def f(){
 println "Hello,world!";
}

def s=this.&f;

s();

函数可以后参数，包括输入参数和输出参数；

如果两个函数的拥有不同个数的未指定类型的参数，则可以使用相同的名称

def f(a){
 println a*a;
}

def f(a,b){
 println a*b;
}

f(10);

f(5,10)

函数可以有返回值:
1.如果有显示地使用return关键字，则返回return指定的返回值，其后面的语句不再执行;
2.如果没有显式地使用return关键字，则返回函数最后一行语句的运行结果;
3.如果使用void关键字代替def关键字定义函数，则函数的返回值将为null。

如果一个函数与一个闭包拥有相同的名称和参数，则调用的时候将执行函数，而不是闭包:

def f(a){
 return a*10;
}

def f={a->a*20};

println f(5);//输出50而不是100

函数可以接受闭包作为参数:

def f(a,Closure c){
 c(a);
}

f(10){println "Parameter a = "+it;}

与闭包相同，函数可以为参数指定默认值:

def f(a,b=10){
 return a+b;
}

println f(5);//输出15

函数也会将命名的参数包装进一个Map，并赋予第一个参数:

def f(a,b){
 return b+a.x+a.y;
}

println f(x:2,1,y:3);//输出6

函数与闭包的相同之处还有，函数同样支持不定长度的参数、分解list作为参数，以及递归调用。