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數據結構，這使您可以保存集合並訪問集合中的特定元素。

列表允許您保存特定的值（唯一或不唯一）。 Set可讓您保留特定值（所有值都是唯一的）。 Map允許您具有Key, Value對（鍵必須是唯一的）。

在此處閱讀更多內容常規列表 常規地圖

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;

}