avatar

groovy语法

groovy

groovy学习视频

groovy是什么

Groovy是构建在JVM上的一个轻量级却强大的动态语言, 它结合了Python、Ruby和Smalltalk的许多强大的特性.
Groovy就是用Java写的 , Groovy语法与Java语法类似, Groovy 代码能够与 Java 代码很好地结合,也能用于扩展现有代码, 相对于Java, 它在编写代码的灵活性上有非常明显的提升,Groovy 可以使用其他 Java 语言编写的库.

groovy安装

这里如果只是用jenkins编写脚本,不需要安装额外的东西,只需要在jenkisn上面使用就可以了
我们需要在下载页面进行安装下载,下载完以后进行解压。
解压完成以后需要配置环境变量

  • 新建GROOVY_HOME,值为刚才解压的路径。
  • 修改PATH,在最后追加%GROOVY_HOME%\bin
    改好一个我们进行测试,打开cmd测试一下groovy -v看是否可以出现版本号

    groovy基本语法

    groovy与java很相似,也可以使用Java的方法,所以类似于java的for try catch这些不多介绍。

    动态类型

    定义一个变量以后,可以对这个变量赋值任何类型的值,如下
    def v = 0; // 定义了数值类型变量
    v= new Date(); //又赋值为日期类型
    print(v); //打印输出

    简单明了的list。map类型

    可以使用groovy简单明了的定义list和map数据
  • 使用”[]”定义列表,并对其直接进行操作
  • 使用”:”分割key和value来行衣map数据,key不需要用引号引起,而且能使用key对其直接对map进行读写操作
    //list
    def list = [1,2]
    list.leftShift(3)
    list.push("abc")//从前面插入
    //groovy中的<<可以对list数据类型的最用添加值,在数字类型是位运算符
    list << "<<号"
    list += "+=号"
    print(list)

    list.each( {
    println(it) //it是一个默认的传值,这里可以认为是一个匿名函数
    })

    def map = [a:2,b:new Date()]

    map.put("aa","bb")

    println(map)
    map.a = 3
    println(map)

    在groovy一切都是对象

    在groovy中,一切都是对象,一切都可以当作对象来使用
    100.times {println(it)}//打印一百次

    属性操作变得更加容易

    在groovy中,定义一个javabeans,不需要写getting,setting方法,读写属性直接使用”.”操作符即可
    class javabeans
    {
    String o
    }
    javabeans javabean = new javabeans()
    javabean.o = "hjaha"
    println(javabean.o)

    GString

  • 双引号””定义的字符串
  • 可以直接通过$var或者${var}方式简单明了的嵌入变量
    def a = "这是我"
    println("${a}")
    println("$a")

    闭包

  • 闭包中内置了很多迭代方法,如find,findAll,collect等等
    def list = ['foo','bar']
    def nemlist=[]
    list.collect(nemlist){
    it.toUpperCase()
    }
    println(nemlist)
    //也可以这样
    list = ['foo','bar']
    nemlist=[]
    list.collect(nemlist,{
    it.toUpperCase()
    })
    println(nemlist)
  • 在groovy中,闭包可以看成是一个代码块,它可以没有参数和返回值 ,它想java8以上的lambda语法或者像一个有方法的java内部类
  • 在groovy闭包中隐藏了很多内置的变量
  • it,当闭包的方法中 没有定义任何参数时,也可以直接使用it变量
  • this跟java中的this一样
  • owner基本上跟this一样,只是除了一种情况,如果闭包时在其他的闭包中定义的那么owner指向定义它的闭包对象
    def a = {
    println "a this:" + this
    println "a owner:" + owner
    def b = {
    println "b this:"+this
    println "b owner"+ owner
    }
    b.call()
    }
    a.call()
  • delegate基本上与owner一样但是可以通过set改变值

    Switch

    groovy的switch支持传入list对象,范围..等表达式作为case的依据
    def x =20
    switch (x)
    {
    case [1,2,3,4]:
    println("aaa")
    break
    case "faa":
    println("bbbb")
    break
    case 10..100:
    println("cccc")
    break
    case Date:
    println("ddddd")
    break
    default:
    println("eee")
    }

    元编程

    groovy可以通过使用mateCalss类来对元数据添加属性和方法
    String.metaClass.upper={-> toUpperCase()}
    println("ooo".upper())

    Integer.metaClass.say={-> "I am int"}
    def i = new Integer(100)
    println(i.say())

    用@TypeChecked注解进行强类型检查

    import groovy.transform.TypeChecked

    class Foos{
    int i = 42.0//不报错
    }

    @TypeChecked
    class foo{
    int i = 42.0//会报错
    }
  • 在闭包里面如果想要强类型检查,可以像java一样定义参数类型
    def list=["oo","qq","zz"]
    list.collect{
    String it ->it.toUpperCase()
    }

    Elvis Operator运算符

  • 进一步简化三元运算符
    def a = null
    def b=a?:"bbb"//这句话的意思就是定义变量b,如果a有值赋值b,没值赋值bbb def b = a==null?a:"bbb"
    println(b)
  • 安全访问
    def person
    String name = person?.getName()//作用就是C#里面的?如果时null就不往后走了
    println(name)

    groovy-Groovy Development Kit(GDk)

    groovy自带集合方法

  • sort对集合进行排序,这个方法可以接受一个闭包作为参数,或者无参数
    def list = [13,24,65,3]
    def numlist = list.sort()
    println(numlist)

    def numlist2 = list.sort({
    a,b -> a - b ? -1:1 //lambda表达式
    })
    println(numlist2)
  • findall返回所有符合条件的元素,它可以接受一个闭包作为参数,或者无参数
    def list = [13,24,65,3]
    def numlist = list.findAll()
    println(numlist)

    def numlist2 = list.findAll({
    value -> value<13
    })
    println(numlist2)
  • collect返回一个新的list,它可以接受一个闭包作为参数,或者无参数
    def list = [13,24,65,3]
    def numlist = list.collect({
    it = it*2
    })
    println(numlist)
  • inject:一个累计的过程方法,传入inject方法的T作为sum的初始值,在遍历collection的过程中,将处理结果(”sum,&elem”)保存到sum中
    def list = [13,24,65,3]
    def numlist = list.inject(0) {
    sum,elem -> sum = sum+elem
    }
    println(numlist)
  • each迭代器,用于循环
  • eachWithIndex用法与each类似,不同的是eachWithIndex传入的是一个闭包,又两个参数一个是值一个是索引
    def list = [13,24,65,3]
    def numlist = list.eachWithIndex { int entry, int i -> println(entry+' '+i)}
  • find:返回第一个符合条件的元素,它可以接受一个闭包作为参数,或者无参数
  • findIndexOf 返回指定元素的索引值它可以接受一个闭包作为参数,或者无参数
  • any 返回boolean值,只要有任意一个符合条件就返回true,它可以接受一个闭包作为参数,或者无参数
  • avart 返回boolean 只有全部符合条件就返回true,它可以接受一个闭包作为参数,或者无参数
  • reverse 返回list倒序,返回一个新的list 无参数
  • first 返回list的第一个值
  • last 返回list的最后一个值
  • tail 返回新的list,这个list包含原list(除死一个元素)的所有元素
  • 还有一些其他方法,这里不一一介绍

    通配符(*)可以很方便的来访问集合对象所有属性

    class Car{
    String make
    String model
    }
    def care=[
    new Car(make:'zlh',model: "5.8"),
    new Car(make:'zlh2',model: "5.9")
    ]
    def makes = care*.make // care*.make属性所有的值都整出来
    makes.each {
    println(it)
    }

    [1,3,5,5,67,]*.multiply(2);//对集合内所有的元素乘2

    GPath 可以轻松访问多层的集合对象

    def listOfMaps = [['a':11,'b':22],['a':33,'dd':44],null]
    println(listOfMaps.a) // [11, 33]

    def listOfMaps1 = [['a':11,'b':22],['a':33,'dd':44],null]
    println(listOfMaps1*.a) // 这个会挨着去遍历,找到null返回null

    IO操作

  • groovy可以简单明了的进行文件读写操作
    println new File("test.txt").text //与该脚本文件同一个路径下
  • 写入一个文件内容
    new File("write.txt").text = "write a file"
  • 通过字节写入
    //先手动创建data文件
    byte[] data = new File("data").bytes
    //把data的数据写进另一个文件中
    new File("data2.txt").bytes = data

    //按行读出
    new File("test.txt").eachLine {line->println(line)}
  • 可以使用InputStream,OutPutStream,Reader,Writer来读文件
    • 输入流InputStream操作:
      Properties properties = new Properties()
      File propertiesFile = new File('test.properties')
      propertiesFile.withDataInputStream {
      properties.load(it)
      }
      println(properties.name)
      println(properties.url)
    • reader操作
      def lineNo = 1
      def line = 1
      new File("test.txt").withReader {reader ->
      while ((line = reader.readLine())!=null)
      {
      println("${lineNo} ${line}")
      lineNo++
      }
      }
    • OutPutStream
      def srcFile = new File("test.txt")
      def targetFile = new File("targetFile.txt")
      targetFile.withOutputStream {
      outputStream ->
      srcFile.withInputStream {
      inputStream ->
      outputStream << inputStream
      }
      }
    • 写入write
      new File("writeFile.txt").withWriter("utf-8",{write -> write.writeLine("hello write")})
      //简洁版
      new File("write2.txt") << "hello world"

极简的URLs操作

URL url = new URL("https://www.baidu.com/")
InputStream input = (InputStream) url.getContent()

ByteArrayOutputStream out = new ByteArrayOutputStream()

int n=0;
byte[] arr = new byte[1024]

while (-1 != (n=input.read(arr)))
{
out.write(arr,0,n)
}
new File("baidu.html").write(new String(out.toByteArray()))

//更简洁的方法就是
println("https://www.baidu.com/".toURL().text)

Ranges 用..表示范围

在groovy中,范围运算可以用在循环,switch,字符串截取中

1..10 //包含1到10的范围数据
1.. <10 //包含1到9的数字
"a".."x" //范围也可以是字符够成
10..1 //范围也可以是倒序,字符串也可以

//可以用于字符串截取,或者数组分割
def a = "qwertyuy"
println(a[1..4])

Expando

Expando类是一个类似于javabean的东西,但是比javabean要强大很多,可以体会一下

def expando = new Expando()
expando.name = {->"abc"}
expando.say = {String a -> "${expando.name} say ${a}"}
println(expando.say("hello"))

def person =new Expando()
person.name = "zenshin"
person.age = 24
person.description={
println ("name: ${person.name}" +
"age : ${person.age}")
}
person.description()

对ObserableList/Map/Set的变化添加监听

def list = new ObservableList()
def print = {e->println(e)}
list.addPropertyChangeListener(print)
list.add("aaa")
list.remove(0)

groovy特性

参数默认值

def a(arg = "abc")
{
println(arg)
}
a()
a("aaedadwe")

正则表达式

只需要用 /表达式/,匹配时用:需要匹配的字符==/正则/

// ==~是看匹配
def email = "1127913170@qq.com"
def isEmail = email==~/[\w]{10}@[\w]{2}.+com/
println(isEmail)
//=~是截取
def str = "@qqqq%aaa*ccccc"
def strarr = str=~/((?<=[@%*]{1})\w+)/
while (strarr.find())
{
println(strarr.group())
}

被弱化的泛型

groovy的类型一直都是弱类型如果需要强类型那么需要加CompileStatic加以强化类型

@CompileStatic
class foo
{
List<Integer> nums =[1,2,3,45,"a"] //会报错
}

groovy数字类型

  • 在默认情况下groovy的数字的类型都是BigDecimal类型的
  • 如果想定义double,float,long类型的数字,只需要在数字后面加上d,f,l

    Boolean自动转换

  • 在默认情况下groovy会把空字符串,0,null,的if条件语句转换为flase,其他转换为true

    map语法糖

    groovy应许我们把一个变量当成map的key和value
    def foo = 1
    def bar = 2
    def map = [(foo) : bar] //必须加括号
    println(map[foo])
文章作者: zenshin
文章链接: https://zlh.giserhub.com/2020/04/03/ckbbo2j41001qpkwacx0i0mvk/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 zenshin's blog
打赏
  • 微信
    微信
  • 支付宝
    支付宝

评论