你可以使用onlyIf()方法将断言附加到任务中。只有当断言结果为true时，才会执行该任务的操作。你可以用闭包来实现断言。闭包会作为一个参数传给任务，如果任务应该执行，应该返回true，如果任务应该被跳过，则返回false。断言只会在任务执行之前才评估。 
You can use the onlyIf() method to attach a predicate to a task. The task's actions are only executed if the predicate evaluates to true. You implement the predicate as a closure. The closure is passed the task as a parameter, and should return true if the task should execute and false if the task should be skipped. The predicate is evaluated just before the task is due to be executed.

task hello << {
    println 'hello world'
}

hello.onlyIf { !project.hasProperty('skipHello') }

> gradle hello -PskipHello
:hello SKIPPED

BUILD SUCCESSFUL

Total time: 1 secs

如果跳过任务的规则不能用断言来表达，你可以使用StopExecutionException。如果一个操作抛出此异常，则此操作的接下来的执行以及该任务的任何后续操作都会跳过。构建会继续执行下一个任务。 
If the rules for skipping a task can't be expressed with predicate, you can use the StopExecutionException. If this exception is thrown by an action, the further execution of this action as well as the execution of any following action of this task is skipped. The build continues with executing the next task.

task compile << {
    println 'We are doing the compile.'
}

compile.doFirst {
    // Here you would put arbitrary conditions in real life. But we use this as an integration test, so we want defined behavior.
    if (true) { throw new StopExecutionException() }
}
task myTask(dependsOn: 'compile') << {
   println 'I am not affected'
}

> gradle -q myTask
I am not affected

如果你使用Gradle提供的任务，那么此功能将非常有用。它允许你向一个任务的内置操作添加执行条件。 ^[7] 
This feature is helpful if you work with tasks provided by Gradle. It allows you to add conditional execution of the built-in actions of such a task. ^[7]

每一项任务有一个默认值为true的enabled标记。将它设置为false，可以不让这个任务的任何操作执行。 
Every task has also an enabled flag which defaults to true. Setting it to false prevents the execution of any of the task's actions.

task disableMe << {
    println 'This should not be printed if the task is disabled.'
}
disableMe.enabled = false

> gradle disableMe
:disableMe SKIPPED

BUILD SUCCESSFUL

Total time: 1 secs

我们来看一个例子。在这里，我们的任务从一个 XML 源文件生成了多个输出文件。 
Let's have a look at an example. Here our task generates several output files from a source XML file. Let's run it a couple of times.

task transform {
    ext.srcFile = file('mountains.xml')
    ext.destDir = new File(buildDir, 'generated')
    doLast {
        println "Transforming source file."
        destDir.mkdirs()
        def mountains = new XmlParser().parse(srcFile)
        mountains.mountain.each { mountain ->
            def name = mountain.name[0].text()
            def height = mountain.height[0].text()
            def destFile = new File(destDir, "${name}.txt")
            destFile.text = "$name -> ${height}\n"
        }
    }
}

> gradle transform
:transform
Transforming source file.

> gradle transform
:transform
Transforming source file.

请注意，Gradle第二次执行此任务的时候，即使没有任何变化也不会跳过该任务。我们的示例任务是使用一个动作闭包定义的。 Gradle不知道这个闭包做了什么，不能自动判断这个任务是否是最新的。要使用Gradle的最新检查，你需要声明任务的输入和输出。 
Notice that Gradle executes this task a second time, and does not skip the task even though nothing has changed. Our example task was defined using an action closure. Gradle has no idea what the closure does and cannot automatically figure out whether the task is up-to-date or not. To use Gradle's up-to-date checking, you need to declare the inputs and outputs of the task.

每一个任务都有一个inputs和outputs属性，用来声明这个任务的输入和输出。下面，我们修改了我们的示例，声明它将 XML 源文件作为输入，并产生到目标目录的输出。让我们运行几次。 
Each task has an inputs and outputs property, which you use to declare the inputs and outputs of the task. Below, we have changed our example to declare that it takes the source XML file as an input and produces output to a destination directory. Let's run it a couple of times.

task transform {
    ext.srcFile = file('mountains.xml')
    ext.destDir = new File(buildDir, 'generated')
    inputs.file srcFile
    outputs.dir destDir
    doLast {
        println "Transforming source file."
        destDir.mkdirs()
        def mountains = new XmlParser().parse(srcFile)
        mountains.mountain.each { mountain ->
            def name = mountain.name[0].text()
            def height = mountain.height[0].text()
            def destFile = new File(destDir, "${name}.txt")
            destFile.text = "$name -> ${height}\n"
        }
    }
}

> gradle transform
:transform
Transforming source file.

> gradle transform
:transform UP-TO-DATE

现在，Gradle 知道要检查哪些文件，以确定任务是否为最新的。
Now, Gradle knows which files to check to determine whether the task is up-to-date or not.

任务的 inputs 属性是 TaskInputs类型。任务的 outputs 属性是 TaskOutputs类型。 
The task's inputs property is of type TaskInputs. The task's outputs property is of type TaskOutputs.

一个任务如果没有定义输出，那么它将永远不会被当作是最新的。对于任务的输出不是文件或是更复杂的场景， TaskOutputs.upToDateWhen()方法允许你以编程方式计算任务的输出是否应该被视为最新的。 
A task with no defined outputs will never be considered up-to-date. For scenarios where the outputs of a task are not files, or for more complex scenarios, the TaskOutputs.upToDateWhen() method allows you to calculate programmatically if the tasks outputs should be considered up to date.

一个只定义了输出的任务，如果自上次构建以来它的输出没变，那么它会被视为最新的。 
A task with only outputs defined will be considered up-to-date if those outputs are unchanged since the previous build.

在第一次执行任务之前，Gradle会获取输入的快照。此快照包含一组输入文件和每个文件的内容的散列。然后Gradle执行任务。如果任务成功完成，则Gradle会对输出进行快照。此快照包含一组输出文件和每个文件的内容的散列。 Gradle会保存这两个快照，用于这个任务下一次的执行。 
Before a task is executed for the first time, Gradle takes a snapshot of the inputs. This snapshot contains the set of input files and a hash of the contents of each file. Gradle then executes the task. If the task completes successfully, Gradle takes a snapshot of the outputs. This snapshot contains the set of output files and a hash of the contents of each file. Gradle persists both snapshots for next time the task is executed.

在这之后每一次执行任务之前，Gradle将输入和输出进行新的快照。如果新快照与以前的快照相同，则Gradle会假定输出是最新的，并跳过任务。如果它们不一样，则Gradle会执行任务。Gradle会保存这两个快照，用于这个任务的下一次执行。 
Each time after that, before the task is executed, Gradle takes a new snapshot of the inputs and outputs. If the new snapshots are the same as the previous snapshots, Gradle assumes that the outputs are up to date and skips the task. If they are not the same, Gradle executes the task. Gradle persists both snapshots for next time the task is executed.

请注意，如果一个任务有指定的输出目录，在它上一次执行之后添加到该目录的所有文件都将被忽略，并且不会使这个任务过期。这样，那些不相关的任务之间就可以共用一个输出目录，而不会产生互相干扰。如果因为一些原因你不想要这样的行为，请考虑使用TaskOutputs.upToDateWhen()。 
Note that if a task has an output directory specified, any files added to that directory since the last time it was executed are ignored and will NOT cause the task to be out of date. This is so unrelated tasks may share an output directory without interfering with each other. If this is not the behaviour you want for some reason, consider using TaskOutputs.upToDateWhen()