Jenkins流水线是否支持动态构建可变阶段，而非固定阶段集合？

Jenkins支持动态组装流水线阶段，不过声明式流水线本身语法限制较多，需要结合脚本式写法来实现。下面是两种可行方案：

方案1：纯脚本式流水线实现动态阶段 #

脚本式流水线灵活性更高，可直接通过循环、变量动态生成阶段，完全匹配你伪代码的需求。比如从构建参数或文件读取阶段列表，遍历执行：

// 从构建参数获取阶段列表，或读取文件解析
def myStages = params.STAGE_LIST.split(',') // 假设参数为逗号分隔的阶段名，如"one,three"

node {
    stage('Prepare') {
        echo "要执行的阶段：${myStages}"
    }
    
    myStages.each { stageName ->
        stage(stageName) {
            // 根据阶段名执行对应逻辑，判断是否存在有效步骤
            switch(stageName) {
                case 'one':
                    echo '执行阶段one的步骤'
                    break
                case 'two':
                    echo '执行阶段two的步骤'
                    break
                case 'three':
                    echo '执行阶段three的步骤'
                    break
                default:
                    echo "未知阶段${stageName}，跳过执行"
            }
        }
    }
}

方案2：声明式流水线中嵌入脚本块实现动态阶段 #

如果想保留声明式流水线的结构（如agent、post等特性），可在stages内使用script块结合循环生成动态阶段：

pipeline {
    agent any
    parameters {
        string(name: 'STAGE_LIST', defaultValue: 'one,three', description: '要执行的阶段，逗号分隔')
    }
    
    stages {
        stage('Dynamic Stages') {
            steps {
                script {
                    def myStages = params.STAGE_LIST.split(',')
                    
                    myStages.each { stageName ->
                        stage(stageName) {
                            // 根据阶段名匹配对应逻辑
                            if (stageName == 'one') {
                                echo '执行one阶段'
                            } else if (stageName == 'two') {
                                echo '执行two阶段'
                            } else if (stageName == 'three') {
                                echo '执行three阶段'
                            } else {
                                echo "跳过不存在的阶段：${stageName}"
                            }
                        }
                    }
                }
            }
        }
    }
}

补充优化：精准判断阶段存在性 #

可提前定义包含所有可用阶段及对应逻辑的映射，再根据输入列表过滤出存在的阶段执行：

def availableStages = [
    'one': { echo 'one的步骤' },
    'two': { echo 'two的步骤' },
    'three': { echo 'three的步骤' }
]

// 过滤出系统中存在的阶段
def targetStages = myStages.findAll { availableStages.containsKey(it) }

targetStages.each { stageName ->
    stage(stageName) {
        availableStages[stageName].call()
    }
}

内容的提问来源于stack exchange，提问作者StoneThrow