取自Bash shell脚本拆分数组：

IN="bla@some.com;john@home.com"
arrIN=(${IN//;/ })
echo ${arrIN[1]}                  # Output: john@home.com

说明：

此构造将替换所有出现的“；”（首字母//表示全局替换）在字符串in中使用“”（单个空格），然后将空格分隔的字符串解释为数组（这就是周围的括号所做的）。

大括号内用于替换每个“；”的语法带有“”字符的字符称为参数扩展。

有一些常见的陷阱：

如果原始字符串有空格，则需要使用IFS：

IFS=“：”；arrIN=（$IN）；未设置IFS；

如果原始字符串包含空格，并且分隔符是新行，则可以使用以下命令设置IFS：

IFS=$'\n'；arrIN=（$IN）；未设置IFS；

一个单行线，用于拆分由“；”分隔的字符串在数组中是：

IN="bla@some.com;john@home.com"
ADDRS=( $(IFS=";" echo "$IN") )
echo ${ADDRS[0]}
echo ${ADDRS[1]}

这只在子shell中设置IFS，因此您不必担心保存和恢复其值。

又一个迟来的答案。。。如果你对java有兴趣，这里是bashj(https://sourceforge.net/projects/bashj/)解决方案：

#!/usr/bin/bashj

#!java

private static String[] cuts;
private static int cnt=0;
public static void split(String words,String regexp) {cuts=words.split(regexp);}
public static String next() {return(cnt<cuts.length ? cuts[cnt++] : "null");}

#!bash

IN="bla@some.com;john@home.com"

: j.split($IN,";")    # java method call

while true
do
    NAME=j.next()     # java method call
    if [ $NAME != null ] ; then echo $NAME ; else exit ; fi
done

兼容答案

在bash中有很多不同的方法可以做到这一点。

然而，首先需要注意的是，bash有许多特殊功能（所谓的bashms），这些功能在任何其他shell中都不起作用。

特别是，本篇文章中的解决方案以及线程中的其他解决方案中使用的数组、关联数组和模式替换都是抨击，可能无法在许多人使用的其他外壳下工作。

例如：在我的Debian GNU/Linux上，有一个名为dash的标准shell；我认识很多人，他们喜欢使用另一种叫做ksh的shell；还有一个叫做busybox的特殊工具，带有自己的shell解释器（ash）。

对于posix shell兼容的答案，请转到此答案的最后一部分！

请求的字符串

上述问题中要拆分的字符串是：

IN="bla@some.com;john@home.com"

我将使用此字符串的修改版本，以确保我的解决方案对包含空格的字符串具有鲁棒性，这可能会破坏其他解决方案：

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"

基于bash中的分隔符拆分字符串（版本>=4.2）

在纯bash中，我们可以创建一个数组，其中元素由IFS的临时值（输入字段分隔符）分割。除其他外，IFS还告诉bash在定义数组时应将哪些字符视为元素之间的分隔符：

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"

# save original IFS value so we can restore it later
oIFS="$IFS"
IFS=";"
declare -a fields=($IN)
IFS="$oIFS"
unset oIFS

在较新版本的bash中，用IFS定义前缀命令只会更改该命令的IFS，并在之后立即将其重置为先前的值。这意味着我们可以在一行中完成上述操作：

IFS=\; read -a fields <<<"$IN"
# after this command, the IFS resets back to its previous value (here, the default):
set | grep ^IFS=
# IFS=$' \t\n'

我们可以看到，字符串IN已存储在一个名为fields的数组中，以分号分隔：

set | grep ^fields=\\\|^IN=
# fields=([0]="bla@some.com" [1]="john@home.com" [2]="Full Name <fulnam@other.org>")
# IN='bla@some.com;john@home.com;Full Name <fulnam@other.org>'

（我们还可以使用declare-p显示这些变量的内容：）

declare -p IN fields
# declare -- IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
# declare -a fields=([0]="bla@some.com" [1]="john@home.com" [2]="Full Name <fulnam@other.org>")

请注意，读取是执行拆分的最快方式，因为没有调用fork或外部资源。

一旦定义了数组，就可以使用一个简单的循环来处理每个字段（或者说，现在定义的数组中的每个元素）：

# `"${fields[@]}"` expands to return every element of `fields` array as a separate argument
for x in "${fields[@]}" ;do
    echo "> [$x]"
    done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

或者，您可以在使用移位方法处理后从阵列中删除每个字段，我喜欢：

while [ "$fields" ] ;do
    echo "> [$fields]"
    # slice the array 
    fields=("${fields[@]:1}")
    done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

如果你只需要一个简单的数组打印输出，你甚至不需要遍历它：

printf "> [%s]\n" "${fields[@]}"
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

更新：最近的bash>=4.4

在较新版本的bash中，还可以使用命令mapfile：

mapfile -td \; fields < <(printf "%s\0" "$IN")

此语法保留特殊字符、换行符和空字段！

如果不想包含空字段，可以执行以下操作：

mapfile -td \; fields <<<"$IN"
fields=("${fields[@]%$'\n'}")   # drop '\n' added by '<<<'

使用mapfile，您还可以跳过声明数组，并隐式“循环”分隔元素，对每个元素调用一个函数：

myPubliMail() {
    printf "Seq: %6d: Sending mail to '%s'..." $1 "$2"
    # mail -s "This is not a spam..." "$2" </path/to/body
    printf "\e[3D, done.\n"
}

mapfile < <(printf "%s\0" "$IN") -td \; -c 1 -C myPubliMail

（注意：如果您不关心字符串末尾的空字段或它们不存在，则格式字符串末尾的\0无效。）

mapfile < <(echo -n "$IN") -td \; -c 1 -C myPubliMail

# Seq:      0: Sending mail to 'bla@some.com', done.
# Seq:      1: Sending mail to 'john@home.com', done.
# Seq:      2: Sending mail to 'Full Name <fulnam@other.org>', done.

或者可以使用<<<，在函数体中包含一些处理来删除它添加的换行符：

myPubliMail() {
    local seq=$1 dest="${2%$'\n'}"
    printf "Seq: %6d: Sending mail to '%s'..." $seq "$dest"
    # mail -s "This is not a spam..." "$dest" </path/to/body
    printf "\e[3D, done.\n"
}

mapfile <<<"$IN" -td \; -c 1 -C myPubliMail

# Renders the same output:
# Seq:      0: Sending mail to 'bla@some.com', done.
# Seq:      1: Sending mail to 'john@home.com', done.
# Seq:      2: Sending mail to 'Full Name <fulnam@other.org>', done.

基于shell中的分隔符拆分字符串

如果你不能使用bash，或者你想写一些可以在许多不同的shell中使用的东西，你通常不能使用bashms——这包括我们在上面的解决方案中使用的数组。

然而，我们不需要使用数组来循环字符串的“元素”。在许多shell中，有一种语法用于从模式的第一次或最后一次出现中删除字符串的子字符串。请注意，*是一个通配符，表示零个或多个字符：

（到目前为止发布的任何解决方案中都没有这种方法，这是我写这个答案的主要原因；）

${var#*SubStr}  # drops substring from start of string up to first occurrence of `SubStr`
${var##*SubStr} # drops substring from start of string up to last occurrence of `SubStr`
${var%SubStr*}  # drops substring from last occurrence of `SubStr` to end of string
${var%%SubStr*} # drops substring from first occurrence of `SubStr` to end of string

如Score_Bow所述：

#和%分别从字符串的开头和结尾删除可能最短的匹配子字符串，以及##和%%删除可能最长的匹配子字符串。

使用上述语法，我们可以创建一种方法，通过删除分隔符之前或之后的子字符串，从字符串中提取子字符串“元素”。

下面的代码块在bash（包括Mac OS的bash）、dash、ksh、lksh、yash、zsh和busybox的ash中运行良好：

（感谢Adam Katz的评论，使这个循环更加简单！）

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
while [ "$IN" != "$iter" ] ;do
    # extract the substring from start of string up to delimiter.
    iter=${IN%%;*}
    # delete this first "element" AND next separator, from $IN.
    IN="${IN#$iter;}"
    # Print (or doing anything with) the first "element".
    printf '> [%s]\n' "$iter"
done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

为什么不剪？

cut用于提取大文件中的列，但重复执行fork（var=$（echo…|cut…））会很快变得过火！

这是一个正确的语法，在许多posix shell下使用cut进行测试，如DougW的另一个答案所建议的：

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
i=1
while iter=$(echo "$IN"|cut -d\; -f$i) ; [ -n "$iter" ] ;do
    printf '> [%s]\n' "$iter"
    i=$((i+1))
done

我写这个是为了比较执行时间。

在我的树莓皮上，这看起来像：

$ export TIMEFORMAT=$'(%U + %S) / \e[1m%R\e[0m : %P  '
$ time sh splitDemo.sh >/dev/null
(0.000 + 0.019) / 0.019 : 99.63  
$ time sh splitDemo_cut.sh >/dev/null
(0.051 + 0.041) / 0.188 : 48.98  

这里的总执行时间大约是10倍长，使用1个叉进行切割，按场计算！

我看到了一些引用cut命令的答案，但它们都被删除了。有点奇怪的是，没有人详细阐述过这一点，因为我认为这是执行这类任务更有用的命令之一，尤其是用于解析分隔的日志文件。

在将这个特定示例拆分为bash脚本数组的情况下，tr可能效率更高，但可以使用cut，如果您想从中间拉取特定字段，则更有效。

例子：

$ echo "bla@some.com;john@home.com" | cut -d ";" -f 1
bla@some.com
$ echo "bla@some.com;john@home.com" | cut -d ";" -f 2
john@home.com

显然，您可以将其放入一个循环中，并迭代-f参数以独立拉动每个字段。

当您有一个分隔的日志文件，其中包含如下行时，这会更有用：

2015-04-27|12345|some action|an attribute|meta data

cut非常方便，能够抓取这个文件并选择一个特定的字段进行进一步处理。

也许不是最优雅的解决方案，但可以使用*和空格：

IN="bla@so me.com;*;john@home.com"
for i in `delims=${IN//[^;]}; seq 1 $((${#delims} + 1))`
do
   echo "> [`echo $IN | cut -d';' -f$i`]"
done

输出

> [bla@so me.com]
> [*]
> [john@home.com]

其他示例（开头和结尾的分隔符）：

IN=";bla@so me.com;*;john@home.com;"
> []
> [bla@so me.com]
> [*]
> [john@home.com]
> []

基本上，它会删除除以下字符以外的所有字符：；制作熟食；；；。然后，它执行从1到${#delims}计数的分隔符数的循环。最后一步是使用切割安全地获得$i部分。