我将此字符串存储在变量中：

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

现在我想用;定界符分割字符串，这样我就可以：

ADDR1="bla@some.com"
ADDR2="john@home.com"

我不一定需要 ADDR1和ADDR2变量。如果它们是数组的元素，那就更好了。

经过以下答案的建议后，我得出了以下结论：

#!/usr/bin/env bash

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

mails=$(echo $IN | tr ";" "\n")

for addr in $mails
do
    echo "> [$addr]"
done

输出：

> [bla@some.com]
> [john@home.com]

解决方案涉及设置Internal_field_separator（IFS）为;。我不确定该答案发生了什么，如何重置IFS为默认值？

RE：IFS解决方案，我尝试过了，而且可行，我保留了旧的IFS，然后将其还原：

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

OIFS=$IFS
IFS=';'
mails2=$IN
for x in $mails2
do
    echo "> [$x]"
done

IFS=$OIFS

顺便说一句，当我尝试

mails2=($IN)

循环打印时，我只有第一个字符串，但没有括号$IN可以使用。

您可以设置内部字段分隔符（IFS）变量，然后将其解析为数组。如果在命令中发生这种情况，则IFS仅对单个命令的环境（to read）进行分配。然后，它根据IFS变量值将输入解析为一个数组，然后可以对其进行迭代。

IFS=';' read -ra ADDR <<< "$IN"
for i in "${ADDR[@]}"; do
    # process "$i"
done

它将解析由分隔的一行项目;，并将其推入数组。用于处理全部内容的材料$IN，每次输入一行时，请用;：

 while IFS=';' read -ra ADDR; do
      for i in "${ADDR[@]}"; do
          # process "$i"
      done
 done <<< "$IN"

取自Bash shell脚本split array：

IN="bla@some.com;john@home.com"
arrIN=(${IN//;/ })

说明：

这种结构替换所有出现';'（初始//手段全局替换）字符串中IN有' '（单个空格），然后将以空格分隔的字符串解释为一个数组（这就是括号的作用）。

花括号内用一个';'字符替换每个字符的语法' '称为参数扩展。

有一些常见的陷阱：

1. 如果原始字符串中有空格，则需要使用IFS：
   • IFS=':'; arrIN=($IN); unset IFS;
2. 如果原始字符串包含空格并且定界符是换行符，则可以使用以下命令设置IFS：
   • IFS=$'\n'; arrIN=($IN); unset IFS;

如果您不介意立即处理它们，我喜欢这样做：

for i in $(echo $IN | tr ";" "\n")
do
  # process
done

您可以使用这种循环来初始化数组，但是可能有一种更简单的方法来执行此操作。希望这会有所帮助。

兼容答案

有很多不同的方法可以做到这一点 重击。

但是，重要的是要首先注意到它bash具有许多其他功能无法使用的特殊功能（所谓的bashisms）贝壳。

特别是，本文中的解决方案以及线程中的其他解决方案中使用的array，关联数组和模式替换是一种bashisms，可能无法在许多人使用的其他shell下工作。

例如：在我的Debian GNU / Linux上，有一个标准叫壳短跑; 我知道很多人喜欢使用另一个称为sh; 还有一个叫做忙箱 用他自己的shell解释器（灰）。

要求的字串

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

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

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

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

根据中的定界符分割字符串 重击 （版本> = 4.2）

在pure中 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>")

请注意，这read是进行拆分的最快方法，因为没有调用派生或外部资源。

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

# `"${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>]

更新：最近 重击 > = 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.

根据中的定界符分割字符串 贝壳

如果您不能使用bash，或者想要编写可以在许多不同的shell中使用的东西，那么您通常就不能使用bashisms－这包括我们在上面的解决方案中一直使用的数组。

但是，我们不需要使用数组来循环字符串的“元素”。许多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_Under所述：

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

##并%%删除可能的最长匹配子字符串。

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

下面的代码块在 重击 （包括Mac OS的 bash），短跑， sh和 忙箱的 灰：

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
while [ "$IN" ] ;do
    # extract the substring from start of string up to delimiter.
    # this is the first "element" of the string.
    iter=${IN%%;*}
    echo "> [$iter]"
    # if there's only one element left, set `IN` to an empty string.
    # this causes us to exit this `while` loop.
    # else, we delete the first "element" of the string from IN, and move onto the next.
    [ "$IN" = "$iter" ] && \
        IN='' || \
        IN="${IN#*;}"
  done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

玩得开心！

我已经看到了几个引用该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能够很方便地访问cat此文件并选择特定字段以进行进一步处理。

这为我工作：

string="1;2"
echo $string | cut -d';' -f1 # output is 1
echo $string | cut -d';' -f2 # output is 2

这种方法怎么样：

IN="bla@some.com;john@home.com" 
set -- "$IN" 
IFS=";"; declare -a Array=($*) 
echo "${Array[@]}" 
echo "${Array[0]}" 
echo "${Array[1]}" 

资源

我认为AWK是解决您问题的最佳且有效的命令。默认情况下，几乎每个Linux发行版都包含AWK。

echo "bla@some.com;john@home.com" | awk -F';' '{print $1,$2}'

会给

bla@some.com john@home.com

当然，您可以通过重新定义awk打印字段来存储每个电子邮件地址。

echo "bla@some.com;john@home.com" | sed -e 's/;/\n/g'
bla@some.com
john@home.com

这也适用：

IN="bla@some.com;john@home.com"
echo ADD1=`echo $IN | cut -d \; -f 1`
echo ADD2=`echo $IN | cut -d \; -f 2`

请注意，此解决方案并不总是正确的。如果仅传递“ bla@some.com”，它将把它分配给ADD1和ADD2。

对Darron的答案有不同的看法，这就是我的做法：

IN="bla@some.com;john@home.com"
read ADDR1 ADDR2 <<<$(IFS=";"; echo $IN)

在Bash中，这是一种防弹方式，即使您的变量包含换行符，该方法也将起作用：

IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")

看：

$ in=$'one;two three;*;there is\na newline\nin this field'
$ IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")
$ declare -p array
declare -a array='([0]="one" [1]="two three" [2]="*" [3]="there is
a newline
in this field")'

起作用的技巧是将（delimiter）-d选项read与一个空的定界符一起使用，以便read强制读取它提供的所有内容。而且我们read准确地输入了变量的内容in，而没有尾随换行符printf。请注意，这也是我们还要放入定界符，printf以确保传递给的字符串read具有尾随定界符。没有它，read将修剪潜在的尾随空白字段：

$ in='one;two;three;'    # there's an empty field
$ IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")
$ declare -p array
declare -a array='([0]="one" [1]="two" [2]="three" [3]="")'

尾随的空白字段将保留。

Bash≥4.4的更新

从Bash 4.4开始，内置的mapfile（aka readarray）支持-d指定分隔符的选项。因此，另一种规范的方式是：

mapfile -d ';' -t array < <(printf '%s;' "$in")

如果您不使用数组，那么这种衬板怎么样：

IFS=';' read ADDR1 ADDR2 <<<$IN

无需设置IFS

如果您只有一个冒号，您可以这样做：

a="foo:bar"
b=${a%:*}
c=${a##*:}

你会得到：

b = foo
c = bar

这是干净的三层纸：

in="foo@bar;bizz@buzz;fizz@buzz;buzz@woof"
IFS=';' list=($in)
for item in "${list[@]}"; do echo $item; done

其中IFS基于分隔符分隔单词并()用于创建数组。然后[@]用于将每个项目作为单独的单词返回。

如果之后有任何代码，则还需要还原$IFS，例如unset IFS。

以下Bash / zsh函数在第二个参数给定的分隔符上拆分其第一个参数：

split() {
    local string="$1"
    local delimiter="$2"
    if [ -n "$string" ]; then
        local part
        while read -d "$delimiter" part; do
            echo $part
        done <<< "$string"
        echo $part
    fi
}

例如，命令

$ split 'a;b;c' ';'

产量

a
b
c

例如，该输出可以通过管道传递给其他命令。例：

$ split 'a;b;c' ';' | cat -n
1   a
2   b
3   c

与给出的其他解决方案相比，该解决方案具有以下优点：

• IFS不会被覆盖：由于甚至局部变量都具有动态作用域，因此覆盖IFS循环会导致新值泄漏到从循环内部执行的函数调用中。

• 不使用数组：使用将字符串读入数组read需要-aBash和-Azsh中的标志。

如果需要，可以将该函数放入脚本中，如下所示：

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

您可以在许多情况下使用awk

echo "bla@some.com;john@home.com"|awk -F';' '{printf "%s\n%s\n", $1, $2}'

你也可以用这个

echo "bla@some.com;john@home.com"|awk -F';' '{print $1,$2}' OFS="\n"

有一种简单而聪明的方法，如下所示：

echo "add:sfff" | xargs -d: -i  echo {}

但是您必须使用gnu xargs，BSD xargs无法支持-d delim。如果您像我一样使用苹果Mac。您可以安装gnu xargs：

brew install findutils

然后

echo "add:sfff" | gxargs -d: -i  echo {}

这是最简单的方法。

spo='one;two;three'
OIFS=$IFS
IFS=';'
spo_array=($spo)
IFS=$OIFS
echo ${spo_array[*]}

这里有一些很酷的答案（特别是错误），但是对于类似于其他语言的东西来说，这就是我最初想表达的意思，我就此解决了：

IN="bla@some.com;john@home.com"
declare -a a="(${IN/;/ })";

现在${a[0]}，，${a[1]}等等，正如您所期望的。使用${#a[*]}的条款的数目。还是要迭代，当然：

for i in ${a[*]}; do echo $i; done

重要的提示：

这在没有空间可担心的情况下可以解决我的问题，但可能无法解决您的问题。$IFS在这种情况下，请使用解决方案。

IN="bla@some.com;john@home.com"
IFS=';'
read -a IN_arr <<< "${IN}"
for entry in "${IN_arr[@]}"
do
    echo $entry
done

输出量

bla@some.com
john@home.com

系统：Ubuntu 12.04.1

如果没有空间，为什么不这样做呢？

IN="bla@some.com;john@home.com"
arr=(`echo $IN | tr ';' ' '`)

echo ${arr[0]}
echo ${arr[1]}

使用set内置的方法加载$@阵列：

IN="bla@some.com;john@home.com"
IFS=';'; set $IN; IFS=$' \t\n'

然后，让聚会开始：

echo $#
for a; do echo $a; done
ADDR1=$1 ADDR2=$2

两个不需bash阵列的本地选择：

情况1：保持简单易懂：使用NewLine作为Record-Separator...。

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

while read i; do
  # process "$i" ... eg.
    echo "[email:$i]"
done <<< "$IN"

注意：在第一种情况下，不会分叉任何子流程来协助进行列表操作。

想法：也许值得在内部广泛使用NL ，并且只有在外部生成最终结果时才转换为其他RS 。

情况2：使用“;” 作为记录分隔符...例如

NL="
" IRS=";" ORS=";"

conv_IRS() {
  exec tr "$1" "$NL"
}

conv_ORS() {
  exec tr "$NL" "$1"
}

IN="bla@some.com;john@home.com"
IN="$(conv_IRS ";" <<< "$IN")"

while read i; do
  # process "$i" ... eg.
    echo -n "[email:$i]$ORS"
done <<< "$IN"

在这两种情况下，循环中可以组成的子列表在循环完成之后是持久的。当在内存中处理列表而不是将列表存储在文件中时，这很有用。{ps保持冷静并继续进行B-）}

除了已经提供的奇妙答案外，如果仅打印出数据，您可以考虑使用awk：

awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"

这;会将字段分隔符设置为，以便它可以使用for并进行相应打印。

测试

$ IN="bla@some.com;john@home.com"
$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"
> [bla@some.com]
> [john@home.com]

用另一个输入：

$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "a;b;c   d;e_;f"
> [a]
> [b]
> [c   d]
> [e_]
> [f]

在Android Shell中，大多数建议的方法都不起作用：

$ IFS=':' read -ra ADDR <<<"$PATH"                             
/system/bin/sh: can't create temporary file /sqlite_stmt_journals/mksh.EbNoR10629: No such file or directory

起作用的是：

$ for i in ${PATH//:/ }; do echo $i; done
/sbin
/vendor/bin
/system/sbin
/system/bin
/system/xbin

其中//表示全球替换。

IN='bla@some.com;john@home.com;Charlie Brown <cbrown@acme.com;!"#$%&/()[]{}*? are no problem;simple is beautiful :-)'
set -f
oldifs="$IFS"
IFS=';'; arrayIN=($IN)
IFS="$oldifs"
for i in "${arrayIN[@]}"; do
echo "$i"
done
set +f

输出：

bla@some.com
john@home.com
Charlie Brown <cbrown@acme.com
!"#$%&/()[]{}*? are no problem
simple is beautiful :-)

说明：使用括号（）的简单赋值会将分号分隔的列表转换为数组，前提是您在执行此操作时具有正确的IFS。标准FOR循环照常处理该数组中的单个项目。请注意，为IN变量提供的列表必须用“硬”引号括起来，即带有单个刻度。

必须保存和还原IFS，因为Bash不会以与命令相同的方式对待分配。另一种解决方法是将分配包装在函数内，然后使用修改后的IFS调用该函数。在这种情况下，不需要单独保存/恢复IFS。感谢“ Bize”指出这一点。

大家好！

这是我的答案！

DELIMITER_VAL='='

read -d '' F_ABOUT_DISTRO_R <<"EOF"
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=14.04
DISTRIB_CODENAME=trusty
DISTRIB_DESCRIPTION="Ubuntu 14.04.4 LTS"
NAME="Ubuntu"
VERSION="14.04.4 LTS, Trusty Tahr"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 14.04.4 LTS"
VERSION_ID="14.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
EOF

SPLIT_NOW=$(awk -F$DELIMITER_VAL '{for(i=1;i<=NF;i++){printf "%s\n", $i}}' <<<"${F_ABOUT_DISTRO_R}")
while read -r line; do
   SPLIT+=("$line")
done <<< "$SPLIT_NOW"
for i in "${SPLIT[@]}"; do
    echo "$i"
done

为什么这种方法对我来说是“最好的”？

有两个原因：

1. 您无需转义分隔符；
2. 您将不会有空格的问题。该值将在数组中正确分隔！

[]的

单线分割用';'分隔的字符串 放入数组是：

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

这仅将IFS设置在子外壳中，因此您不必担心保存和恢复其值。

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

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]
> []

基本上，它消除了比其他的每一个字符;使delims如。;;;。然后，它会for从循环1到number-of-delimiters，由计数${#delims}。最后一步是使用来安全地获取该$i部分cut。