【问题标题】：How to iterate over multiple variables and echo them using Shell Script?如何迭代多个变量并使用 Shell 脚本回显它们？
【发布时间】：2021-10-07 14:28:45
【问题描述】：

考虑以下变量，这些变量是动态的并且每次都可能发生变化。有时甚至可能有5个变量，但所有变量的长度每次都是一样的。

var1='a b c d e... upto z'
var2='1 2 3 4 5... upto 26'
var3='I II III IV V... upto XXVI'

我正在寻找一种通用方法来迭代 for 循环中的变量 & 我想要的输出应该如下所示。

a,1,I
b,2,II
c,3,III
d,4,IV
e,5,V
.
.
goes on upto
z,26,XXVI

如果我使用嵌套循环，那么我会得到所有可能的组合，这不是预期的结果。

另外，我知道如何使用 for 循环和使用下面的链接转移 2 个变量 https://unix.stackexchange.com/questions/390283/how-to-iterate-two-variables-in-a-sh-script

【问题讨论】：

在 POSIX shell 中确实没有什么好的方法可以做到这一点。在支持数组的 shell 中，您可以创建 3 个单独的数组并遍历索引。如果您需要这种“压缩”行为，您可能应该考虑使用不同的语言（具有良好的数据结构支持）。
字段是否用空格分隔？如果是，您可以将这些值分配给 bash 索引数组 (var1=( a b c d e...z )) 并在索引上使用循环。看看this other question也许吧。
这能回答你的问题吗？ The ever changing variable
@AndrejPodzimek：不，与我的要求相比，这太复杂了。粘贴选项为我做了。感谢您的回复！
@AdarshR 确实，paste 很好地解决了这个问题，但我认为 Bash 中的“nameref”解决方案也有它的特点——特别是，它更容易扩展到任意数量的变量（并且每个变量只需要一个命令行标记）。我已经 added an answer 表明了我的意思。

标签： bash shell for-loop unix echo

【解决方案1】：

与paste

paste -d , <(tr ' ' '\n' <<<"$var1") <(tr ' ' '\n' <<<"$var2") <(tr ' ' '\n' <<<"$var3")

a,1,I
b,2,II
c,3,III
d,4,IV
e...z,5...26,V...XXVI

但显然必须为更多 varN 添加其他参数替换是不可扩展的。

【讨论】：

非常感谢。这真的很简单，就像一个魅力！

【解决方案2】：

您需要一次“压缩”两个变量。

var1='a b c d e...z'
var2='1 2 3 4 5...26'
var3='I II III IV V...XXVI'

zip_var1_var2 () {
    set $var1
    for v2 in $var2; do
        echo "$1,$v2"
        shift
    done
}

zip_var12_var3 () {
    set $(zip_var1_var2)
    for v3 in $var3; do
        echo "$1,$v3"
        shift
    done
}

for x in $(zip_var12_var3); do
  echo "$x"
done

如果你愿意使用eval 并且确定这样做是安全的，你可以编写一个类似的函数

zip () {
    if [ $# -eq 1 ]; then
        eval echo \$$1
        return
    fi

    a1=$1
    shift
    x=$*

    set $(eval echo \$$a1)
    for v in $(zip $x); do
        printf '=== %s\n' "$1,$v" >&2
        echo "$1,$v"
        shift
    done
}

zip var1 var2 var3  # Note the arguments are the *names* of the variables to zip

如果可以使用数组，那么（例如bash）

var1=(a b c d e)
var2=(1 2 3 4 5)
var3=(I II III IV V)

for i in "${!var1[@]}"; do
    printf '%s,%s,%s\n' "${var1[i]}" "${var2[i]}" "${var3[i]}"
done

【讨论】：

我尝试实现数组选项，但没有成功。我可能遗漏了一些东西，或者我们可能正在使用 POSIX shell。无论如何，非常感谢您的回复。非常感谢！

【解决方案3】：

使用这个 Perl 单行代码：

perl -le '@in = map { [split] } @ARGV; for $i ( 0..$#{ $in[0] } ) { print join ",", map { $in[$_][$i] } 0..$#in; }' "$var1" "$var2" "$var3"

打印：

a,1,I
b,2,II
c,3,III
d,4,IV
e,5,V
z,26,XXVI

Perl 单行器使用这些命令行标志：
-e：告诉 Perl 查找内联代码，而不是在文件中。
-l：去除输入行分隔符 ( "\n" on *NIX 默认情况下）在内联执行代码之前，并在打印时附加它。

输入变量必须用“like so”双引号引起来，以防止空格分隔的单词被视为单独的参数。
@ARGV 是命令行参数的数组，此处为$var1 , $var2, $var3.
@in 是一个由 3 个元素组成的数组，每个元素都是对一个数组的引用，该数组是通过在空格上拆分 @ARGV 的相应元素而获得的。请注意，split 默认情况下会在空格上拆分字符串，但您可以指定不同的分隔符，它接受正则表达式。
随后的for 循环打印@in 元素，用逗号分隔。

另请参阅：
perldoc perlrun: how to execute the Perl interpreter: command line switches
perldoc perlvar: Perl predefined variables

【讨论】：

【解决方案4】：

以下内容（几乎）是of this answer 的副本，经过一些调整使其适合这个问题。

原始问题

首先让我们分配一些变量来玩，每个变量中有 26 个标记：

var1="$(echo {a..z})"
var2="$(echo {1..26})"
var3="$(echo I II III IV \
             V{,I,II,III} IX \
             X{,I,II,III} XIV \
             XV{,I,II,III} XIX \
             XX{,I,II,III} XXIV \
             XXV XXVI)"
var4="$(echo {A..Z})"
var5="$(echo {010101..262626..10101})"

现在我们想要一个压缩任意数量变量的“神奇”函数，最好是在纯 Bash 中：

zip_vars var1       # a trivial test
zip_vars var{1..2}  # a slightly less trivial test
zip_vars var{1..3}  # the original question
zip_vars var{1..4}  # more vars, becasuse we can
zip_vars var{1..5}  # more vars, because why not

zip_vars 会是什么样子？这是纯 Bash 中的一个，没有任何外部命令：

zip_vars() {
  local var
  for var in "$@"; do
    local -a "array_${var}"
    local -n array_ref="array_${var}"
    array_ref=(${!var})
    local -ar "array_${var}"
  done
  local -n array_ref="array_${1}"
  local -ir size="${#array_ref[@]}"
  local -i i
  local output
  for ((i = 0; i < size; ++i)); do
    output=
    for var in "$@"; do
      local -n array_ref="array_${var}"
      output+=",${array_ref[i]}"
    done
    printf '%s\n' "${output:1}"
  done
}

它是如何工作的：

它将所有变量（通过引用（通过变量名）传递）拆分为数组。对于每个变量varX，它会创建一个本地数组array_varX。
- 如果输入变量一开始就已经是 Bash 数组（见下文），实际上会更容易，但是……我们最初坚持原来的问题。
它确定第一个数组的size，然后盲目地期望所有数组都属于那个size。
对于从0 到size - 1 的每个索引i，它连接所有数组的ith 元素，由, 分隔。

数组让事情变得更简单

如果你从一开始就使用 Bash 数组，脚本会更短，看起来更简单，并且不会有任何字符串到数组的转换。

zip_arrays() {
  local -n array_ref="$1"
  local -ir size="${#array_ref[@]}"
  local -i i
  local output
  for ((i = 0; i < size; ++i)); do
    output=
    for arr in "$@"; do
      local -n array_ref="$arr"
      output+=",${array_ref[i]}"
    done
    printf '%s\n' "${output:1}"
  done
}

arr1=({a..z})
arr2=({1..26})
arr3=(    I II III    IV
       V{,I,II,III}   IX
       X{,I,II,III}  XIV
      XV{,I,II,III}  XIX
      XX{,I,II,III} XXIV
                    XXV
                    XXVI)
arr4=({A..Z})
arr5=({010101..262626..10101})

zip_arrays arr1       # a trivial test
zip_arrays arr{1..2}  # a slightly less trivial test
zip_arrays arr{1..3}  # (almost) the original question
zip_arrays arr{1..4}  # more arrays, becasuse we can
zip_arrays arr{1..5}  # more arrays, because why not

【讨论】：