如何在 Bash 中将字符串拆分为数组？

这是一种不设置 IFS 的方法：

string="1:2:3:4:5"
set -f                      # avoid globbing (expansion of *).
array=(${string//:/ })
for i in "${!array[@]}"
do
    echo "$i=>${array[i]}"
done

这个想法是使用字符串替换：

${string//substring/replacement}

用空格替换 $substring 的所有匹配项，然后使用替换的字符串初始化数组：

(element1 element2 ... elementN)

注意：此答案使用 split+glob operator。因此，为了防止扩展某些字符（例如 *），最好暂停此脚本的通配符。

t="one,two,three"
a=($(echo "$t" | tr ',' '\n'))
echo "${a[2]}"

打印三个

有时我碰巧接受的答案中描述的方法不起作用，特别是如果分隔符是回车符。在这些情况下，我以这种方式解决了：

string='first line
second line
third line'

oldIFS="$IFS"
IFS='
'
IFS=${IFS:0:1} # this is useful to format your code with tabs
lines=( $string )
IFS="$oldIFS"

for line in "${lines[@]}"
    do
        echo "--> $line"
done

接受的答案适用于一行中的值。如果变量有几行：

string='first line
        second line
        third line'

我们需要一个非常不同的命令来获取所有行：

while read -r line; do lines+=("$line"); done <<<"$string"

或者更简单的 bash readarray：

readarray -t lines <<<"$string"

利用 printf 功能打印所有行非常容易：

printf ">[%s]\n" "${lines[@]}"

>[first line]
>[        second line]
>[        third line]

这适用于我在 OSX 上：

string="1 2 3 4 5"
declare -a array=($string)

如果您的字符串有不同的分隔符，只需首先用空格替换它们：

string="1,2,3,4,5"
delimiter=","
declare -a array=($(echo $string | tr "$delimiter" " "))

简单的 ：-）

如果你使用 macOS 并且不能使用 readarray，你可以简单地这样做——

MY_STRING="string1 string2 string3"
array=($MY_STRING)

迭代元素：

for element in "${array[@]}"
do
    echo $element
done

这类似于 approach by Jmoney38，但使用 sed：

string="1,2,3,4"
array=(`echo $string | sed 's/,/\n/g'`)
echo ${array[0]}

打印 1

将字符串拆分为数组的关键是 ", " 的多字符分隔符。将 IFS 用于多字符分隔符的任何解决方案本质上都是错误的，因为 IFS 是一组这些字符，而不是字符串。

如果您指定 IFS=", "，则字符串将在 "," 或 " " 或它们的任何组合上中断，这不是 ", " 的两个字符分隔符的准确表示。

您可以使用 awk 或 sed 通过进程替换来拆分字符串：

#!/bin/bash

str="Paris, France, Europe"
array=()
while read -r -d $'\0' each; do   # use a NUL terminated field separator 
    array+=("$each")
done < <(printf "%s" "$str" | awk '{ gsub(/,[ ]+|$/,"\0"); print }')
declare -p array
# declare -a array=([0]="Paris" [1]="France" [2]="Europe") output

直接在 Bash 中使用正则表达式更有效：

#!/bin/bash

str="Paris, France, Europe"

array=()
while [[ $str =~ ([^,]+)(,[ ]+|$) ]]; do
    array+=("${BASH_REMATCH[1]}")   # capture the field
    i=${#BASH_REMATCH}              # length of field + delimiter
    str=${str:i}                    # advance the string by that length
done                                # the loop deletes $str, so make a copy if needed

declare -p array
# declare -a array=([0]="Paris" [1]="France" [2]="Europe") output...

使用第二种形式，没有子外壳，它本质上会更快。

由 bgoldst 编辑： 以下是一些比较我的 readarray 解决方案与 dawg 的正则表达式解决方案的基准，我还包括了 read 解决方案以供参考（注意：我稍微修改了正则表达式解决方案与我的解决方案更加和谐）（另见我在帖子下方的评论）：

## competitors
function c_readarray { readarray -td '' a < <(awk '{ gsub(/, /,"\0"); print; };' <<<"$1, "); unset 'a[-1]'; };
function c_read { a=(); local REPLY=''; while read -r -d ''; do a+=("$REPLY"); done < <(awk '{ gsub(/, /,"\0"); print; };' <<<"$1, "); };
function c_regex { a=(); local s="$1, "; while [[ $s =~ ([^,]+),\  ]]; do a+=("${BASH_REMATCH[1]}"); s=${s:${#BASH_REMATCH}}; done; };

## helper functions
function rep {
    local -i i=-1;
    for ((i = 0; i<$1; ++i)); do
        printf %s "$2";
    done;
}; ## end rep()

function testAll {
    local funcs=();
    local args=();
    local func='';
    local -i rc=-1;
    while [[ "$1" != ':' ]]; do
        func="$1";
        if [[ ! "$func" =~ ^[_a-zA-Z][_a-zA-Z0-9]*$ ]]; then
            echo "bad function name: $func" >&2;
            return 2;
        fi;
        funcs+=("$func");
        shift;
    done;
    shift;
    args=("$@");
    for func in "${funcs[@]}"; do
        echo -n "$func ";
        { time $func "${args[@]}" >/dev/null 2>&1; } 2>&1| tr '\n' '/';
        rc=${PIPESTATUS[0]}; if [[ $rc -ne 0 ]]; then echo "[$rc]"; else echo; fi;
    done| column -ts/;
}; ## end testAll()

function makeStringToSplit {
    local -i n=$1; ## number of fields
    if [[ $n -lt 0 ]]; then echo "bad field count: $n" >&2; return 2; fi;
    if [[ $n -eq 0 ]]; then
        echo;
    elif [[ $n -eq 1 ]]; then
        echo 'first field';
    elif [[ "$n" -eq 2 ]]; then
        echo 'first field, last field';
    else
        echo "first field, $(rep $[$1-2] 'mid field, ')last field";
    fi;
}; ## end makeStringToSplit()

function testAll_splitIntoArray {
    local -i n=$1; ## number of fields in input string
    local s='';
    echo "===== $n field$(if [[ $n -ne 1 ]]; then echo 's'; fi;) =====";
    s="$(makeStringToSplit "$n")";
    testAll c_readarray c_read c_regex : "$s";
}; ## end testAll_splitIntoArray()

## results
testAll_splitIntoArray 1;
## ===== 1 field =====
## c_readarray   real  0m0.067s   user 0m0.000s   sys  0m0.000s
## c_read        real  0m0.064s   user 0m0.000s   sys  0m0.000s
## c_regex       real  0m0.000s   user 0m0.000s   sys  0m0.000s
##
testAll_splitIntoArray 10;
## ===== 10 fields =====
## c_readarray   real  0m0.067s   user 0m0.000s   sys  0m0.000s
## c_read        real  0m0.064s   user 0m0.000s   sys  0m0.000s
## c_regex       real  0m0.001s   user 0m0.000s   sys  0m0.000s
##
testAll_splitIntoArray 100;
## ===== 100 fields =====
## c_readarray   real  0m0.069s   user 0m0.000s   sys  0m0.062s
## c_read        real  0m0.065s   user 0m0.000s   sys  0m0.046s
## c_regex       real  0m0.005s   user 0m0.000s   sys  0m0.000s
##
testAll_splitIntoArray 1000;
## ===== 1000 fields =====
## c_readarray   real  0m0.084s   user 0m0.031s   sys  0m0.077s
## c_read        real  0m0.092s   user 0m0.031s   sys  0m0.046s
## c_regex       real  0m0.125s   user 0m0.125s   sys  0m0.000s
##
testAll_splitIntoArray 10000;
## ===== 10000 fields =====
## c_readarray   real  0m0.209s   user 0m0.093s   sys  0m0.108s
## c_read        real  0m0.333s   user 0m0.234s   sys  0m0.109s
## c_regex       real  0m9.095s   user 0m9.078s   sys  0m0.000s
##
testAll_splitIntoArray 100000;
## ===== 100000 fields =====
## c_readarray   real  0m1.460s   user 0m0.326s   sys  0m1.124s
## c_read        real  0m2.780s   user 0m1.686s   sys  0m1.092s
## c_regex       real  17m38.208s   user 15m16.359s   sys  2m19.375s
##

纯 bash 多字符分隔符解决方案。

正如其他人在这个线程中指出的那样，OP的问题给出了一个逗号分隔字符串被解析为数组的例子，但没有表明他/她是否只对逗号分隔符、单字符分隔符或多字符感兴趣分隔符。

由于谷歌倾向于将此答案排在搜索结果的顶部或附近，因此我想为读者提供一个关于多字符分隔符问题的有力答案，因为至少在一个回复中也提到了这一点。

如果您正在寻找多字符分隔符问题的解决方案，我建议您查看 Mallikarjun M 的帖子，尤其是来自 gniourf_gniourf 的回复，他使用参数扩展提供了这个优雅的纯 BASH 解决方案：

#!/bin/bash
str="LearnABCtoABCSplitABCaABCString"
delimiter=ABC
s=$str$delimiter
array=();
while [[ $s ]]; do
    array+=( "${s%%"$delimiter"*}" );
    s=${s#*"$delimiter"};
done;
declare -p array

链接到 cited comment/referenced post

引用问题的链接：Howto split a string on a multi-character delimiter in bash?

尝试这个

IFS=', '; array=(Paris, France, Europe)
for item in ${array[@]}; do echo $item; done

这很简单。如果需要，您还可以添加声明（并删除逗号）：

IFS=' ';declare -a array=(Paris France Europe)

添加 IFS 以撤消上述操作，但在新的 bash 实例中没有它也可以工作

#!/bin/bash

string="a | b c"
pattern=' | '

# replaces pattern with newlines
splitted="$(sed "s/$pattern/\n/g" <<< "$string")"

# Reads lines and put them in array
readarray -t array2 <<< "$splitted"

# Prints number of elements
echo ${#array2[@]}
# Prints all elements
for a in "${array2[@]}"; do
        echo "> '$a'"
done

此解决方案适用于较大的分隔符（超过一个字符）。如果原始字符串中已有换行符，则不起作用

这适用于给定的数据：

$ aaa='Paris, France, Europe'
$ mapfile -td ',' aaaa < <(echo -n "${aaa//, /,}")
$ declare -p aaaa

结果：

declare -a aaaa=([0]="Paris" [1]="France" [2]="Europe")

它也适用于带有空格的扩展数据，例如“New York”：

$ aaa="New York, Paris, New Jersey, Hampshire"
$ mapfile -td ',' aaaa < <(echo -n "${aaa//, /,}")
$ declare -p aaaa

结果：

declare -a aaaa=([0]="New York" [1]="Paris" [2]="New Jersey" [3]="Hampshire")

在不修改 IFS 的情况下执行此操作的另一种方法：

read -r -a myarray <<< "${string//, /$IFS}"

我们可以通过 "${string//, /$IFS}" 将所有出现的所需分隔符 ", " 替换为 $IFS 的内容，而不是更改 IFS 以匹配我们想要的分隔符。

也许这对于非常大的字符串来说会很慢？

这是基于丹尼斯威廉姆森的回答。

我在解析如下输入时遇到了这篇文章：word1,word2,...

以上都没有帮助我。通过使用 awk 解决了它。如果对某人有帮助：

STRING="value1,value2,value3"
array=`echo $STRING | awk -F ',' '{ s = $1; for (i = 2; i <= NF; i++) s = s "\n"$i; print s; }'`
for word in ${array}
do
        echo "This is the word $word"
done

更新：不要这样做，因为 eval 有问题。

稍微少一点仪式：

IFS=', ' eval 'array=($string)'

例如

string="foo, bar,baz"
IFS=', ' eval 'array=($string)'
echo ${array[1]} # -> bar

不要更改 IFS！

这是一个简单的 bash 单行代码：

read -a my_array <<< $(echo ${INPUT_STRING} | tr -d ' ' | tr ',' ' ')

这是我的黑客！

使用 bash 将字符串按字符串拆分是一件非常无聊的事情。发生的情况是，我们的方法有限，仅在少数情况下有效（由“;”、“/”、“.”等分割），或者我们在输出中有各种副作用。

下面的方法需要一些操作，但我相信它可以满足我们的大部分需求！

#!/bin/bash

# --------------------------------------
# SPLIT FUNCTION
# ----------------

F_SPLIT_R=()
f_split() {
    : 'It does a "split" into a given string and returns an array.

    Args:
        TARGET_P (str): Target string to "split".
        DELIMITER_P (Optional[str]): Delimiter used to "split". If not 
    informed the split will be done by spaces.

    Returns:
        F_SPLIT_R (array): Array with the provided string separated by the 
    informed delimiter.
    '

    F_SPLIT_R=()
    TARGET_P=$1
    DELIMITER_P=$2
    if [ -z "$DELIMITER_P" ] ; then
        DELIMITER_P=" "
    fi

    REMOVE_N=1
    if [ "$DELIMITER_P" == "\n" ] ; then
        REMOVE_N=0
    fi

    # NOTE: This was the only parameter that has been a problem so far! 
    # By Questor
    # [Ref.: https://unix.stackexchange.com/a/390732/61742]
    if [ "$DELIMITER_P" == "./" ] ; then
        DELIMITER_P="[.]/"
    fi

    if [ ${REMOVE_N} -eq 1 ] ; then

        # NOTE: Due to bash limitations we have some problems getting the 
        # output of a split by awk inside an array and so we need to use 
        # "line break" (\n) to succeed. Seen this, we remove the line breaks 
        # momentarily afterwards we reintegrate them. The problem is that if 
        # there is a line break in the "string" informed, this line break will 
        # be lost, that is, it is erroneously removed in the output! 
        # By Questor
        TARGET_P=$(awk 'BEGIN {RS="dn"} {gsub("\n", "3F2C417D448C46918289218B7337FCAF"); printf $0}' <<< "${TARGET_P}")

    fi

    # NOTE: The replace of "\n" by "3F2C417D448C46918289218B7337FCAF" results 
    # in more occurrences of "3F2C417D448C46918289218B7337FCAF" than the 
    # amount of "\n" that there was originally in the string (one more 
    # occurrence at the end of the string)! We can not explain the reason for 
    # this side effect. The line below corrects this problem! By Questor
    TARGET_P=${TARGET_P%????????????????????????????????}

    SPLIT_NOW=$(awk -F"$DELIMITER_P" '{for(i=1; i<=NF; i++){printf "%s\n", $i}}' <<< "${TARGET_P}")

    while IFS= read -r LINE_NOW ; do
        if [ ${REMOVE_N} -eq 1 ] ; then

            # NOTE: We use "'" to prevent blank lines with no other characters 
            # in the sequence being erroneously removed! We do not know the 
            # reason for this side effect! By Questor
            LN_NOW_WITH_N=$(awk 'BEGIN {RS="dn"} {gsub("3F2C417D448C46918289218B7337FCAF", "\n"); printf $0}' <<< "'${LINE_NOW}'")

            # NOTE: We use the commands below to revert the intervention made 
            # immediately above! By Questor
            LN_NOW_WITH_N=${LN_NOW_WITH_N%?}
            LN_NOW_WITH_N=${LN_NOW_WITH_N#?}

            F_SPLIT_R+=("$LN_NOW_WITH_N")
        else
            F_SPLIT_R+=("$LINE_NOW")
        fi
    done <<< "$SPLIT_NOW"
}

# --------------------------------------
# HOW TO USE
# ----------------

STRING_TO_SPLIT="
 * How do I list all databases and tables using psql?

\"
sudo -u postgres /usr/pgsql-9.4/bin/psql -c \"\l\"
sudo -u postgres /usr/pgsql-9.4/bin/psql <DB_NAME> -c \"\dt\"
\"

\"
\list or \l: list all databases
\dt: list all tables in the current database
\"

[Ref.: https://dba.stackexchange.com/questions/1285/how-do-i-list-all-databases-and-tables-using-psql]


"

f_split "$STRING_TO_SPLIT" "bin/psql -c"

# --------------------------------------
# OUTPUT AND TEST
# ----------------

ARR_LENGTH=${#F_SPLIT_R[*]}
for (( i=0; i<=$(( $ARR_LENGTH -1 )); i++ )) ; do
    echo " > -----------------------------------------"
    echo "${F_SPLIT_R[$i]}"
    echo " < -----------------------------------------"
done

if [ "$STRING_TO_SPLIT" == "${F_SPLIT_R[0]}bin/psql -c${F_SPLIT_R[1]}" ] ; then
    echo " > -----------------------------------------"
    echo "The strings are the same!"
    echo " < -----------------------------------------"
fi

由于有很多方法可以解决这个问题，让我们从定义我们希望在我们的解决方案中看到的内容开始。

为此，Bash 提供了一个内置的 readarray。让我们使用它。避免丑陋和不必要的技巧，例如更改 IFS、循环、使用 eval 或添加额外元素然后删除它。找到一种简单易读的方法，可以很容易地适应类似的问题。

readarray 命令最容易使用换行符作为分隔符。使用其他分隔符，它可能会向数组添加一个额外的元素。最简洁的方法是首先将我们的输入调整为与 readarray 完美配合的表单，然后再将其传入。

此示例中的输入确实 not 具有多字符分隔符。如果我们应用一点常识，最好将其理解为逗号分隔的输入，每个元素可能需要对其进行修剪。我的解决方案是用逗号将输入拆分为多行，修剪每个元素，然后将其全部传递给 readarray。

string='  Paris,France  ,   All of Europe  '
readarray -t foo < <(tr ',' '\n' <<< "$string" |sed 's/^ *//' |sed 's/ *$//')
declare -p foo

# declare -a foo='([0]="Paris" [1]="France" [2]="All of Europe")'

对于多线元素，为什么不类似

$ array=($(echo -e $'a a\nb b' | tr ' ' '§')) && array=("${array[@]//§/ }") && echo "${array[@]/%/ INTERELEMENT}"

a a INTERELEMENT b b INTERELEMENT

另一种方法是：

string="Paris, France, Europe"
IFS=', ' arr=(${string})

现在您的元素存储在“arr”数组中。遍历元素：

for i in ${arr[@]}; do echo $i; done

另一种方法可以是：

str="a, b, c, d"  # assuming there is a space after ',' as in Q
arr=(${str//,/})  # delete all occurrences of ','

在这个 'arr' 之后是一个包含四个字符串的数组。这不需要处理 IFS 或读取或任何其他特殊的东西，因此更简单和直接。