Gradle tip #2: understanding syntax

In the Part 1 we talked about tasks and different stages of the build lifecycle. But after I published it I realized that before we jump into Gradle specifics it is very important to understand what we are dealing with - understand its syntax and stop being scared when we see complex build.gradlescripts. With this article I will try to fill this missing gap.

在第一篇博客中，我讲解了关于tasks和构建过程中task的不同阶段。在写完这篇之后，我意识到我应该更详尽的讲述一下Gradle。弄懂语法很重要，免得我们碰到复杂的构建脚本的时候直接晕菜。这篇文章我就会讲解一些语法上的东西。

Syntax

Gradle build scripts are written in Groovy, so before we start analyzing them, I want to touch (briefly) some key Groovy concepts. Groovy syntax is somewhat similar to Java, so hopefully you won't have much problems understanding it.

Gradle脚本是使用Groovy语言来写的。Groovy的语法有点像Java，希望你能接受它。

If you feel comfortable with Groovy - feel free to skip this section.

如果你对Groovy已经很熟悉了，可以跳过这部分了。

There is one important Groovy aspect you need to understand in order to understand Gradle scripts - Closure.

Groovy中有一个很重要的概念你必要要弄懂–Closure（闭包）

Closures

Closure is a key concept which we need to grasp to better understand Gradle. Closure is a standalone block of code which can take arguments, return values and be assigned to a variable. It is some sort of a mix between Callable interface, Future, function pointer, you name it..

Closure是我们弄懂Gradle的关键。Closure是一段单独的代码块，它可以接收参数，返回值，也可以被赋值给变量。和Java中的Callable接口，Future类似，也像函数指针，你自己怎么方便理解都好。

Essentially this is a block of code which is executed when you call it, not when you create it. Let's see a simple Closure example:

关键是这块代码会在你调用的时候执行，而不是在创建的时候。看一个Closure的例子：

def myClosure = { println 'Hello world!' }

//execute our closure
myClosure()

#output: Hello world!

Or here is a closure which accepts a parameter:

下面是一个接收参数的Closure：

def myClosure = {String str -> println str }

//execute our closure
myClosure('Hello world!')

#output: Hello world!

Or if closure accepts only 1 parameter, it can be referenced as it:

如果Closure只接收一个参数，可以使用it来引用这个参数：

def myClosure = {println it }

//execute our closure
myClosure('Hello world!')

#output: Hello world!

Or if closure accepts multiple input parameters:

接收多个参数的Closure：

def myClosure = {String str, int num -> println "$str : $num" }

//execute our closure
myClosure('my string', 21)

#output: my string : 21

By the way, argument types are optional, so example above can be simplified to:

另外，参数的类型是可选的，上面的例子可以简写成这样：

def myClosure = {str, num -> println "$str : $num" }

//execute our closure
myClosure('my string', 21)

#output: my string : 21

One cool feature is that closure can reference variables from the current context (read class). By default, current context - is the class within this closure was created:

很酷的是Closure中可以使用当前上下文中的变量。默认情况下，当前的上下文就是closure被创建时所在的类：

def myVar = 'Hello World!'
def myClosure = {println myVar}
myClosure()

#output: Hello world!

Another cool feature is that current context for the closure can be changed by callingClosure#setDelegate(). This feature will become very important later:

另外一个很酷的点是closure的上下文是可以改变的，通过Closure#setDelegate()。这个特性非常有用：

def myClosure = {println myVar} //I'm referencing myVar from MyClass class
MyClass m = new MyClass()
myClosure.setDelegate(m)
myClosure()

class MyClass {
    def myVar = 'Hello from MyClass!'
}

#output: Hello from MyClass!

As you can see, at the moment when we created closure, myVar variable doesn't exist. And this is perfectly fine - it should be present in the closure context at the point when we execute this closure.

正如你锁看见的，在创建closure的时候，myVar并不存在。这并没有什么问题，因为当我们执行closure的时候，在closure的上下文中，myVar是存在的。

In this case I modified current context for the closure right before I executed it, so myVar is available.

这个例子中。因为我在执行closure之前改变了它的上下文为m，因此myVar是存在的。

Pass closure as an argument

The real benefit of having closures - is an ability to pass closure to different methods which helps us to decouple execution logic.

closure的好处就是可以传递给不同的方法，这样可以帮助我们解耦执行逻辑。

In previous section we already used this feature when passed closure to another class instance. Now we will go through different ways to call method which accepts closure:

前面的例子中我已经展示了如何把closure传递给一个类的实例。下面我们将看一下各种接收closure作为参数的方法：

1. method accepts 1 parameter - closure (只接收一个参数，且参数是closure的方法)

   myMethod(myClosure)

2. if method accepts only 1 parameter - parentheses can be omitted (如果方法只接收一个参数，括号可以省略)

   myMethod myClosure

3. I can create in-line closure (可以使用内联的closure)

   myMethod {println 'Hello World'}

4. method accepts 2 parameters (接收两个参数的方法)

   myMethod(arg1, myClosure)

5. or the same as '4', but closure is in-line (和4类似，单数closure是内联的)

   myMethod(arg1, { println 'Hello World' })

6. if last parameter is closure - it can be moved out of parentheses (如果最后一个参数是closure，它可以从小括号从拿出来)

   myMethod(arg1) { println 'Hello World' }

At this point I really have to point your attention to example #3 and #6. Doesn't it remind you something from gradle scripts?