bash中的动态变量名称

Question

我对狂欢脚本感到困惑。

我有以下代码：

function grep_search() {
    magic_way_to_define_magic_variable_$1=`ls | tail -1`
    echo $magic_variable_$1
}

我希望能够创建一个包含命令的第一个参数的变量名称，并具有 ls 的最后一行的值。

因此，为了说明我想要的东西：

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

那么，我应该如何定义/声明 $ magic_way_to_define_magic_variable_ $ 1 ，我应该如何在脚本中称呼它？

我尝试过 eval ， $ {...} ， \ $$ {...} ，但我仍然很困惑。

Answer 1

我最近一直在寻找更好的方法。对我来说，联想阵列听起来像是过度杀伤。看看我发现的内容：

suffix=bzz
declare prefix_$suffix=mystr

...然后...

varname=prefix_$suffix
echo ${!varname}

从 docs ：

“ $”字符引入参数扩展，命令替代或算术扩展。 ...

参数扩展的基本形式为$ {参数}。参数的值被取代。 ...

如果参数的第一个字符是感叹点（！），而参数不是nameref，则会引入一个间接级别。 Bash使用通过将其余参数作为新参数形成的值；然后将其扩展，并在其余的扩展中使用该值，而不是原始参数的扩展。这被称为间接扩展。该值受Tilde扩展，参数扩展，命令替代和算术扩展的约束。 ...

Answer 2

使用具有命令名称的关联数组。

# Requires bash 4, though
declare -A magic_variable=()

function grep_search() {
    magic_variable[$1]=$( ls | tail -1 )
    echo ${magic_variable[$1]}
}

如果您不能使用关联阵列（例如，必须支持 bash 3），则可以使用声明来创建动态变量名称：

declare "magic_variable_$1=$(ls | tail -1)"

并使用间接参数扩展来访问价值。

var="magic_variable_$1"
echo "${!var}"

请参阅Bashfaq：间接 - 评估间接/参考变量。

Answer 3

除了关联阵列外，还有几种方法可以实现bash中的动态变量。请注意，所有这些技术都呈现出风险，在本答案结束时进行了讨论。

在以下示例中，我将假设 i = 37 ，并且您想别名名为 var_37 的变量，其初始值为 lolilol 。

方法1。使用“指针”变量，

您可以简单地将变量的名称存储在间接变量中，与C指针不同。然后，bash具有读取的语法 aleased变量： $ {！name} 扩展到该变量的值，其名称是变量 name name name name < /代码>。您可以将其视为两个阶段的扩展： $ {！name} 将扩展到 $ var_37 ，它扩展到 lolilol 。

name="var_$i"
echo "$name"         # outputs “var_37”
echo "${!name}"      # outputs “lolilol”
echo "${!name%lol}"  # outputs “loli”
# etc.

不幸的是，修改的同类变量没有对应语法。相反，您可以使用以下技巧之一来实现作业。

1a。用 eval eval 分配

是邪恶的，但也是实现我们目标的最简单，最便携的方法。您必须小心地逃脱分配的右侧，因为它将两次评估。这样做的一种简单而系统的方法是事先评估右侧（或使用 printf％q ）。

和您应该手动检查左侧是有效的变量名称，或带有索引的名称（如果是 Ever> Evil_code＃？）。相比之下，下面的所有其他方法都会自动执行它。

# check that name is a valid variable name:
# note: this code does not support variable_name[index]
shopt -s globasciiranges
[[ "$name" == [a-zA-Z_]*([a-zA-Z_0-9]) ]] || exit

value='babibab'
eval "$name"='$value'  # carefully escape the right-hand side!
echo "$var_37"  # outputs “babibab”

缺点：

• 不检查变量名称的有效性。
• 评估是邪恶的。
• eval 是邪恶的。
• eval 是邪恶的。

1b。用读取

读取内置的允许您将值分配给您提供名称的变量，这一事实可以与此处串触相结合：

IFS= read -r -d '' "$name" <<< 'babibab'
echo "$var_37"  # outputs “babibab\n”

ifs part和选项 -r 确保将值分配给AS-IS，而选项 -d''允许分配多行值。由于最后一个选项，命令使用非零退出代码返回。

请注意，由于我们正在使用此处的弦，因此 newline字符附加到值。

despsides：

• 有些晦涩；
• 使用非零退出代码返回；
• 将新线附加到该值。

1C。用 printf 分配

自Bash 3.1（发布2005年）， printf 内置也可以将其结果分配给给出名称的变量。与以前的解决方案相反，它只是有效的，不需要额外的努力来逃脱事物，以防止分裂等。

printf -v "$name" '%s' 'babibab'
echo "$var_37"  # outputs “babibab”

弊端：

• 便携式（但是，很好）。

方法2。自Bash 4.3（发布2014年发布）以来，使用“参考”变量

， neclare indentin具有一个选项 -n 用于创建一个变量，该变量是“名称参考”到另一个变量，就像C ++引用一样。就像方法1中一样，参考将其名称存储在别名变量的名称中，但是每次访问参考（用于读取或分配）时，BASH都会自动解决间接。

此外，BASH具有一种特殊且非常令人困惑的语法，以获取参考本身的价值，请自己判断： $ {！ref} 。

declare -n ref="var_$i"
echo "${!ref}"  # outputs “var_37”
echo "$ref"     # outputs “lolilol”
ref='babibab'
echo "$var_37"  # outputs “babibab”

这并不能避免下面解释的陷阱，但至少它使语法直接。

缺点：

• 不携带。

风险

所有这些混叠技术都带来了几种风险。第一个是每次解决间接时执行任意代码（用于阅读或分配）。实际上，您也可以像 var_37 那样而不是标量变量名称，也可以像 arr [42] 一样别名。但是Bash每次需要评估方括号的内容，因此Aliasing arr [$（do_evil）] 将产生意想不到的效果……因此，仅在控制时使用这些技术别名的出处。

function guillemots {
  declare -n var="$1"
  var="«${var}»"
}

arr=( aaa bbb ccc )
guillemots 'arr[1]'  # modifies the second cell of the array, as expected
guillemots 'arr[$(date>>date.out)1]'  # writes twice into date.out
            # (once when expanding var, once when assigning to it)

第二种风险是创建一个环状别名。由于狂欢变量是通过其名称而不是通过其范围来标识的，因此您可以无意间为自己创建一个别名（同时认为它会从封闭范围中吸用变量）。使用通用变量名称时，这可能会特别发生（例如 var ）。结果，才能在控制别名变量的名称的名称时使用这些技术。

function guillemots {
  # var is intended to be local to the function,
  # aliasing a variable which comes from outside
  declare -n var="$1"
  var="«${var}»"
}

var='lolilol'
guillemots var  # Bash warnings: “var: circular name reference”
echo "$var"     # outputs anything!

Source:

• BashFaq/006: How can I use variable variables (indirect variables, pointers,引用）还是关联数组？
• bashfaq/048：eval and命令和安全问题

Answer 4

下面的示例返回$ name_of_var的值

var=name_of_var
echo $(eval echo "\$var")

Answer 5

使用声明

不需要在其他答案上使用前缀，也不需要。仅使用 声明 ，双引号和参数扩展。

我经常使用以下技巧解析参数列表conaning n to n 格式为 key = key = value eleseke equale = etherkeque et eett et eett et et et etceet = etc ，例如：

# brace expansion just to exemplify
for variable in {one=foo,two=bar,ninja=tip}
do
  declare "${variable%=*}=${variable#*=}"
done
echo $one $two $ninja 
# foo bar tip

一样扩展argv列表

for v in "$@"; do declare "${v%=*}=${v#*=}"; done

---

但是：但是像额外 尖端

# parse argv's leading key=value parameters
for v in "$@"; do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
done
# consume argv's leading key=value parameters
while test $# -gt 0; do
  case "$1" in ?*=?*) declare "${1%=*}=${1#*=}";; *) break;; esac
  shift
done

Answer 6

在这里将两个高度评价的答案结合到一个完整的示例中，希望有用且不言而喻：

#!/bin/bash

intro="You know what,"
pet1="cat"
pet2="chicken"
pet3="cow"
pet4="dog"
pet5="pig"

# Setting and reading dynamic variables
for i in {1..5}; do
        pet="pet$i"
        declare "sentence$i=$intro I have a pet ${!pet} at home"
done

# Just reading dynamic variables
for i in {1..5}; do
        sentence="sentence$i"
        echo "${!sentence}"
done

echo
echo "Again, but reading regular variables:"
echo $sentence1
echo $sentence2
echo $sentence3
echo $sentence4
echo $sentence5

输出：

您知道，我在家中有一只宠物猫
你知道吗，我在家里有一只宠物鸡
你知道吗，我在家有宠物母牛
你知道吗，我在家有宠物狗
你知道吗，我又在家有一只宠物猪

，但是阅读常规变量：
你知道吗，我在家里有一只宠物猫
你知道吗，我在家里有一只宠物鸡
你知道吗，我在家有宠物母牛
你知道吗，我在家有宠物狗
你知道吗，我在家有宠物猪

Answer 7

这也会起作用

my_country_code="green"
x="country"

eval z='
在您的情况下，
eval final_val='
my_"$x"_code
echo $z                 ## o/p: green

在您的情况下，

magic_way_to_define_magic_variable_"$1"
echo $final_val

my_"$x"_code echo $z ## o/p: green

在您的情况下，

Answer 8

对于ZSH（Newers Mac OS版本），您应该使用

real_var="holaaaa"
aux_var="real_var"
echo ${(P)aux_var}
holaaaa

代替“！”

Answer 9

这应该有效：

function grep_search() {
    declare magic_variable_$1="$(ls | tail -1)"
    echo "$(tmpvar=magic_variable_$1 && echo ${!tmpvar})"
}
grep_search var  # calling grep_search with argument "var"

Answer 10

按 bashfaq/bashfaq/006 > with 在这里字符串语法用于分配间接变量：

function grep_search() {
  read "$1" <<<$(ls | tail -1);
}

用法：usage：usage：usage：usage： usage：usage：

$ grep_search open_box
$ echo $open_box
stack-overflow.txt

Answer 11

不依赖于您拥有的shell/bash版本的额外方法是使用 envsubst 。例如：

newvar=$(echo '$magic_variable_'"${dynamic_part}" | envsubst)

Answer 12

即使这是一个古老的问题，我仍然很难找到动态变量名称，同时避免了 eval （evil）命令。

用 nectrare -n 求解它，该创建了对动态值的引用，这在CI/CD进程中特别有用，在CI/CD过程中，CI/CD服务的所需秘密名称直到运行时才知道。以下是：

# Bash v4.3+
# -----------------------------------------------------------
# Secerts in CI/CD service, injected as environment variables
# AWS_ACCESS_KEY_ID_DEV, AWS_SECRET_ACCESS_KEY_DEV
# AWS_ACCESS_KEY_ID_STG, AWS_SECRET_ACCESS_KEY_STG
# -----------------------------------------------------------
# Environment variables injected by CI/CD service
# BRANCH_NAME="DEV"
# -----------------------------------------------------------
declare -n _AWS_ACCESS_KEY_ID_REF=AWS_ACCESS_KEY_ID_${BRANCH_NAME}
declare -n _AWS_SECRET_ACCESS_KEY_REF=AWS_SECRET_ACCESS_KEY_${BRANCH_NAME}

export AWS_ACCESS_KEY_ID=${_AWS_ACCESS_KEY_ID_REF}
export AWS_SECRET_ACCESS_KEY=${_AWS_SECRET_ACCESS_KEY_REF}

echo $AWS_ACCESS_KEY_ID $AWS_SECRET_ACCESS_KEY
aws s3 ls

Answer 13

亲吻方法：

a=1
c="bam"
let "$c$a"=4
echo $bam1

结果4

Answer 14

哇，大多数语法都是可怕的！这是一个具有一些简单语法的解决方案，如果您需要间接参考数组：

#!/bin/bash

foo_1=(fff ddd) ;
foo_2=(ggg ccc) ;

for i in 1 2 ;
do
    eval mine=( \${foo_$i[@]} ) ;
    echo ${mine[@]}" " ;
done ;

对于更简单的用例，我建议您建议语法在高级bash-scripting指南中描述的语法 。

Answer 15

我希望能够创建一个包含命令的第一个参数

的变量名称

script.sh.sh 文件的第一个参数的变量名称：

#!/usr/bin/env bash
function grep_search() {
  eval $1=$(ls | tail -1)
}

test：

$ source script.sh
$ grep_search open_box
$ echo $open_box
script.sh

---

per help> help> help eval eval ：

执行参数为shell命令。

---

您也可以使用Bash $ {！var} 间接扩展，但是它不支持检索数组索引。

---

有关进一步的阅读或示例，请检查 bashfaq/006关于indirection 。

我们不知道没有任何技巧可以在没有 eval eval 的情况下复制Posix或Bourne shell中的该功能，这可能很难安全。因此，将其视为您自己的风险hack 。

但是，您应该根据以下说明重新考虑使用间接方向。

通常，在bash脚本中，您根本不需要间接参考。通常，当人们不了解或不了解狂欢数组或不完全考虑其他bash功能（例如函数）时，人们就将其视为解决方案。

将变量名称或任何其他bash语法在内部参数中经常错误地进行，并且在不适当的情况下以解决具有更好解决方案的问题。它违反了代码和数据之间的分离，因此使您陷入了针对错误和安全问题的滑坡。间接方向可以使您的代码不那么透明，更难遵循。

Answer 16

虽然我认为声明-n 仍然是最好的方法，但没有人提到的另一种方式，在CI/CD中非常有用，

function dynamic(){
  export a_$1="bla"
}

dynamic 2
echo $a_2

此功能将不支持空格，因此 Dynamic“ 2 3” 将返回错误。

Answer 17

对于索引数组，您可以像这样引用它们：

foo=(a b c)
bar=(d e f)

for arr_var in 'foo' 'bar'; do
    declare -a 'arr=("${'"$arr_var"'[@]}")'
    # do something with $arr
    echo "\$arr_var contains:"
    for char in "${arr[@]}"; do
        echo "$char"
    done
done

可以类似地引用关联数组，但需要 -A switch On neclare 而不是 -A 。

Answer 18

此解决方案的POSIX合规答案

您需要将R/W权限具有/tmp 文件夹。
我们创建一个保存我们的变量的临时文件，并利用 -A set> set 内置的标志：

$男人集
...
-a 给出了所创建或修改的每个变量或函数的导出属性，并标记为导出到后续命令的环境。

因此，如果我们创建一个保留动态变量的文件，我们可以使用设置将它们在脚本中栩栩如生。

实施

#!/bin/sh
# Give the temp file a unique name so you don't mess with any other files in there
ENV_FILE="/tmp/$(date +%s)"

MY_KEY=foo
MY_VALUE=bar

echo "$MY_KEY=$MY_VALUE" >> "$ENV_FILE"

# Now that our env file is created and populated, we can use "set"
set -a; . "$ENV_FILE"; set +a
rm "$ENV_FILE"
echo "$foo"

# Output is "bar" (without quotes)

解释了上述步骤：

# Enables the -a behavior
set -a

# Sources the env file
. "$ENV_FILE"

# Disables the -a behavior
set +a

Answer 19

小心：我刚刚发现这项工作非常不同 - 在 zsh 中不起作用。因此，请确保您在外壳中的意思是您要参加；或将出于脚本的最终执行上下文。

Answer 20

对于 varname = $ prefix_suffix 格式，只需使用：

varname=${prefix}_suffix