Groovy基础语法点

string类型 “” 和‘’ 的区别

在groovy里，表示string类型，可以使用双引号也可以使用单引号，和java有些区别。
单引号和双引号在groovy里也是有区别的。单引号里表示的是常量字符串，双引号有计算能力，区别如示例：

task printStringVal{
    def name = "哈利路亚"
    
    println "双引号里的变量${name}"
    println '单引号里的变量${name}'
}

输出结果如下：

> Task :printStringVal
双引号里的变量哈利路亚
单引号里的变量${name}

输出list、map

直接看例子

task printList {
    def numList =[1,2,3,4,5]
    
    doLast{
        println numList.getClass().name // 打印对应的类型
        println numList[0]  // 打印第一个元素
        println numList[-1] // 打印最后一个元素
        println numList[4]  // 打印第五个元素
        println numList[1..3] // 打印第二个到第四个元素
        
        numList.each{
            print it + "\t"
        }
    }
}

结果：

> Task :printList
java.util.ArrayList
1
5
5
[2, 3, 4]
1       2       3       4       5

list对应了ArrayList类
再来看map：

task printMap {
    def map1 = ['width':1080, 'height':1920]
    
    doLast {
        println map1.getClass().name
        println "key为width的元素，value为：" + map1['width']
        map1.each{
            println "key:${it.key}, value:${it.value}"
        }
    }
}

map对应了LinkedHashMap
运行结果：

> Configure project :
hello gradle

> Task :printMap
java.util.LinkedHashMap
key为width的元素，value为：1080
key:width, value:1080
key:height, value:1920

方法调用

// 定义一个方法
def method1(int a, int b){
    println a + b
}

// task中调用这个方法，可以不使用括号()，如
method1(1,2)、
method1 1,2
以上两中方式均可，*不过貌似作为参数时，第二种方式不可以

闭包

实现一个类似闭包的功能

task helloClosure{
    doLast{
        customEach{
            println it
        }
    }
}

def customEach(closure){
    // 循环调用10次这个闭包代码块
    for(int i in 1..10){
        closure(i)
    }
}

以上代码类似list中的each闭包功能，方法customEach在task的doLast中被执行，而customEach后的代码块{...}就是customEach的参数closure，这个参数（即代码块{...}）在customEach里被放在for循环里迭代10次，这就类似list的each功能的实现。

task helloClosure2{
    doLast{
        eachMap{ k,v ->
            println "${k} : ${v}" 
        }
    }
}

def eachMap(closure){
    def map = ["name":"jason", "age":16]
    map.each{
        closure(it.key, it.value)
    }
}

结果：

task helloClosure2{
    doLast{
        eachMap{ k,v ->
            println "${k} : ${v}" 
        }
    }
}

def eachMap(closure){
    def map = ["name":"jason", "age":16]
    map.each{
        closure(it.key, it.value)
    }
}

闭包委托

Groovy闭包的强大之处在于它支持闭包方法的委托，Groovy中的闭包有thisObject、owner、delegate三个属性。当你在闭包内调用方法时，由它们来决定使用哪个对象来处理。默认情况下，owner和delegate是相等的，当时delegate是可以被修改的，这个功能非常地强大。Gradle中的闭包有很多功能是通过修改delegate实现的。

下面看一段代码：

task helloDelegate{
    new Delegate().test{
        println "thisObject: ${thisObject.getClass()}"
        println "ower:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
        method1()
        it.method1()
    }
}

def method1(){
    println "Context this:${this.getClass()} in root"
    println "method1 in root"
}

class Delegate{
    def method1(){
        println "Delegate this:${this.getClass()} in Delegate"
        println "method1 in Delegate"
    }
    
    def test(Closure<Delegate> closure){
        closure(this)
    }
}

运行结果：

thisObject: class build_euvgp8ua408ivvs8hgkf7dmfi
ower:class build_euvgp8ua408ivvs8hgkf7dmfi$_run_closure7
delegate:class build_euvgp8ua408ivvs8hgkf7dmfi$_run_closure7
Context this:class build_euvgp8ua408ivvs8hgkf7dmfi in root
method1 in root
Delegate this:class Delegate in Delegate
method1 in Delegate