Bash 中的多维数组

Question

我正在计划一个脚本来管理我的 Linux 系统的某些部分，并且正在决定是使用 bash 还是 python。

我更喜欢将其作为 Bash 脚本执行，因为命令更简单，但真正的决定因素是配置。我需要能够在配置文件中存储一个多维数组来告诉脚本如何处理自己。使用 bash 在配置文件中存储简单的 key=value 对很容易，但我能想到的唯一方法是做一个多维数组是一个两层解析引擎，比如

array=&d1|v1;v2;v3&d2|v1;v2;v3

但是 marshall/unmarshall 代码可能会变成熊，对于下一个必须管理它的可怜的 sap 来说，它远非用户友好。如果我不能在 bash 中轻松做到这一点，我只需将配置写入 xml 文件并在 python 中编写脚本。

在 bash 中有没有简单的方法来做到这一点？

谢谢大家。

Answer 1

Bash 不支持多维数组，也不支持散列，而且您似乎想要一个值是数组的散列。这个解决方案不是很漂亮，有xml文件的解决方案应该更好：

array=('d1=(v1 v2 v3)' 'd2=(v1 v2 v3)')
for elt in "${array[@]}";do eval $elt;done
echo "d1 ${#d1[@]} ${d1[@]}"
echo "d2 ${#d2[@]} ${d2[@]}"

编辑：这个答案已经很老了，因为 bash 4 支持哈希表，另请参阅 this answer 了解没有 eval 的解决方案。

Answer 2

Bash 没有多维数组。但是您可以使用关联数组来模拟类似的效果。下面是一个关联数组伪装成多维数组的例子：

declare -A arr
arr[0,0]=0
arr[0,1]=1
arr[1,0]=2
arr[1,1]=3
echo "${arr[0,0]} ${arr[0,1]}" # will print 0 1

如果您不将数组声明为关联数组（使用-A），上述方法将不起作用。例如，如果省略declare -A arr 行，echo 将打印2 3 而不是0 1，因为0,0、1,0 等将被视为算术表达式并计算为0 (逗号运算符右侧的值）。

Answer 3

这要归功于 1. “间接扩展” ！它增加了一层间接性，以及 2.“子字符串扩展”，它与数组的行为不同，可用于“切片”它们，如 https://stackoverflow.com/a/1336245/317623

所述

# Define each array and then add it to the main one
SUB_0=("name0" "value 0")
SUB_1=("name1" "value;1")
MAIN_ARRAY=(
  SUB_0[@]
  SUB_1[@]
)

# Loop and print it.  Using offset and length to extract values
COUNT=${#MAIN_ARRAY[@]}
for ((i=0; i<$COUNT; i++))
do
  NAME=${!MAIN_ARRAY[i]:0:1}
  VALUE=${!MAIN_ARRAY[i]:1:1}
  echo "NAME ${NAME}"
  echo "VALUE ${VALUE}"
done

它基于this answer here

Answer 4

如果您想使用 bash 脚本并使其易于阅读，建议将数据放入结构化 JSON 中，然后在 bash 命令中使用 lightweight tool jq 来遍历数组。例如以下数据集：

[

    {"specialId":"123",
    "specialName":"First"},

    {"specialId":"456",
    "specialName":"Second"},

    {"specialId":"789",
    "specialName":"Third"}
]

您可以像这样使用 bash 脚本和 jq 遍历这些数据：

function loopOverArray(){

    jq -c '.[]' testing.json | while read i; do
        # Do stuff here
        echo "$i"
    done
}

loopOverArray

输出：

{"specialId":"123","specialName":"First"}
{"specialId":"456","specialName":"Second"}
{"specialId":"789","specialName":"Third"}

Answer 5

独立于所使用的外壳（sh、ksh、bash、...），以下方法非常适用于 n 维数组（示例涵盖二维数组）。

在示例中，行分隔符（第一维）是空格字符。为了引入字段分隔符（第二维），使用标准 unix 工具 tr。附加维度的附加分隔符可以以相同的方式使用。

当然这种方法的性能不是很好，但是如果性能不是一个标准，这种方法是相当通用的，可以解决很多问题：

array2d="1.1:1.2:1.3 2.1:2.2 3.1:3.2:3.3:3.4"

function process2ndDimension {
    for dimension2 in $*
    do
        echo -n $dimension2 "   "
    done
    echo
}

function process1stDimension {
    for dimension1 in $array2d
    do
        process2ndDimension `echo $dimension1 | tr : " "`
    done
}

process1stDimension

该样本的输出如下所示：

1.1     1.2     1.3     
2.1     2.2     
3.1     3.2     3.3     3.4 

Answer 6

经过大量试验和错误，我实际上发现 bash 上最好、最清晰和最简单的多维数组是使用常规 var。是的。

优点：你不必遍历一个大数组，你可以直接回显 "$var" 并使用 grep/awk/sed。它简单明了，您可以拥有任意数量的列。

例子：

$ var=$(echo -e 'kris hansen oslo\nthomas jonson peru\nbibi abu johnsonville\njohnny lipp peru')

$ echo "$var"
kris hansen oslo
thomas johnson peru
bibi abu johnsonville
johnny lipp peru

如果你想找到秘鲁的每一个人

$ echo "$var" | grep peru
thomas johnson peru
johnny lipp peru

仅在第三个字段中使用 grep(sed)

$ echo "$var" | sed -n -E '/(.+) (.+) peru/p'
thomas johnson peru
johnny lipp peru

如果你只想要 x 字段

$ echo "$var" | awk '{print $2}'
hansen
johnson
abu
johnny

秘鲁每个叫 thomas 的人都返回他的姓氏

$ echo "$var" |grep peru|grep thomas|awk '{print $2}'
johnson

任何你能想到的查询...超级简单。

要更改项目：

$ var=$(echo "$var"|sed "s/thomas/pete/")

删除包含“x”的行

$ var=$(echo "$var"|sed "/thomas/d")

根据另一个项目的值更改同一行中的另一个字段

$ var=$(echo "$var"|sed -E "s/(thomas) (.+) (.+)/\1 test \3/")
$ echo "$var"
kris hansen oslo                                                                                                                                             
thomas test peru                                                                                                                                          
bibi abu johnsonville
johnny lipp peru

当然循环也可以，如果你想这样做

$ for i in "$var"; do echo "$i"; done
kris hansen oslo
thomas jonson peru
bibi abu johnsonville
johnny lipp peru

我发现的唯一问题是你必须总是引用 var(在示例中；var 和 i) 或者事情看起来像这样

$ for i in "$var"; do echo $i; done
kris hansen oslo thomas jonson peru bibi abu johnsonville johnny lipp peru

毫无疑问，有人会说如果您的输入中有空格，这将不起作用，但是可以通过在输入中使用另一个分隔符来解决此问题，例如（现在使用 utf8 字符来强调您可以选择输入的内容不会包含，但你可以选择任何ofc）：

$ var=$(echo -e 'field one☥field two hello☥field three yes moin\nfield 1☥field 2☥field 3 dsdds aq')

$ for i in "$var"; do echo "$i"; done
field one☥field two hello☥field three yes moin
field 1☥field 2☥field 3 dsdds aq

$ echo "$var" | awk -F '☥' '{print $3}'
field three yes moin
field 3 dsdds aq

$ var=$(echo "$var"|sed -E "s/(field one)☥(.+)☥(.+)/\1☥test☥\3/")
$ echo "$var"
field one☥test☥field three yes moin
field 1☥field 2☥field 3 dsdds aq

如果您想在输入中存储换行符，您可以在输入之前将换行符转换为其他内容，然后在输出中再次将其转换回（或者不要使用 bash...）。尽情享受吧！

Answer 7

我发布以下内容是因为它是一种非常简单明了的方式来模拟（至少在某种程度上）Bash 中二维数组的行为。它使用一个 here-file（参见 Bash 手册）和 read（一个 Bash 内置命令）：

## Store the "two-dimensional data" in a file ($$ is just the process ID of the shell, to make sure the filename is unique)
cat > physicists.$$ <<EOF
Wolfgang Pauli 1900
Werner Heisenberg 1901
Albert Einstein 1879
Niels Bohr 1885
EOF
nbPhysicists=$(wc -l physicists.$$ | cut -sf 1 -d ' ')     # Number of lines of the here-file specifying the physicists.

## Extract the needed data
declare -a person     # Create an indexed array (necessary for the read command).                                                                                 
while read -ra person; do
    firstName=${person[0]}
    familyName=${person[1]}
    birthYear=${person[2]}
    echo "Physicist ${firstName} ${familyName} was born in ${birthYear}"
    # Do whatever you need with data
done < physicists.$$

## Remove the temporary file
rm physicists.$$

输出： Physicist Wolfgang Pauli was born in 1900 Physicist Werner Heisenberg was born in 1901 Physicist Albert Einstein was born in 1879 Physicist Niels Bohr was born in 1885

工作方式：

• 创建的临时文件中的行扮演一维向量的角色，其中空格（或您选择的任何分隔字符；请参阅 Bash 手册中read 命令的描述）分隔这些元素的元素向量。
• 然后，使用带有-a 选项的read 命令，我们循环遍历文件的每一行（直到到达文件末尾）。对于每一行，我们可以将所需的字段（= 单词）分配给我们在循环之前声明的数组。 read 命令的 -r 选项可防止反斜杠充当转义字符，以防我们在此处的文档 physicists.$$ 中键入反斜杠。

总之，一个文件被创建为一个二维数组，它的元素是通过每行循环提取的，并使用read 命令的能力将单词分配给（索引）数组的元素。

略有改善：

在上面的代码中，文件physicists.$$ 作为while 循环的输入，因此它实际上被传递给read 命令。但是，我发现当我在 while 循环中有另一个命令要求输入时，这会导致问题。例如，select 命令等待标准输入，如果放在while 循环中，它将从physicists.$$ 获取输入，而不是在命令行中提示用户输入。 为了纠正这个问题，我使用了read 的-u 选项，它允许从文件描述符中读取。我们只需要创建一个与physicists.$$ 对应的文件描述符（使用exec 命令），并将其提供给读取的-u 选项，如下代码所示：

## Store the "two-dimensional data" in a file ($$ is just the process ID of the shell, to make sure the filename is unique)
cat > physicists.$$ <<EOF
Wolfgang Pauli 1900
Werner Heisenberg 1901
Albert Einstein 1879
Niels Bohr 1885
EOF
nbPhysicists=$(wc -l physicists.$$ | cut -sf 1 -d ' ')     # Number of lines of the here-file specifying the physicists.
exec {id_file}<./physicists.$$     # Create a file descriptor stored in 'id_file'.

## Extract the needed data
declare -a person     # Create an indexed array (necessary for the read command).                                                                                 
while read -ra person -u "${id_file}"; do
firstName=${person[0]}
familyName=${person[1]}
birthYear=${person[2]}
echo "Physicist ${firstName} ${familyName} was born in ${birthYear}"
# Do whatever you need with data
done

## Close the file descriptor
exec {id_file}<&-
## Remove the temporary file
rm physicists.$$

注意文件描述符最后关闭了。

Answer 8

扩展 Paul 的答案 - 这是我在 bash 中使用关联子数组的版本：

declare -A SUB_1=(["name1key"]="name1val" ["name2key"]="name2val")
declare -A SUB_2=(["name3key"]="name3val" ["name4key"]="name4val")
STRING_1="string1val"
STRING_2="string2val"
MAIN_ARRAY=(
  "${SUB_1[*]}"
  "${SUB_2[*]}"
  "${STRING_1}"
  "${STRING_2}"
)
echo "COUNT: " ${#MAIN_ARRAY[@]}
for key in ${!MAIN_ARRAY[@]}; do
    IFS=' ' read -a val <<< ${MAIN_ARRAY[$key]}
    echo "VALUE: " ${val[@]}
    if [[ ${#val[@]} -gt 1 ]]; then
        for subkey in ${!val[@]}; do
            subval=${val[$subkey]}
            echo "SUBVALUE: " ${subval}
        done
    fi
done

它适用于主数组中的混合值 - 字符串/数组/关联。数组

这里的关键是将子数组用单引号括起来，并在将子数组存储在主数组中时使用* 而不是@，以便将其存储为单个空格分隔的字符串："${SUB_1[*]}"

然后，在使用 IFS=' ' read -a val <<< ${MAIN_ARRAY[$key]} 循环遍历值时，可以很容易地从中解析出一个数组

上面的代码输出：

COUNT:  4
VALUE:  name1val name2val
SUBVALUE:  name1val
SUBVALUE:  name2val
VALUE:  name4val name3val
SUBVALUE:  name4val
SUBVALUE:  name3val
VALUE:  string1val
VALUE:  string2val

Answer 9

这里有很多关于在 bash 中创建多维数组的答案。

而且无一例外，都是迟钝且难用的。

如果 MD 数组是必需的标准，那么是时候做出决定了：

使用支持 MD 数组的语言

我的首选是 Perl。大多数人可能会选择 Python。 两者都可以。

将数据存储在别处

JSON 和 jq 已经被推荐了。还建议使用 XML，尽管 JSON 和 jq 可能更简单。

Bash 似乎不是您需要做的最佳选择。

有时正确的问题不是“我如何在工具 Y 中做 X？”，而是“哪种工具最适合做 X？”

Answer 10

我从 bash 4 开始使用 associative arrays 执行此操作，并将 IFS 设置为可以手动定义的值。

这种方法的目的是将数组作为关联数组键的值。

为了将 IFS 设置回默认值，只需取消设置即可。

• unset IFS

---

这是一个例子：

#!/bin/bash

set -euo pipefail

# used as value in asscciative array
test=(
  "x3:x4:x5"
)
# associative array
declare -A wow=(
  ["1"]=$test
  ["2"]=$test
)
echo "default IFS"
for w in ${wow[@]}; do
  echo "  $w"
done

IFS=:
echo "IFS=:"
for w in ${wow[@]}; do
  for t in $w; do
    echo "  $t"
  done
done
echo -e "\n or\n"
for w in ${!wow[@]}
do
  echo "  $w"
  for t in ${wow[$w]}
  do
    echo "    $t"
  done
done

unset IFS
unset w
unset t
unset wow
unset test

下面脚本的输出是：

default IFS
  x3:x4:x5
  x3:x4:x5
IFS=:
  x3
  x4
  x5
  x3
  x4
  x5

 or

  1
    x3
    x4
    x5
  2
    x3
    x4
    x5

Answer 11

Bash 不支持多维数组，但是我们可以使用 Associate 数组来实现。这里的索引是检索值的关键。关联数组在 bash 版本 4 中可用。

#!/bin/bash

declare -A arr2d
rows=3
columns=2

for ((i=0;i<rows;i++)) do
    for ((j=0;j<columns;j++)) do
        arr2d[$i,$j]=$i
    done
done


for ((i=0;i<rows;i++)) do
    for ((j=0;j<columns;j++)) do
        echo ${arr2d[$i,$j]}
    done
done

Answer 12

我有一个非常简单但聪明的解决方法： 只需在其名称中定义带有变量的数组。例如：

for (( i=0 ; i<$(($maxvalue + 1)) ; i++ ))
  do
  for (( j=0 ; j<$(($maxargument + 1)) ; j++ ))
    do
    declare -a array$i[$j]=((Your rule))
  done
done

不知道这是否有帮助，因为它不完全符合您的要求，但它对我有用。 （同样可以使用没有数组的变量来实现）

Answer 13

echo "Enter no of terms"
read count
for i in $(seq 1 $count)
do
  t=` expr $i - 1 `
  for j in $(seq $t -1 0)
  do
    echo -n " "
  done
  j=` expr $count + 1 `
  x=` expr $j - $i `
  for k in $(seq 1 $x)
  do
    echo -n "* "
  done
  echo ""
done