如何在 Bash 中加入数组的元素？

Question

如果我在 Bash 中有这样的数组：

FOO=( a b c )

如何用逗号连接元素？例如，产生a,b,c。

Answer 1

也许，例如，

SAVE_IFS="$IFS"
IFS=","
FOOJOIN="${FOO[*]}"
IFS="$SAVE_IFS"

echo "$FOOJOIN"

Answer 2

我现在正在使用：

TO_IGNORE=(
    E201 # Whitespace after '('
    E301 # Expected N blank lines, found M
    E303 # Too many blank lines (pep8 gets confused by comments)
)
ARGS="--ignore `echo ${TO_IGNORE[@]} | tr ' ' ','`"

这可行，但（在一般情况下）如果数组元素中有空格，则会严重损坏。

（对于那些感兴趣的人，这是一个围绕pep8.py 的包装脚本）

Answer 3

这种方法处理值中的空格，但需要循环：

#!/bin/bash

FOO=( a b c )
BAR=""

for index in ${!FOO[*]}
do
    BAR="$BAR,${FOO[$index]}"
done
echo ${BAR:1}

Answer 4

另一种解决方案：

#!/bin/bash
foo=('foo bar' 'foo baz' 'bar baz')
bar=$(printf ",%s" "${foo[@]}")
bar=${bar:1}

echo $bar

编辑：相同，但用于多字符可变长度分隔符：

#!/bin/bash
separator=")|(" # e.g. constructing regex, pray it does not contain %s
foo=('foo bar' 'foo baz' 'bar baz')
regex="$( printf "${separator}%s" "${foo[@]}" )"
regex="${regex:${#separator}}" # remove leading separator
echo "${regex}"
# Prints: foo bar)|(foo baz)|(bar baz

Answer 5

liststr=""
for item in list
do
    liststr=$item,$liststr
done
LEN=`expr length $liststr`
LEN=`expr $LEN - 1`
liststr=${liststr:0:$LEN}

这也会处理末尾的额外逗号。我不是 bash 专家。只是我的 2c，因为这更基本且易于理解

Answer 6

$ foo=(a "b c" d)
$ bar=$(IFS=, ; echo "${foo[*]}")
$ echo "$bar"
a,b c,d

Answer 7

通过重复使用@doesn't matter' 的解决方案，但通过避免 ${:1} 替换和中间变量的需要使用一个语句。

echo $(printf "%s," "${LIST[@]}" | cut -d "," -f 1-${#LIST[@]} )

printf 有'格式字符串会根据需要重复使用以满足参数。'在其手册页中，以便记录字符串的连接。然后诀窍是使用 LIST 长度来切割最后一个分隔符，因为 cut 将仅保留 LIST 的长度作为字段计数。

Answer 8

$ set a 'b c' d

$ history -p "$@" | paste -sd,
a,b c,d

Answer 9

不使用外部命令：

$ FOO=( a b c )     # initialize the array
$ BAR=${FOO[@]}     # create a space delimited string from array
$ BAZ=${BAR// /,}   # use parameter expansion to substitute spaces with comma
$ echo $BAZ
a,b,c

警告，它假定元素没有空格。

Answer 10

s=$(IFS=, eval 'echo "${FOO[*]}"')

Answer 11

如果你想加入的元素不是数组，只是一个空格分隔的字符串，你可以这样做：

foo="aa bb cc dd"
bar=`for i in $foo; do printf ",'%s'" $i; done`
bar=${bar:1}
echo $bar
    'aa','bb','cc','dd'

例如，我的用例是在我的 shell 脚本中传递了一些字符串，我需要使用它来运行 SQL 查询：

./my_script "aa bb cc dd"

在 my_script 中，我需要执行“SELECT * FROM table WHERE name IN ('aa','bb','cc','dd')。然后上面的命令会很有用。

Answer 12

接受任意长度分隔符的 printf 解决方案（基于@doesn't Matters 答案）

#/!bin/bash
foo=('foo bar' 'foo baz' 'bar baz')

sep=',' # can be of any length
bar=$(printf "${sep}%s" "${foo[@]}")
bar=${bar:${#sep}}

echo $bar

Answer 13

支持多字符分隔符的 100% 纯 Bash 函数是：

function join_by {
  local d=${1-} f=${2-}
  if shift 2; then
    printf %s "$f" "${@/#/$d}"
  fi
}

例如，

join_by , a b c #a,b,c
join_by ' , ' a b c #a , b , c
join_by ')|(' a b c #a)|(b)|(c
join_by ' %s ' a b c #a %s b %s c
join_by $'\n' a b c #a<newline>b<newline>c
join_by - a b c #a-b-c
join_by '\' a b c #a\b\c
join_by '-n' '-e' '-E' '-n' #-e-n-E-n-n
join_by , #
join_by , a #a

上面的代码基于@gniourf_gniourf、@AdamKatz、@MattCowell 和@x-yuri 的想法。它适用于选项errexit (set -e) 和nounset (set -u)。

或者，一个只支持单个字符分隔符的更简单的函数是：

function join_by { local IFS="$1"; shift; echo "$*"; }

例如，

join_by , a "b c" d #a,b c,d
join_by / var local tmp #var/local/tmp
join_by , "${FOO[@]}" #a,b,c

此解决方案基于 Pascal Pilz 的原始建议。

之前在这里提出的解决方案的详细解释可以在"How to join() array elements in a bash script", an article by meleu at dev.to找到。

Answer 14

awk -v sep=. 'BEGIN{ORS=OFS="";for(i=1;i<ARGC;i++){print ARGV[i],ARGC-i-1?sep:""}}' "${arr[@]}"

或

$ a=(1 "a b" 3)
$ b=$(IFS=, ; echo "${a[*]}")
$ echo $b
1,a b,3

Answer 15

我的尝试。

$ array=(one two "three four" five)
$ echo "${array[0]}$(printf " SEP %s" "${array[@]:1}")"
one SEP two SEP three four SEP five

Answer 16

这是一个 100% 纯 Bash 函数来完成这项工作：

join() {
    # $1 is return variable name
    # $2 is sep
    # $3... are the elements to join
    local retname=$1 sep=$2 ret=$3
    shift 3 || shift $(($#))
    printf -v "$retname" "%s" "$ret${@/#/$sep}"
}

看：

$ a=( one two "three three" four five )
$ join joineda " and " "${a[@]}"
$ echo "$joineda"
one and two and three three and four and five
$ join joinedb randomsep "only one element"
$ echo "$joinedb"
only one element
$ join joinedc randomsep
$ echo "$joinedc"

$ a=( $' stuff with\nnewlines\n' $'and trailing newlines\n\n' )
$ join joineda $'a sep with\nnewlines\n' "${a[@]}"
$ echo "$joineda"
 stuff with
newlines
a sep with
newlines
and trailing newlines


$

这甚至保留了尾随的换行符，并且不需要子shell来获取函数的结果。如果你不喜欢printf -v（你为什么不喜欢它？）并传递一个变量名，你当然可以为返回的字符串使用一个全局变量：

join() {
    # $1 is sep
    # $2... are the elements to join
    # return is in global variable join_ret
    local sep=$1 IFS=
    join_ret=$2
    shift 2 || shift $(($#))
    join_ret+="${*/#/$sep}"
}

Answer 17

使用 perl 作为多字符分隔符：

function join {
   perl -e '$s = shift @ARGV; print join($s, @ARGV);' "$@"; 
}

join ', ' a b c # a, b, c

或者在一行中：

perl -le 'print join(shift, @ARGV);' ', ' 1 2 3
1, 2, 3

Answer 18

也许我遗漏了一些明显的东西，因为我是整个 bash/zsh 的新手，但在我看来，您根本不需要使用 printf。没有它也不会变得很丑。

join() {
  separator=$1
  arr=$*
  arr=${arr:2} # throw away separator and following space
  arr=${arr// /$separator}
}

至少，到目前为止，它对我来说没有问题。

例如，join \| *.sh，假设我在我的~ 目录中，输出utilities.sh|play.sh|foobar.sh。对我来说已经足够了。

编辑：这基本上是Nil Geisweiller's answer，但被概括为一个函数。

Answer 19

令人惊讶的是我的解决方案还没有给出:) 这对我来说是最简单的方法。它不需要函数：

IFS=, eval 'joined="${foo[*]}"'

注意：观察到此解决方案在非 POSIX 模式下运行良好。在POSIX mode 中，元素仍然正确连接，但IFS=, 变为永久。

Answer 20

最佳答案的简短版本：

joinStrings() { local a=("${@:3}"); printf "%s" "$2${a[@]/#/$1}"; }

用法：

joinStrings "$myDelimiter" "${myArray[@]}"

Answer 21

我会将数组作为字符串回显，然后将空格转换为换行符，然后使用paste 将所有内容加入一行，如下所示：

tr " " "\n" <<< "$FOO" | paste -sd , -

结果：

a,b,c

这对我来说似乎是最快最干净的！

Answer 22

如果你在循环中构建数组，这里有一个简单的方法：

arr=()
for x in $(some_cmd); do
   arr+=($x,)
done
arr[-1]=${arr[-1]%,}
echo ${arr[*]}

Answer 23

将迄今为止所有世界中最好的与以下想法结合起来。

# join with separator
join_ws()  { local IFS=; local s="${*/#/$1}"; echo "${s#"$1$1$1"}"; }

这个小杰作是

• 100% 纯 bash（临时取消设置 IFS 的参数扩展，没有外部调用，没有 printf ...）
• 紧凑、完整且完美无缺（适用于单字符和多字符限制器，适用于包含空格、换行符和其他 shell 特殊字符的限制器，适用于空分隔符）
• 高效（无子shell，无数组复制）
• 简单而愚蠢，在某种程度上，也很漂亮和有启发性

例子：

$ join_ws , a b c
a,b,c
$ join_ws '' a b c
abc
$ join_ws $'\n' a b c
a
b
c
$ join_ws ' \/ ' A B C
A \/ B \/ C

Answer 24

感谢@gniourf_gniourf 详细介绍了我迄今为止的最佳世界组合。很抱歉发布没有经过彻底设计和测试的代码。这是一个更好的尝试。

# join with separator
join_ws() { local d=$1 s=$2; shift 2 && printf %s "$s${@/#/$d}"; }

这种意念之美是

• （仍然）100% 纯 bash（感谢您明确指出 printf 也是内置的。我之前不知道这一点...）
• 适用于多字符分隔符
• 更紧凑、更完整，这次仔细考虑并使用来自 shell 脚本的随机子字符串进行了长期压力测试，包括使用 shell 特殊字符或控制字符或在分隔符和/或参数中不使用字符，和边缘情况，极端情况和其他小问题，就像根本没有争论一样。这并不能保证没有更多的错误，但要找到一个更难的挑战。顺便说一句，即使是目前投票率最高的答案和相关问题也会受到 -e 错误之类的影响......

其他示例：

$ join_ws '' a b c
abc
$ join_ws ':' {1,7}{A..C}
1A:1B:1C:7A:7B:7C
$ join_ws -e -e
-e
$ join_ws $'\033[F' $'\n\n\n'  1.  2.  3.  $'\n\n\n\n'
3.
2.
1.
$ join_ws $ 
$

Answer 25

使用变量间接引用直接引用数组也可以。也可以使用命名引用，但它们仅在 4.3 中可用。

使用这种形式的函数的好处是你可以有可选的分隔符（默认为默认IFS的第一个字符，这是一个空格；如果你愿意，可以将它设为一个空字符串），并且它避免两次扩展值（第一次作为参数传递，第二次作为函数内部的"$@"）。

此解决方案也不需要用户在命令替换中调用该函数 - 这会调用一个子 shell，以获取分配给另一个变量的字符串的连接版本。

function join_by_ref {
    __=
    local __r=$1[@] __s=${2-' '}
    printf -v __ "${__s//\%/%%}%s" "${!__r}"
    __=${__:${#__s}}
}

array=(1 2 3 4)

join_by_ref array
echo "$__" # Prints '1 2 3 4'.

join_by_ref array '%s'
echo "$__" # Prints '1%s2%s3%s4'.

join_by_ref 'invalid*' '%s' # Bash 4.4 shows "invalid*[@]: bad substitution".
echo "$__" # Prints nothing but newline.

请随意为函数使用更舒适的名称。

这适用于 3.1 到 5.0-alpha。正如所观察到的，变量间接不仅适用于变量，还适用于其他参数。

参数是存储值的实体。它可以是一个名字，一个 数字，或下面列出的特殊字符之一 参数。变量是由名称表示的参数。

数组和数组元素也是参数（存储值的实体），对数组的引用在技术上也是对参数的引用。就像特殊参数@ 一样，array[@] 也可以作为有效参考。

偏离参数本身的引用的更改或选择性扩展形式（如子字符串扩展）不再起作用。

更新

在 Bash 5.0 的发布版本中，变量间接已被称为间接扩展，其行为已在手册中明确记录：

如果参数的第一个字符是感叹号（！），并且 参数不是nameref，它引入了一个间接级别。 Bash 使用扩展其余参数形成的值作为 新参数；然后扩展 this 并将该值用于 其余的扩展，而不是原来的扩展 范围。这称为间接扩展。

请注意，在${parameter} 的文档中，parameter 被称为“在 PARAMETERS 中描述的外壳参数或数组引用” .并且在数组的文档中，提到“数组的任何元素都可以使用${name[subscript]} 引用”。这使得__r[@] 成为数组引用。

通过参数加入版本

在Riccardo Galli's answer 中查看我的comment。

Answer 26

这与现有的解决方案并没有太大的不同，但它避免使用单独的函数，不会修改父 shell 中的 IFS 并且都在一行中：

arr=(a b c)
printf '%s\n' "$(IFS=,; printf '%s' "${arr[*]}")"

导致

a,b,c

限制：分隔符不能超过一个字符。

---

这可以简化为

(IFS=,; printf '%s' "${arr[*]}")

此时它与Pascal's answer基本相同，但使用printf而不是echo，并将结果打印到stdout而不是将其分配给变量。

Answer 27

这是大多数 POSIX 兼容的 shell 支持的一个：

join_by() {
    # Usage:  join_by "||" a b c d
    local arg arr=() sep="$1"
    shift
    for arg in "$@"; do
        if [ 0 -lt "${#arr[@]}" ]; then
            arr+=("${sep}")
        fi
        arr+=("${arg}") || break
    done
    printf "%s" "${arr[@]}"
}

Answer 28

x=${arr[*]// /,}

这是最短的方法。

例子，

# ZSH:
arr=(1 "2 3" 4 5)
x=${"${arr[*]}"// /,}
echo $x  # output: 1,2,3,4,5

# ZSH/BASH:
arr=(1 "2 3" 4 5)
a=${arr[*]}
x=${a// /,}
echo $x  # output: 1,2,3,4,5

Answer 29

也许派对迟到了，但这对我有用：

function joinArray() {
  local delimiter="${1}"
  local output="${2}"
  for param in ${@:3}; do
    output="${output}${delimiter}${param}"
  done

  echo "${output}"
}

Answer 30

这些解决方案中的许多（如果不是大多数）依赖于晦涩难懂的语法、令人费解的正则表达式技巧或对外部可执行文件的调用。我想提出一个简单的、仅限 bash 的解决方案，该解决方案非常容易理解，并且在性能方面只是略微次优。

join_by () {
    # Argument #1 is the separator. It can be multi-character.
    # Argument #2, 3, and so on, are the elements to be joined.
    # Usage: join_by ", " "${array[@]}"
    local SEPARATOR="$1"
    shift

    local F=0
    for x in "$@"
    do
        if [[ F -eq 1 ]]
        then
            echo -n "$SEPARATOR"
        else
            F=1
        fi
        echo -n "$x"
    done
    echo
}

例子：

$ a=( 1 "2 2" 3 )
$ join_by ", " "${a[@]}"
1, 2 2, 3
$ 

我想指出，任何使用 /usr/bin/[ 或 /usr/bin/printf 的解决方案本质上都比我的解决方案慢，因为我使用 100% 纯 bash。作为其性能的一个示例，这里有一个演示，我创建了一个包含 1,000,000 个随机整数的数组，然后用逗号将它们全部连接起来，并计时。

$ eval $(echo -n "a=("; x=0 ; while [[ x -lt 1000000 ]]; do echo -n " $RANDOM" ; x=$((x+1)); done; echo " )")
$ time join_by , ${a[@]} >/dev/null
real    0m8.590s
user    0m8.591s
sys     0m0.000s
$