当前位置： 代码网 > it编程>开发工具>Docker > 【Jenkins】Pipeline流水线语法解析全集 -- 脚本式流水线、groovy语法

【Jenkins】Pipeline流水线语法解析全集 -- 脚本式流水线、groovy语法

2024年07月28日 • Docker •我要评论
【Jenkins】Pipeline流水线语法解析全集 -- 脚本式流水线、groovy语法

在这里插入图片描述

文章目录

脚本式流水线

groovy语法

注释

标识符

标识符也称为变量名；以字母、美元符号$或下划线_开始，不能以数字开始。

字符串

在groovy中字符串有两种类型，一种是java原生的java.lang.string；另一种是groovy.lang.gstring，又叫插值字符串(interpolated strings)。

单引号字符串（single quoted string）

在groovy中，使用单引号括住的字符串就是java.lang.string，不支持插值：

def name = 'dancs'

println name.class # class java.lang.string

三单引号字符串（triple single quoted string）

使用三单引号括住字符串支持多行，也是java.lang.string实例，在第一个’‘’起始处加一个反斜杠\可以在新一行开始文本：

def strippedfirstnewline = '''line one

line two

line three

'''

// 可以写成下面这种形式，可读性更好

def strippedfirstnewline = '''\

line one

line two

line three
'''

双引号字符串（double quoted string）

如果双引号括住的字符串中没有插值表达式（interpolated expression），那它就是java.lang.string；如是有插值表达式，那它就是groovy.lang.gstring：

def normalstr = "yjiyjige" // 这是一个java.lang.string

def interpolatedstr = "my name is ${normalstr}" // 这是一个groovy.lang.gstring

字符串插值（string interpolation）

在groovy语法中，所有的字符串字面量表示中，除了单引号字符串和三单引号字符串之外，其他形式都支持字符串插值。字符串插值，也即将占位表达式中的结果最终替换到字符串相应的位置中：

def name = 'guillaume' // 单引号不支持插值，定义一个变量值
def greeting = "hello ${name}" // name变量的值会被替换进去

print greeting.tostring() == 'hello guillaume'

在jenkins流水线中的script中使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def name = 'guillaume'
					def greeting = "hello ${name}" 
					print greeting.tostring()
                }
            }
        }
    }
}

输出结果为：

在这里插入图片描述

当使用点号表达式时，可以只用$代替${}：

//定义变量字典
def person = [name: 'guillaume', age: 36]
// 输出信息，调用变量
println "$person.name is $person.age years old"

在jenkins流水线中的script中使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def person = [name: 'zhangsan', age: 30]
					println "$person.name is $person.age years old"
                }
            }
        }
    }
}

输出结果为：zhangsan is 30 years old

在这里插入图片描述

// 注意还有一种小数点值输出的方式

def number = 3.14

println "$number.tostring()" // 这里会报异常,因为相当于"${number.tostring}()"

println "${number.tostring()}" // 这样就正常了
// 或者直接使用变量，就不会有小数点的报错了
println "$number"

列表

默认情况下groovy的列表使用的是java.util.arraylist，用中括号[]括住，使用逗号分隔：

def number = [1,2,3,4]

查看指定列表值

列表值是从0开始算的，输出第1个内容的时候为0；

def number1 = [1,2,3,4]
print "${number1[1]}"
// 返回的就是：2，如果[中写的0]返回的就是1；以此类推；
// 如果[中写的是4]超过了列表值，那么就返回的null。

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
                }
            }
        }
    }
}

结果为：2

在这里插入图片描述

查看列表值从前往后找

def number2 = [1,2,3,4]
print "${number2[-1]}"

// 结果为：4；[-2]就是3；以此类推。

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
					
					def number2 = [1,2,3,4]
					print "从后往前查看第一个值，结果为：${number2[-1]}"	
                }
            }
        }
    }
}

执行结果为：4

在这里插入图片描述

直接修改列表值

def number3 = [1,2,3,4]
number3[2] = 6
print "${number3[2]}"

// 输出结果为：6，如果选择[1]的话，那么输出的结果就还是2。

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
					
					def number2 = [1,2,3,4]
					print "从后往前查看第一个值，结果为：${number2[-1]}"
					
					def number3 = [1,2,3,4]
					number3[2] = 6
					print "修改的第2个值为：${number3[2]}"	
                }
            }
        }
    }
}

结果为：6

在这里插入图片描述

在列表中往后面添加一个值

def number4 = [1,2,3,4]
number4[4] = 5
print "在最后添加一个值，结果为：${number4[4]}"
// 结果为：5
print "此列表中现在所有的结果为：$number4"
// 结果为：[1,2,3,4,5]

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
					
					def number2 = [1,2,3,4]
					print "从后往前查看第一个值，结果为：${number2[-1]}"
					
					def number3 = [1,2,3,4]
					number3[2] = 6
					print "修改的第2个值为：${number3[2]}"	
					
					def number4 = [1,2,3,4]
                    number4[4] = 5
                    print "在最后添加一个值，结果为：${number4[4]}"
                    print "此列表中现在所有的结果为：$number4"
                }
            }
        }
    }
}

在这里插入图片描述

指定输出列表值

def number5 = [1,2,3,4,5,6,7,8,9,10]
print "指定取出列表第1、5、9、3的值：${number5[1,5,9,3]}"

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
					
					def number2 = [1,2,3,4]
					print "从后往前查看第一个值，结果为：${number2[-1]}"
					
					def number3 = [1,2,3,4]
					number3[2] = 6
					print "修改的第2个值为：${number3[2]}"	
					
					def number4 = [1,2,3,4]
                    number4[4] = 5
                    print "在最后添加一个值，结果为：${number4[4]}"
                    print "此列表中现在所有的结果为：$number4"
                    
                    def number5 = [1,2,3,4,5,6,7,8,9,10]
                    print "指定取出列表第1、5、9、3的值：${number5[1,5,9,3]}"
                }
            }
        }
    }
}

结果为：[2, 6, 10, 4]

在这里插入图片描述

二维列表

在groovy（以及许多其他编程语言中）中，二维列表（或称为列表的列表）是一个列表，其中的每个元素也是一个列表。换句话说，它是一个列表的嵌套结构。下面是个例子:

def twodimensionallist = [  
    [1, 2, 3],  
    [4, 5, 6],  
    [7, 8, 9]  
]

简单来说，在列表的基础上；用一个大的中括号，套多个中括号列表，称为二维列表。

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script') {
            steps {
                echo "scripted block"
                script {
					def number1 = [1,2,3,4]
					print "正常查看第1个列表值，结果为：${number1[1]}"
					
					def number2 = [1,2,3,4]
					print "从后往前查看第一个值，结果为：${number2[-1]}"
					
					def number3 = [1,2,3,4]
					number3[2] = 6
					print "修改的第2个值为：${number3[2]}"	
					
					def number4 = [1,2,3,4]
                    number4[4] = 5
                    print "在最后添加一个值，结果为：${number4[4]}"
                    print "此列表中现在所有的结果为：$number4"
                    
                    def number5 = [1,2,3,4,5,6,7,8,9,10]
                    print "指定取出列表第1、5、9、3的值：${number5[1,5,9,3]}"
                    
                    def number6 = [[0, 1], ['壹', '叁'],['a','c','d','f']]
                    print "二维列表中，指定输出的值为：${number6[2][3]}"
                }
            }
        }
    }
}

输出的结果为：f

在这里插入图片描述

字典（maps）

在groovy语法中，使用中括号[]来定义字典，和列表一样，都是使用中括号[]，但区别为列表[]里是具体的值，而字典里是需要包含key和value，key和value之间使用冒号分隔，元素与元素之间用逗号分隔；

下面一个基本的例子：

def people = [name:'zhangsan',age:'18',sex:'男',height:'180']
print "姓名为：${people.name}，年龄为：${people.age}，性别为：${people.sex}，身高为：${people.height}"

下面是在jenkins流水线的script下使用：

pipeline {
    agent any
    
    stages {
        stage('script -- maps') {
            steps {
                echo "scripted block"
                script {
					def people = [name:'zhangsan',age:'18',sex:'男',height:'180']
					print "姓名为：${people.name}，年龄为：${people.age}，性别为：${people.sex}，身高为：${people.height}"
                }
            }
        }
    }
}

输出的结果为：

在这里插入图片描述

条件语句 if/else判断

pipeline脚本同其它脚本语言一样，从上至下顺序执行，它的流程控制取决于groovy表达式，如if/else条件语句：

  • 语法：
if (条件) {
	echo "要输出的值"
}else{
	echo "要输出的值2"
}

script 示例：

pipeline {
    agent any
    
    stages {
        stage('script -- if/else') {
            steps {
                echo "scripted block"
                script {
					if(env.branch_name == 'master'){
					    echo 'i only execute on the master branch'
					}else{
					    echo 'i execute elsewhere'
					}
                }
            }
        }
    }
}

判断，如果是在master分支上执行的那么就输出：i only execute on the master branch，否则就输出：i execute elsewhere；

env.branch_name是流水线语法中的全局变量，可在此查看全局变量都有什么：http://ip:port/job/my_pipeline/pipeline-syntax/globals

执行结果为：i execute elsewhere，因为我们没有开启多分支所以没有分支的说法，所以是false判断；

在这里插入图片描述

for循环

for 循环用于遍历一组值。用法和java是一样的；

  • for循环语法：
for(int i = 1;i<=5;i++) {
	println "循环第${i}次";
}
  • 在jenkins的script中使用：
pipeline {
    agent any
    
    stages {
        stage('script -- for') {
            steps {
                echo "scripted block"
                script {
					for(int i = 1;i<=5;i++) {
	                    println "循环第${i}次";
                    }
                }
            }
        }
    }
}

在这里插入图片描述

  • 进阶for循环，在jenkins的script中使用：
pipeline {
    agent any
    
    stages {
        stage('script -- for') {
            steps {
                echo "scripted block"
                script {
					def array = ['language','mathematics','english']
					for (i = 0;i < array.size();i++) {
					    echo "this is ${array[i]}, the ${i}th array;"
					}
                }
            }
        }
    }
}

执行结果：

在这里插入图片描述

异常处理try/catch/finally

pipeline脚本流程控制的另一种方式是groovy的异常处理机制。当任何一个步骤因各种原因而出现异常时，都必须在groovy中使用try/catch/finally语句块进行处理

pipeline {  
    agent any  
  
    stages {  
        stage('example stage with exception handling') {  
            steps {  
                script {  
                    try {  
                        // 尝试执行的代码块  
                        echo "trying to execute some code..."  
                        // 这里可以调用其他函数或执行可能抛出异常的步骤  
                        // 例如，模拟一个异常：  
                        throw new exception("something went wrong!")  
                    } catch (exception e) {  
                        // 捕获并处理异常  
                        echo "caught an exception: ${e.getmessage()}"  
                        // 可以选择标记构建为失败，或者进行其他错误处理  
                        currentbuild.result = 'failure'  
                    } finally {  
                        // 无论是否发生异常，都会执行的代码块  
                        echo "this will always be executed, regardless of exceptions."  
                        // 可以在这里执行清理操作或其他必要的步骤  
                    }  
                }  
            }  
        }  
    }  
}

在这个例子中，try 块包含可能会抛出异常的代码。如果 try 块中的代码抛出了异常，那么控制流会立即跳转到与异常类型匹配的 catch 块（在这个例子中是 exception 类型）。在 catch 块中，你可以处理异常，比如记录错误消息或者设置构建的状态。

无论 try 块中的代码是否抛出异常，finally 块中的代码都会被执行。这通常用于执行清理操作，比如关闭文件句柄、释放资源等。

请注意，在 jenkins pipeline 脚本中，使用 currentbuild.result = 'failure' 可以将构建状态标记为失败。这通常在捕获到异常并希望停止构建流程时非常有用。如果 finally 块中的代码也可能失败，你可能还需要在 finally 块中进一步处理异常，以确保所有的清理工作都能正确完成。

总结

参考文献：

相关专栏

专栏名称专栏地址
《jenkins》
《linux从入门到精通》

相关文章

文章名称文章链接
【jenkins】pipeline流水线语法解析全集 – 声明式流水线
【jenkins】pipeline流水线语法解析全集 – 脚本式流水线、groovy语法
赞 (0)

相关文章:

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论

验证码：
最近更新的文章
推荐阅读
大家感兴趣的文章
Copyright © 2017-2025  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱：2386932994@qq.com