Groovy - 定义变量，其中变量名称由另一个变量传递

Question

我想在 groovy 中定义一个变量，其中变量名由另一个变量传递。

类似的东西。

def runExtFunc(varName){
    def varName  // => def abc
    varName = load 'someFile.groovy'   // abc = load 'someFile.groovy'

    varName."$varName"() // -> abc.abc() (run function defined in File)
}

    [...]
runExtFunc('abc')  // -> abc.abc() (Function abc defined in File)
    [...]
runExtFunc('xyz')  // -> xyz.xyz() (Function xyz defined in File)
    [...]

遗憾的是 def varName 定义了变量 varName 而不是 abc。当我调用 runExtFunc 两次时，由于 varName 已定义而发生错误。

我也试过了

def runExtFunc(varName){
    def "${varName}"  // => def abc
       [...]
    "${varName}" =  load 'someFile.groovy'
       [...]
}

这也不起作用。

有什么建议吗？

Answer 1

这是错误的方法。通常您会使用 List、Map 或 Set 数据结构，它们允许您保存集合并访问集合中的特定元素。

List 允许您保存特定值（唯一或非唯一）。 Set 允许您保存特定的值（所有值都是唯一的）。 Map 允许您拥有Key, Value 对（密钥必须是唯一的）。

在这里阅读更多 groovy list, groovy map

Answer 2

试试这个（如果我理解正确的话）：

def dummyFunc(varName) {
  new GroovyShell(this.binding).evaluate("${varName}")
}

dummyFunc('abc')

abc = "Hello there"
println abc

打印

Hello there

Answer 3

看这里 https://godless-internets.org/2020/02/14/extracting-jenkins-credentials-for-use-in-another-place/

secret_var="SECRET_VALUE_${secret_index}" aws ssm put-parameter --name ${param_arn} --type "SecureString" --value ${!secret_var} --region us-east-2 --overwrite

Answer 4

我在这里输入一个我们已经完成的代码示例。

请随时发表评论。

http://groovy-lang.org/syntax.html https://godless-internets.org/2020/02/14/extracting-jenkins-credentials-for-use-in-another-place/

def int fileContentReplaceDynamic(String filePathVar, String envTail = "", 
String [] keysToIgnore = new String[0]){

def filePath = readFile filePathVar
def lines = filePath.readLines()

//def regex = ~/\b__\w*\b/
String regex = "__(.*?)__"
ArrayList credentialsList = new ArrayList();
ArrayList<String> keysToIgnoreList = new ArrayList<String>(Arrays.asList(keysToIgnore));

for (line in lines){
    Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE)
    Matcher matcher = pattern.matcher(line)

    while (matcher.find()){
        String credKeyName = matcher.group().replaceAll("__","")
        if ((! credentialsList.contains(credKeyName)) && 
            (! keysToIgnoreList.contains(credKeyName))) {
            credentialsList.add(credKeyName)
        } else {
            log.info("Credencial ignorada o ya incluida: ${credKeyName}")
        }
    }       
}


if(credentialsList.size() <= 0){
    log.info("No hay variables para aplicar transformada")
    return 0
}

log.info("Numero de credenciales encontradas a sustituir: " + credentialsList.size())
String credentialsListString = String.join(", ", credentialsList);
log.info("Credenciales: " + credentialsListString)

def credsRequest = null
for(def credKeyName in credentialsList){
    // Retrieve the values of the variables by environment tail name.
    String credKeyNameByEnv = "${credKeyName}";
    if ((envTail != null) && (! envTail.trim().isEmpty())) {
        credKeyNameByEnv = credKeyNameByEnv + "-" + envTail.trim().toUpperCase();
    }
    
    // Now define the name of the variable we'll use
    // List<org.jenkinsci.plugins.credentialsbinding.MultiBinding>
    // Tip: java.lang.ClassCastException: 
    // org.jenkinsci.plugins.credentialsbinding.impl.BindingStep.bindings 
    // expects class org.jenkinsci.plugins.credentialsbinding.MultiBinding
    String varName = "var_${credKeyNameByEnv}"
    if (credsRequest == null) {
        // Initialize
        credsRequest = [string(credentialsId: "${credKeyNameByEnv}", variable: "${varName}")]
    } else {
        // Add element
        credsRequest << string(credentialsId: "${credKeyNameByEnv}", variable: "${varName}")
    }
}

int credsProcessed = 0
def passwordsRequest = null
StringBuilder sedReplacements = new StringBuilder();

// Now ask jenkins to fill in all variables with values
withCredentials(credsRequest) {
    for(def credKeyName in credentialsList){
        String credKeyVar = "var_${credKeyName}"
        log.info("Replacing value for credential ${credKeyName} stored in ${credKeyVar}")
        
        String credKeyValueIn = "${!credKeyVar}"
        String credKeyValue = null;
        if ("empty_string_value".equals(credKeyValueIn.trim())) {
            credKeyValue = "";
        } else {
            credKeyValue = credKeyValueIn.replaceAll(/(!|"|@|#|\$|%|&|\/|\(|\)|=|\?)/, /\\$0/)
        }
        
        if (passwordsRequest == null) {
            // Initialize
            passwordsRequest = [[password: "${credKeyValue}" ]]
        } else {
            // Add element
            passwordsRequest << [password: "${credKeyValue}" ]
        }
        
        sedReplacements.append("s/__${credKeyName}__/${credKeyValue}/; ")
        
        credsProcessed++
    }
}

wrap([$class: "MaskPasswordsBuildWrapper", varPasswordPairs: passwordsRequest ]){
    
    String sedReplacementsString = sedReplacements.toString().trim();
    if (sedReplacementsString.endsWith(";")) {
        sedReplacementsString = sedReplacementsString.substring(0, sedReplacementsString.length() -1);
        sedReplacementsString = sedReplacementsString + "g;"
    }
    
    sh """sed -i "${sedReplacementsString}" ${filePathVar}"""
}

log.info("Finaliza la transformada. Transformados: ${credsProcessed}/${credentialsList.size()} ")

if (credsProcessed != credentialsList.size()) {
    log.info("Hay credenciales que no se han podido encontrar en el vault de Jenkins.")
    log.info("Si estas guardando cadenas vacias en credenciales, guarda en su lugar el valor 'empty_string_value'.");
    return -1
}
return 0;
}