如何在Bash中将字符串分割成数组？

我对@bgoldst的流行答案中关于“正确答案”的相对性能很好奇，因为它明显对循环进行了批评，所以我对它进行了一个简单的基准测试，与三个纯bash实现进行了比较。
总结一下，我建议：
1. 对于字符串长度小于4k左右，纯bash比gawk更快。 2. 对于分隔符长度小于10且字符串长度小于256k，纯bash与gawk相当。 3. 对于分隔符长度远大于10且字符串长度小于64k左右，纯bash是“可接受的”；而gawk则快不到5倍。 4. 对于字符串长度小于512k左右，gawk是“可接受的”。
我任意地将“可接受”定义为“分割字符串所需时间小于0.5秒”。

---

我正在解决的问题是将一个 bash 字符串拆分成一个 bash 数组，使用任意长度的分隔符字符串（非正则表达式）。

# in: $1=delim, $2=string
# out: sets array a

我的纯bash实现如下：

# naive approach - slow
split_byStr_bash_naive(){
    a=()
    local prev=""
    local cdr="$2"
    [[ -z "${cdr}" ]] && a+=("")
    while [[ "$cdr" != "$prev" ]]; do
        prev="$cdr"
        a+=( "${cdr%%"$1"*}" )
        cdr="${cdr#*"$1"}"
    done
    # echo $( declare -p a | md5sum; declare -p a )
}

# use lengths wherever possible - faster
split_byStr_bash_faster(){
    a=()
    local car=""
    local cdr="$2"
    while
        car="${cdr%%"$1"*}"
        a+=("$car")
        cdr="${cdr:${#car}}"
        (( ${#cdr} ))
    do
        cdr="${cdr:${#1}}"
    done
    # echo $( declare -p a | md5sum; declare -p a )
}

# use pattern substitution and readarray - fastest
split_byStr_bash_sub(){
        a=()
        local delim="$1" string="$2"

        delim="${delim//=/=-}"
        delim="${delim//$'\n'/=n}"

        string="${string//=/=-}"
        string="${string//$'\n'/=n}"

        readarray -td $'\n' a <<<"${string//"$delim"/$'\n'}"

        local len=${#a[@]} i s
        for (( i=0; i<len; i++ )); do
                s="${a[i]//=n/$'\n'}"
                a[i]="${s//=-/=}"
        done
        # echo $( declare -p a | md5sum; declare -p a )
}

在原始的幼稚版本中，初始的-z测试处理了传递零长度字符串的情况。如果没有这个测试，输出数组将为空；而有了这个测试，数组将有一个零长度的元素。
将readarray替换为while read会导致不到10%的减速。

---

这是我使用的gawk实现：

split_byRE_gawk(){
    readarray -td '' a < <(awk '{gsub(/'"$1"'/,"\0")}1' <<<"$2$1")
    unset 'a[-1]'
    # echo $( declare -p a | md5sum; declare -p a )
}

显然，在一般情况下，delim参数需要进行清理，因为gawk期望一个正则表达式，而gawk特殊字符可能会引起问题。此外，目前的实现无法正确处理分隔符中的换行符。
由于正在使用gawk，可以使用更通用的版本来处理更多任意的分隔符。

split_byREorStr_gawk(){
    local delim=$1
    local string=$2
    local useRegex=${3:+1}  # if set, delimiter is regex

    readarray -td '' a < <(
        export delim
        gawk -v re="$useRegex" '
            BEGIN {
                RS = FS = "\0"
                ORS = ""
                d = ENVIRON["delim"]

                # cf. https://dev59.com/hJbfa4cB1Zd3GeqPyMCE#37039138
                if (!re) gsub(/[\\.^$(){}\[\]|*+?]/,"\\\\&",d)
            }
            gsub(d"|\n$","\0")
        ' <<<"$string"
    )
    # echo $( declare -p a | md5sum; declare -p a )
}

或者用Perl实现相同的想法：

split_byREorStr_perl(){
    local delim=$1
    local string=$2
    local regex=$3  # if set, delimiter is regex

    readarray -td '' a < <(
        export delim regex
        perl -0777pe '
            $d = $ENV{delim};
            $d = "\Q$d\E" if ! $ENV{regex};
            s/$d|\n$/\0/g;
        ' <<<"$string"
    )
    # echo $( declare -p a | md5sum; declare -p a )
}

---

实现产生相同的输出，通过单独比较md5sum进行测试。
请注意，如果输入是模糊的（正如@bgoldst所说的“逻辑上不正确”），行为会稍有不同。例如，使用分隔符--和字符串a-或a---：

• @goldst的代码返回：declare -a a=([0]="a")或declare -a a=([0]="a" [1]="")
• 我的返回：declare -a a=([0]="a-")或declare -a a=([0]="a" [1]="-")

---

通过简单的Perl脚本从以下内容中提取了参数：

delim="-=-="
base="ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"

这里是三种不同类型的字符串和分隔符参数的计时结果表（以秒为单位）。
- `#s` - 字符串参数的长度 - `#d` - 分隔符参数的长度 - `=` - 性能平衡点 - `!` - "可接受"性能限制（bash）大约在这个范围内 - `!!` - "可接受"性能限制（gawk）大约在这个范围内 - `-` - 函数执行时间过长 - `` - gawk命令运行失败 类型1

d=$(perl -e "print( '$delim' x (7*2**$n) )")
s=$(perl -e "print( '$delim' x (7*2**$n) . '$base' x (7*2**$n) )")

类型2

d=$(perl -e "print( '$delim' x ($n) )")
s=$(perl -e "print( ('$delim' x ($n) . '$base' x $n ) x (2**($n-1)) )")

类型3

d=$(perl -e "print( '$delim' x (2**($n-1)) )")
s=$(perl -e "print( ('$delim' x (2**($n-1)) . '$base' x (2**($n-1)) ) x ($n) )")

---

分隔符长度1..10的摘要

由于短分隔符可能比长分隔符更常见，下面总结了分隔符长度在1到10之间的结果（2到9的结果大多被省略，因为非常相似）。

s1=$(perl -e "print( '$d' . '$base' x (7*2**$n) )")
s2=$(perl -e "print( ('$d' . '$base' x $n ) x (2**($n-1)) )")
s3=$(perl -e "print( ('$d' . '$base' x (2**($n-1)) ) x ($n) )")

bash_sub < gawk

bash_sub < 0.5s

gawk < 0.5秒

（我不完全确定为什么在s>160k和d=1的情况下，bash_sub的速度始终比d>1的情况要慢。）
（所有测试都是在运行xubuntu 20.04的Intel i7-7500U上使用bash 5.0.17进行的。）

输入代码纯bash多字符分隔符解决方案。

正如其他人在本主题中指出的那样，原帖提供了一个逗号分隔的字符串示例以被分解为数组，但并未指明他/她是否只关心逗号分隔符、单个字符分隔符或多个字符分隔符。

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

如果您正在寻找多个字符分隔符的解决方案，我建议查看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

链接到引用的评论/参考帖子

链接到引用的问题：如何在bash中使用多字符分隔符拆分字符串？

---

2022年8月3日更新

xebeche在下面的评论中提出了一个很好的观点。经过审核其建议的编辑，我修改了由gniourf_gniourf提供的脚本，并添加了注释以便理解该脚本正在做什么。我还将双括号[[]]更改为单括号，以增强兼容性，因为许多Shell变体不支持双括号表示法。在这种情况下，对于BaSH，逻辑在单括号或双括号内均可正常工作。

#!/bin/bash
  
str="LearnABCtoABCSplitABCABCaABCStringABC"
delimiter="ABC"
array=()

while [ "$str" ]; do

    # parse next sub-string, left of next delimiter
    substring="${str%%"$delimiter"*}" 

    # when substring = delimiter, truncate leading delimiter
    # (i.e. pattern is "$delimiter$delimiter")
    [ -z "$substring" ] && str="${str#"$delimiter"}" && continue

    # create next array element with parsed substring
    array+=( "$substring" )

    # remaining string to the right of delimiter becomes next string to be evaluated
    str="${str:${#substring}}"

    # prevent infinite loop when last substring = delimiter
    [ "$str" == "$delimiter" ] && break

done

declare -p array

没有注释：

#!/bin/bash
str="LearnABCtoABCSplitABCABCaABCStringABC"
delimiter="ABC"
array=()
while [ "$str" ]; do
    substring="${str%%"$delimiter"*}" 
    [ -z "$substring" ] && str="${str#"$delimiter"}" && continue
    array+=( "$substring" )
    str="${str:${#substring}}"
    [ "$str" == "$delimiter" ] && break
done
declare -p array

#!/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")

它还可以用于包含空格的扩展数据，例如“纽约”：

$ 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")

这是一个纯粹的bash函数，适用于空元素、多字符分隔符、通配符等情况。

# Usage: split_str_by "a,b,c" ,  # result is in "${__ret[@]}"
split_str_by(){
    local s="$1" sep="$2" el
    __ret=()
    while true; do
        el="${s%%"$sep"*}"
        __ret+=("$el")
        # If no sep was left, quit
        [[ "$el" == "$s" ]] && break
        s="${s#*"$sep"}"
    done
    return 0
}

# some tests:
split_str_by "a,b,c" ,
declare -p __ret  # __ret=([0]="a" [1]="b" [2]="c")

split_str_by ",a,,b,c," ,
declare -p __ret # __ret=([0]="" [1]="a" [2]="" [3]="b" [4]="c" [5]="")

split_str_by ",,a,b,,,c,," ,,
declare -p __ret # __ret=([0]="" [1]="a,b" [2]=",c" [3]="")

split_str_by " *a *b *c *" ' *'
declare -p __ret # __ret=([0]="" [1]="a" [2]="b" [3]="c" [4]="")

split_str_by "--aa--bb--cc" '--'
declare -p __ret # declare -a __ret=([0]="" [1]="aa" [2]="bb" [3]="cc")

试试这个

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

很简单。如果你想的话，也可以添加一个声明（并且去掉逗号）：

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

IFS是用来撤销上述操作的，但在新的bash实例中，即使没有它也可以工作。

另一种方法是在不修改IFS的情况下进行操作:

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

与其改变 IFS 以匹配我们所需的分隔符，我们可以通过 "${string//, /$IFS}" 将所有出现的所需分隔符 ", " 替换为 $IFS 的内容。 也许对于非常大的字符串来说，这可能会很慢？
这是基于 Dennis Williamson 的答案。

当我想解析像这样的输入时： 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 ',' ' ')