Pipeline Groovy 语法

Groovy是一种功能强大，可选类型和动态 语言，支持Java平台。旨在提高开发人员的生产力得益于简洁，熟悉且简单易学的语法。可以与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本编写功能，特定领域语言编写，运行时和编译时元编程以及函数式编程。

字符串操作

注释

//  单行注释   
  
/*
    多行注释
*/

字符串操作

字符串表示方式： 单引号、双引号、三单双引号
字符串操作：截取字符串、判断某个字符串是否存在、获取字符串长度、字符反转等……

//定义一个字符串类型变量name，定义一个变量lovely包含多行内容

                script{
                    String name = 'zhangsan'
                    String lovely = """
                    dev
                    ops
                    """
                    println(name)
                    println(lovely)
                }

-------------
//字符串和变量值截取，使用split选择分隔符，先分割后截取

                script{
                    name = "yuanyuan-gao"
                    String Version = "release-1.2.3"
                    println(Version.split("-")[0])
                    println(Version.split("-")[-1])
                    println("${name}".split("-")[-1])
                }
         
控制台输出 release   1.2.3  gao
-------------
//使用 contains 判断是否包含某字段

                script{
                    name = "yuanyuan-gao"
                    String Version = "release-1.2.3"
                    println(Version.contains("release"))
                }
           
---------------
//打印字符串的长度

                script{
                    name = "yuanyuan-gao"
                    String Version = "release-1.2.3"
                    println(Version.size())
                    println(Version.length())
                }
--------------
//引用其他变量值作为值

                script{
                    name = "yuanyuan-gao"
                    String Version = "release-1.2.3"
                    println(Version)
                    def message = "Version ${Version}"
                    println(message)
                }
            
控制台输出 release-1.2.3 和 Version release-1.2.3

---------------
//判断字符串结尾
                script{
                    name = "yuanyuan-gao"
                    String Version = "release-1-2-3"
                    println(Version.endsWith("3"))
                }
--------------
//字符串增删操作 +- 或plus和minus
                script{
                    String log = "error: xxxxxx aa"
                    println(log.minus("a"))
                    println(log - "a")
                    println(log.plus("aa"))
                    println(log + "aa")
                }    
--------------
//字符串反转
                script{
                    String nums = "1234567"
                    println(nums.reverse())
                }

列表 List

// 定义一个list并打印

				script{
                def mylist = ["a","b",1,2,"devops"]
                println(mylist)
				}

// list的元素增删

				script{
                def mylist = ["a","b",1,2,"devops"]
                println(mylist + "jenkins")
                println(mylist - "devops")
				}


// 判断元素是否为空
println(mylist.isEmpty())

// 列表去重
println(mylist.unique())

// 列表反转
println(mylist.reverse())

// 列表排序
println(mylist.sort())

// 判断列表是否包含元素
println(mylist.contains("devops"))

// 列表的长度
println(mylist.size())

//扩展列表定义方式
String[] stus = ["zhangsan", "lisi","wangwu"]
def numList = [1,2,3,4,4,4] as int[]

// 通过索引获取列表元素
println(numList[2])

// 计算列表中元素出现的次数
println(numList.count(4))

映射 Map

// 定义map并打印出value值

				script{
                def mydef = ["mvn":"/usr/local/maven","jar":"/usr/local/jar"]
                println(mydef.mvn)
                println(mydef.jar)
				}


// 根据key给map重新赋值

				script{
                def mydef = ["mvn":"/usr/local/maven","jar":"/usr/local/jar"]
                mydef["mvn"] = "new maven"
                println(mydef.mvn)
				}

// 判断map是否包含某个key或者value

				script{
                def mydef = ["mvn":"/usr/local/maven","jar":"/usr/local/jar"]
                println(mydef.containsKey("mvn"))
				}

// 返回map的key 列表

				script{
                def mydef = ["mvn":"/usr/local/maven","jar":"/usr/local/jar"]
                println(mydef.keySet())
				}

条件语句

if语句，在Jenkinsfile中可用于条件判断。

/*
定义变量参数name
如果name 等于dev则打印dev，
如果name 等于test则打印test，
上面都不匹配则打印skipdeploy
*/

pipeline {
	agent { label  "build" }
	stages {
		stage("build"){
			steps{
				script{
                 String name = "hhh"
                 if ( name == "dev"){
                 println("dev……")    
                 } else if ( name == "test"){
                     println(test……)
                 } else {
                     println("skipdeploy……")
                 }
				}
			}
		}
	}
}

switch语句

/*
定义参数branchName
匹配 develop  则打印develop ，跳出。
匹配 release  则打印release ，跳出。
默认匹配， 打印 error ，退出。


*/

String branchName = "release"

switch(branchName) {
	case "develop":
	    println("develop .....")
		break
	case "release":
		println("release.....")
		break
	default:
	    println("error。。。。。。")
}

for循环语句

// 遍历0-9，打印
				script{
				    for (i=1; i<10; i++ ){
                    	println(i)
                    }
// 循环5次
5.times { 
	println("hello")
}

// 遍历 0-4
5.times { i ->
   println(i)
}

// 遍历List
def serverList = ["server-1", "server-2", "server-3"]
for ( i in serverList){
	println(i)
}

// 使用each遍历map
def stus = ["zeyang":"177", "jenkins":"199"]
stus.each { k, v ->
	println(k+"="+v)
}

// 使用for遍历map
for (k in stus.keySet()){
	println(k+"="+stus[k])
}