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

另一种方式是:

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

现在您的元素存储在“ arr”数组中。 对元素进行迭代:

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

将字符串分割为数组的关键是 ", "的多字符分隔符。任何使用 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 中直接使用 regex 效率更高:

#!/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 分割字符串是一件非常无聊的事情。发生的情况是，我们的方法有限，只能在少数情况下工作(由“ ;”，“/”，“分割”等等)或者我们在输出中有各种各样的副作用。

下面的方法需要一些操作，但我相信它将工作的大多数我们的需要！

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

不修改 IFS 的另一种方法是:

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

而不是更改 IFS 以匹配我们所需的分隔符 我们可以通过 ABC2将所需分隔符 ABC0的所有匹配项替换为 $IFS的内容。

但是，对于非常大的字符串，这可能会比较慢？

这是基于 Dennis Williamson 的回答。

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

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

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

如果你正在寻找解决多字符分隔符问题的方法，我建议你回顾一下 Mallikarjun M的帖子，特别是来自 < a href = “ https://stackoverflow. com/users/1815797/gniourf-gniourf”> 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 在下面的评论中提出了一个很好的观点。在回顾了他们建议的编辑之后，我已经修改了 (咒语)提供的脚本，并添加了备注，以便于理解脚本在做什么。我还将双括号[[]]更改为单括号，以实现更大的兼容性，因为许多 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

我在解析输入时看到了这篇文章，比如: 单词1，单词2，..。

以上都没有帮助我。用 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

这对我在 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" " "))

简单: -)

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

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

readarray命令最容易使用换行符作为分隔符。使用其他分隔符，它可以向数组中添加额外的元素。最简洁的方法是在传递输入之前，首先将输入调整为与 readarray协同工作的表单。

本例中的输入有一个多字符分隔符 没有。如果我们应用一些常识，最好将其理解为逗号分隔的输入，其中每个元素都可能需要进行修剪。我的解决方案是用逗号将输入分割成多行，修剪每个元素，并将其全部传递给 readarray。

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


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

编辑: 我的解决方案允许逗号分隔符周围不一致的间距，同时也允许元素包含空格。几乎没有其他解决方案可以处理这些特殊情况。

我还避免使用看起来像是黑客技巧的方法，比如创建一个额外的数组元素，然后删除它。如果你不同意这是最好的答案，请留言解释。

如果您想纯粹在 Bash 中尝试相同的方法，并且使用较少的 subshell，那么这是可能的。但是结果很难阅读，这种优化可能是不必要的。

string='     Paris,France  ,   All of Europe    '
foo="${string#"${string%%[![:space:]]*}"}"
foo="${foo%"${foo##*[![:space:]]}"}"
foo="${foo//+([[:space:]]),/,}"
foo="${foo//,+([[:space:]])/,}"
readarray -t foo < <(echo "$foo")

对于多行元素，为什么不像

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


a a INTERELEMENT b b INTERELEMENT

如果您使用的是 macOS 而不能使用 readarray，那么您可以简单地这样做-

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

对元素进行迭代:

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

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

不要改变 IFS！

下面是一个简单的 bash 一行程序:

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

我很好奇“正确答案”的相对表现 在@bgoldst 的流行答案中，它明显地谴责了循环, 所以我对三个纯 bash 实现做了一个简单的基准测试。

总之，我建议:

1. 对于字符串长度 < 4k 左右，纯 bash 比 gawk 快
2. 对于分隔符长度 < 10和字符串长度 < 256k，纯 bash 与 gawk 相当
3. 对于分隔符长度 > 10和字符串长度 < 64k 左右的情况，纯 bash 是“可接受的”; 而 Gawk 的速度不到5倍
4. 对于字符串长度 < 512k 左右，gawk 是“可接受的”

我武断地将“可接受的”定义为“需要 < 0.5 s 来分割字符串”。

我认为问题在于使用任意长度的分隔符字符串(而不是 regex)将 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测试处理长度为零的情况 如果没有测试，输出数组是空的; 使用它，数组只有一个零长度的元素。

用 while read代替 readarray，减速 < 10% 。

这是我使用的笨拙的实现:

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://stackoverflow.com/a/37039138
if (!re) gsub(/[\\.^$(){}\[\]|*+?]/,"\\\\&",d)
}
gsub(d"|\n$","\0")
' <<<"$string"
)
# echo $( declare -p a | md5sum; declare -p a )
}

或者在佩尔也有同样的想法:

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’s code return: declare -a a=([0]="a") or declare -a a=([0]="a" [1]="")
• 我的回报: declare -a a=([0]="a-")或 declare -a a=([0]="a" [1]="-")

参数是通过简单的 Perl 脚本从以下地方派生出来的:

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

下面是3种不同类型的计时结果(以秒为单位)表 字符串和分隔符参数。

• 字符串参数的长度
• 外延参数的长度
• 性能收支平衡点
• !-“可接受的”性能限制(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) )")

第二类

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

第三类

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.5 s

Gawk < 0.5 s

(我不完全确定为什么 s160k 和 d = 1的 bash _ sub 总是比 s3的 d > 1慢。)

所有测试都是在运行 xubuntu 20.04的 Intel i7-7500U 上使用 bash 5.0.17进行的。