Jenkins pipeline 脚本语言学习支持

1 引言

Groovy是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Groovy是一种基础JVM(Java虚拟机)的敏捷开发语言，他结合了Python、Ruby和Smalltalk的特性，Groovy代码能够于Java代码很好的结合，也能用于扩展现有代码。由于其运行在JVM的特性，Groovy可以使用其他Java语言编写法的库。

for(int i=0; i<10; i++) {...
}10.times{...
}

在使用Groovy编程时，Java有的Groovy几乎都有。Groovy同样扩展了java.lang.Object类，Groovy类就是Java类，Java语义都保留下来了，所以使用Groovy编写的表达式和语句，对于Java程序员而言，理解它没有任何障碍。
在这里插入图片描述

Groovy虽然支持Java的语法但它并没有强迫我们学习新的类和库，而是通过向JDK中各种类添加方法，所以说Groovy扩展了JDK，这些扩展称之为GDK (Groovy JDK)。

Java中可以使用java.lang.process与系统级进程进行交互，例如，我们在代码中调用git的help命令并把help的内容打印出来，用Java的实现代码如下:

package com.zs.groovy;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class ExecuterProcessor {public static void main(String[] args) {try {// 获取process实例Process process = Runtime.getRuntime().exec("git help");// 读取输入流BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));String line = "";while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}}
}

转化为 groovy 语法：

print "git help".execute().text

2 基本语法

2.1 标识符

在这里插入图片描述

2.2 字符串

Groovy允许实例化java.lang.String类来定义一个字符串对象，同样地，也可以通过实例化groovy.lang.GString类定义一个字符串对象，两者可以混合使用。

def a = 'i am zhaoshuai-lc'
def b = '''i am zhaoshuai-lcandi am a male
'''
// 说明:用单引号或三个单引号定义的字符串不支持混合编程def c = "hello zhaoshuai-lc"

> def name = "zhaoshuai-lc"
> def _name = "hello ${name}"
> print _name
hello zhaoshuai-lc

三个双引号引起来的字符串：
用"""引号引起来的字符串行为上和双引号引起来的字符串是一样的，不同之处在于它代表多行字符串，就像三个单引号定义的字符串。例如:

def name = 'zhaoshuai-lc'
def template = """Dear $namei love U
"""
print(template)

如果是使用内置变量类型定义的变量，一经定义，后面是不可以更改变量类型的。但是Groovy也提供了类似javascript中的any定义任意变量类型的关键字def。

class Example { static void main(String[] args) { def _Name = 1;_Name="it飞牛"; println(_Name);} 
}
//打印如下：
it飞牛

在这里插入图片描述

2.3 数值类型

byte -这是用来表示字节值。例如2。
short -这是用来表示一个短整型。例如10。
int -这是用来表示整数。例如1234。
long -这是用来表示一个长整型。例如10000090。
float -这是用来表示32位浮点数。例如12.34。
double -这是用来表示64位浮点数，这些数字是有时可能需要的更长的十进制数表示。例如12.3456565。
char -这定义了单个字符文字。例如“A”。
Boolean -这表示一个布尔值，可以是true或false。
String -这些是以字符串的形式表示的文本。例如，“Hello World”。

在这里插入图片描述

不同类型数值进行算术运算的规则：
对于二元运算符，两个不同类型的数值进行运算后它们的结果按照以下规则确定
对于byte、char、short、int这几种类型之间运算的结果为int
涉及long与byte、char、short、int之间运算的结果为long
涉及BigInteger与其它类型数值之间的运算结果为BigInteger
BigDecimal与byte、char、short、int之间的运算结果为BigDecimal
float、double与BigDecimal之间的运算结果为double
两个BigDecimal之间的运算结果为BigDecimal

2.4 数组与集合

Groovy没有自己的集合类型，它的List类型实际上用的就是JDK中的java.util.List包。当我们定义一个集合对象，Groovy默认采用Java.util.ArrayList类型。

> def numbers = [1, 2, 3]
> assert numbers instanceof java.util.List
> assert numbers.size() == 3

也可以在集合中放置不同类型的元素，例如:

def numbers = [1, 2, 3, true, 'false']

默认定义的集合对象属于Java.util.ArrayList类，也可以用as运算符，强制定义List接口的其它实现类的对象，例如:

> def list = [1, 2, 3, 4] as LinkedList
> assert list instanceof LinkedList

> def list = [1, 2, 3, 4] as LinkedList
> assert 1 == list[0]
> assert 4 == list[-1]
> list << true
> print list[4]
true

Groovy 可以定义多维集合，例如:

def multi = [[0, 1], [2, 3]]

Groovy中数组和集合的表示方式相同，也就是说Groovy复用list的表示形式来表示数组，但必须显式的声明数组的类型，例如:

> String[] arrStr = ['zhaoshuai-lc', 'zhaoshuai-la', 'zhaoshuai-lb']
> assert arrStr instanceof String[]
> assert !(arrStr instanceof List)

使用as运算符，强制转化为要定义的类型：

> def intArr = [1, 2, 3] as int[]
> assert intArr instanceof int[]

也可以定义多维数组：

> def _matrix = new Integer[2][3]
> assert _matrix.size() == 2

声明时不指定数组元素个数：

> Integer[][] arr
> arr = [[1, 2, 3], [2, 3]]
> print arr.length
2

访问数组元素时按照和list—样的方式，使用下标运算符[]，例如:

> String[] strArr = ['zjaosuia', 'dafas', 'erqrw']
> print strArr[2]
erqrw

Java 风格化：

> def primes = new int[]{2, 3, 4, 1, 6}
> assert primes.length == 5 && primes.sum() == 16
> 
> def pets = new String[]{'zhaoshuai', '-', 'lc'}
> assert pets.size() === 3 && pets.sum() == 'zhaoshuai-lc'
> 
> String[] groovyArr = ['zhaoshuaiA', '-A', 'lcA']
> assert groovyArr.every { it -> it.contains('A') }

2.4.1 List 语法详解

groovy 列表使用索引操作符 [] 索引。列表索引从 0 开始，指第一个元素。groovy 中的一个列表中的数据可以是任意类型。这 java 下集合列表有些不同，java 下的列表是同种类型的数据集合。
List.reverse() 可以实现列表反转。
调用 List.sort() 可以实现列表排序。

> def list1 = []
> def list2 = [1, 2, 3, 4]
> list2.add(12)
> list2.add(12)
> println list1.size()
> println list2.size()
0
6

1、搜索-find

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];// find：返回第一个符合条件的项def find = list.find( item -> item == 1)assert 1 == find// findAll：返回所有符合条件的项def findA = list.findAll( item -> item == 1)assert [1, 1] == findA// findIndexOf：返回满足条件的第一个元素的下标值。def index = list.findIndexOf(item -> item == 1)assert 0 == index}
}

2、排序-sort、reverse

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];// sort-正序排序print list.sort();// sort-倒叙排序print list.sort((a, b) -> b - a)// reverse：将原list倒序，返回一个新的listprint list.reverse();}
}

3、返回新数组-collect、tail

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];// collect:返回一个新的list，他可以接受一个闭包参数或者无参。类似js中map。it是闭包中自带的隐式变量；println list.collect(item -> item + 100)// tail：返回一个新的list，它包含list中的所有的元素(除了第一个元素)println list.tail(); // [2, 3, 1, 2, 3]}
}

4、遍历 each、eachWithIndex

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];// each：普通的迭代遍历list.each(item -> print item)//eachWithIndex：他的作用和each一样，但是他要传入一个闭包，有两个参数，一个是值，一个是索引。list.eachWithIndex { int entry, int i -> println("${entry}--${i}")}}
}

every、any、first、last、max、min、count、unique

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];// every：接收一个闭包，返回为一个布尔值，当所有条件都满足时才返回trueprintln list.every(item -> item > 0)// any：和every用法一样，只要有一个为true，则返回trueprintln list.any(item -> item > 0)//返回第一个数据println(list.first());//返回最后一个数据println(list.last());//返回最大值println(list.max());//返回最小值println(list.min());//返回总和println(list.sum());//返回某项出现的次数println(list.count(3));//返回去重后的数组println(list.unique());}
}

5、分组

class Main {static void main(String[] args) {def items = [[name: "tony", age: 4], [name: "tony", age: 5], [name: "alan", age: 16]]def groups = items.groupBy { it.name }println(groups);// [tony:[[name:tony, age:4], [name:tony, age:5]], alan:[[name:alan, age:16]]]}
}

6、包含

class Main {static void main(String[] args) {def list = [1, 2, 3, 1, 2, 3];def list2 = [1, 2, 3, 4];println(list.containsAll(list2));println(list2.containsAll(list));}
}

2.5 Map映射

Groovy的map对象就是LinkedHashMap的实例
在这里插入图片描述

class Example { static void main(String[] args) { def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"] println(mp.get("TopicName")); println(mp.get("Topic")); } 
}

2.6 对象运算符

安全导航运算符(safe navigation operator) 主要作用为避免出现NullPointerException异常，如果出现空指针异常，使用安全导航运算符将返回null，而不是抛出异常。例如:

> class Person{
>     int id
> 
>     Person(int id) {
>         this.id = id
>     }
> 
>     int getId() {
>         return id
>     }
> 
>     void setId(int id) {
>         this.id = id
>     }
> 
> }
> def person = new Person(3451)
> def _person = person.find{ item -> item.id == 345}
> println _person
> println _person?.id
null
null

直接字段访问运算符(Direct field access operator) 使用该运算符可以不用调用get方法而直接获取字段的值。例如:

> class User {
>     public String name;
>
>     User(String name) {
>         this.name = name;
>     }
>
>     String getName() {
>         "Name: ${name}"
>     }
> }
>
> def user = new User("Bob")
> print user.name
> assert user.name == 'Name: Bob'
Name: Bob> class User {
>     public String name;
>
>     User(String name) {
>         this.name = name;
>     }
>
>     String getName() {
>         "Name: ${name}"
>     }
> }
>
> def user = new User("Bob")
> print user.@name
> assert user.@name == 'Bob'
Bob

2.7 正则表达式

Groovy使用~”pattern” 来支持正则表达式，它将使用给定的模式字符串创建一个编译好的Java Pattern 对象。Groovy也支持 =~（创建一个Matcher）和 ==~ (返回boolean，是否给定的字符串匹配这个pattern)操作符。

> import java.util.regex.Pattern
>
> def p = ~/foo/
> assert p instanceof Pattern
> def res = p.matcher('foo').matches()
> print res
true

> import java.util.regex.Matcher
>
> def text = 'i am your father'
> def res = text =~ /father/
> assert res instanceof Matcher
> print res.matches()
false

> import java.util.regex.Matcher
>
> def text = 'i am your father'
> def res = text ==~ /father/
> assert res instanceof Boolean
> print res
false

3 类与脚本

Groovy提供了两种代码方式，一种是脚本一种是类，首先我们定义一个名为Main.groovy的类。代码如下:

class Main{static void main(String[] args) {print 'hello zhaoshuai-lc'}
}print 'hello zhaoshuai-lc'

print 'hello zhaoshuai-lc'

上面的脚本实由groovy.lang.Script类编译成一个class文件，把脚本代码拷贝到groovy.lang.Script类的run方法中进行执行，实际运行的代码形如下面的内容:

在这里插入图片描述
执行的步骤如下:
Main.class继承Script类
把脚本的主体内容复制到run方法内
然后自动生成main()方法，最后运行run()

方法可以在脚本中定义方法，例如:

> int fib(int n) {
>     n < 2 ? 1 : fib(n - 1) + fib(n - 2)
> }
>
> assert fib(10) == 89

创建的脚本类在编译后会把脚本中的所有方法装配到run方法中，这些对于用户来说都是透明的。

变量在脚本中定义变量无需声明变量的类型，例如:

int x = 1
int y = 2
assert x+y == 3

×= 1
y = 2
assert x+y == 3

这两者在语义上有一些差别，上面的例子中声明的变量属于局部变量，只在run方法内部可见，而下面的无声明变量定义对于其它方法可见，这对于脚本与其它应用程序共享数据就显得很重要了。

Groovy类是数据的集合和对该数据进行操作的方法的载体，类的数据和方法用于表示问题域中的一些现实世界对象。 Groovy中的类声明了该类定义的对象的状态（数据）和行为。因此，Groovy类描述了该类的实例字段和方法。
在这里插入图片描述
在任何编程语言中，总是使用private关键字隐藏实例成员，通过提供getter和setter方法来相应地设置和获取实例变量的值。例如下面的代码:

在这里插入图片描述
内部类定义在另一个类中，外层类可以访问内部类，内部类也可以使用外层类的成员变量，即使是私有的。其它类不能访问内部类。内部类的示例如下:

class Main {static void main(String[] args) {def outer = new Outer()outer.name = 'zhaoshuai-lc'outer.callInnerMethods()}
}class Outer {String namedef callInnerMethods() {new Inner().methodInner()}class Inner {def methodInner() {print name}}
}

extends是用于继承类的关键字，我们通过一个示例介绍groovy中如何继承其它类：

class Main {static void main(String[] args) {def sub = new Sub('zhaoshuai-lc')}
}class Outer {public String nameOuter(String name) {print name}
}
class Sub extends Outer {Sub(String subName) {super(subName)}
}

抽象类表示通用概念，因此它不能被实例化，但可以被继承。抽象类中的抽象方法只有方法的定义而没有方法的实现，它的实现通过继承它的类来完成，定义抽象类通过关键字 abstract来声明，抽象方法也是同样的。

接口定义了类需要遵守的规范，接口仅定义需要实现的方法的列表，但是不定义方法实现。接口需要使用interface关键字声明接口，接口的方法总是公开的，在接口中使用受保护或私有方法是一个错误。

class Example {static void main(String[] args) {Student st = new Student();st.StudentID = 1;st.Marks1 = 10;println(st.DisplayMarks());} 
} interface Marks { void DisplayMarks(); 
} class Student implements Marks {int StudentIDint Marks1;void DisplayMarks() {println(Marks1);}
}

4 闭包

闭包可以接收入参
闭包可以引用外部变量

class Example {     static void main(String[] args) {def str1 = "Hello";def clos = {param -> println "${str1} ${param}"}clos.call("World");// We are now changing the value of the String str1 which is referenced in the closurestr1 = "Welcome";clos.call("World");} 
}//打印
Hello World 
Welcome World