Tôi có chuỗi này được lưu trữ trong một biến:

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

Bây giờ tôi muốn phân tách các chuỗi bằng ;dấu phân cách để tôi có:

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

Tôi không nhất thiết cần ADDR1và ADDR2các biến. Nếu chúng là các phần tử của một mảng thậm chí còn tốt hơn.

Sau những gợi ý từ các câu trả lời dưới đây, tôi đã kết thúc với những điều sau đây là:

#!/usr/bin/env bash

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

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

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

Đầu ra:

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

Có một giải pháp liên quan đến việc đặt Internal_field_separator (IFS) thành ;. Tôi không chắc điều gì đã xảy ra với câu trả lời đó, làm thế nào để bạn đặt IFSlại về mặc định?

RE: IFSgiải pháp, tôi đã thử cái này và nó hoạt động, tôi giữ cái cũ IFSvà sau đó khôi phục nó:

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

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

IFS=$OIFS

BTW, khi tôi đã cố gắng

mails2=($IN)

Tôi chỉ có chuỗi đầu tiên khi in nó trong vòng lặp, không có dấu ngoặc quanh $INnó hoạt động.

Bạn có thể đặt biến phân tách trường bên trong (IFS), sau đó để nó phân tích thành một mảng. Khi điều này xảy ra trong một lệnh, thì việc gán IFSchỉ diễn ra trong môi trường của lệnh đó (đến read). Sau đó, nó phân tích cú pháp đầu vào theo IFSgiá trị biến thành một mảng, sau đó chúng ta có thể lặp lại.

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

Nó sẽ phân tích một dòng các mục được phân tách bằng cách ;đẩy nó vào một mảng. Công cụ xử lý toàn bộ $IN, mỗi lần một dòng đầu vào được phân tách bằng ;:

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

Lấy từ mảng phân tách shell Bash :

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

Giải trình:

Cấu trúc này thay thế tất cả các lần xuất hiện ';'(ban đầu //có nghĩa là thay thế toàn cầu) trong chuỗi INbằng ' '(một khoảng trắng), sau đó diễn giải chuỗi phân tách không gian thành một mảng (đó là những gì các dấu ngoặc đơn xung quanh làm).

Cú pháp được sử dụng bên trong các dấu ngoặc nhọn để thay thế mỗi ';'ký tự bằng một ' 'ký tự được gọi là Mở rộng tham số .

Có một số vấn đề phổ biến:

1. Nếu chuỗi gốc có khoảng trắng, bạn sẽ cần sử dụng IFS :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Nếu chuỗi gốc có khoảng trắng và dấu phân cách là một dòng mới, bạn có thể đặt IFS với:
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Nếu bạn không ngại xử lý chúng ngay lập tức, tôi thích làm điều này:

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

Bạn có thể sử dụng loại vòng lặp này để khởi tạo một mảng, nhưng có lẽ có một cách dễ dàng hơn để làm điều đó. Hy vọng điều này sẽ giúp, mặc dù.

Câu trả lời tương thích

Có rất nhiều cách khác nhau để làm điều này trong bash.

Tuy nhiên, điều quan trọng cần lưu ý đầu tiên là bashcó nhiều tính năng đặc biệt (được gọi là bashism ) sẽ không hoạt động trong bất kỳ tính năng nào khácvỏ.

Đặc biệt, mảng , mảng kết hợp , và thay thế mô hình , được sử dụng trong các giải pháp trong bài viết này cũng như những người khác trong các chủ đề, là bashisms và có thể không làm việc dưới khác vỏ mà nhiều người sử dụng.

Ví dụ: trên Debian GNU / Linux của tôi , có một vỏ tiêu chuẩn được gọi làdấu gạch ngang; Tôi biết nhiều người thích sử dụng một vỏ khác được gọi làksh; và cũng có một công cụ đặc biệt gọi làbận rộn với trình thông dịch shell của riêng mình (tro).

Chuỗi yêu cầu

Chuỗi được phân chia trong câu hỏi trên là:

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

Tôi sẽ sử dụng một phiên bản sửa đổi của chuỗi này để đảm bảo rằng giải pháp của tôi mạnh mẽ đối với các chuỗi chứa khoảng trắng, có thể phá vỡ các giải pháp khác:

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

Chia chuỗi dựa trên dấu phân cách trong bash (phiên bản> = 4.2)

Trong sạch bash , chúng ta có thể tạo một mảng với các phần tử được phân tách bằng một giá trị tạm thời cho IFS ( dấu tách trường đầu vào ). IFS, trong số những thứ khác, cho biết bash(các) ký tự nào sẽ được coi là dấu phân cách giữa các phần tử khi xác định một mảng:

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

Trong các phiên bản mới hơn của bash, tiền tố một lệnh với một định nghĩa IFS thay đổi IFS cho lệnh đó chỉ và resets nó với giá trị trước đó ngay lập tức sau đó. Điều này có nghĩa là chúng ta có thể làm như trên chỉ trong một dòng:

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'

Chúng ta có thể thấy rằng chuỗi INđã được lưu trữ thành một mảng có tên fields, được phân chia trên dấu chấm phẩy:

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>'

(Chúng tôi cũng có thể hiển thị nội dung của các biến này bằng cách sử dụng 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>")

Lưu ý rằng đó readlà cách nhanh nhất để thực hiện phân tách vì không có nhánh hoặc tài nguyên bên ngoài được gọi.

Khi mảng được xác định, bạn có thể sử dụng một vòng lặp đơn giản để xử lý từng trường (hoặc, đúng hơn là từng phần tử trong mảng mà bạn đã xác định bây giờ):

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

Hoặc bạn có thể thả từng trường từ mảng sau khi xử lý bằng cách sử dụng phương pháp dịch chuyển , mà tôi thích:

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

Và nếu bạn chỉ muốn một bản in đơn giản của mảng, bạn thậm chí không cần phải lặp lại nó:

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

Cập nhật: gần đây bash > = 4,4

Trong các phiên bản mới hơn bash, bạn cũng có thể chơi với lệnh mapfile:

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

Cú pháp này bảo tồn các ký tự đặc biệt, dòng mới và các trường trống!

Nếu bạn không muốn bao gồm các trường trống, bạn có thể làm như sau:

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

Với mapfile, bạn cũng có thể bỏ qua việc khai báo một mảng và ngầm "lặp" qua các phần tử được phân tách, gọi một hàm trên mỗi:

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

(Lưu ý: \0ở cuối chuỗi định dạng là vô ích nếu bạn không quan tâm đến các trường trống ở cuối chuỗi hoặc chúng không có mặt.)

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.

Hoặc bạn có thể sử dụng <<<và trong thân hàm bao gồm một số xử lý để bỏ dòng mới, nó thêm vào:

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.

Chia chuỗi dựa trên dấu phân cách trong vỏ

Nếu bạn không thể sử dụng bashhoặc nếu bạn muốn viết một cái gì đó có thể được sử dụng trong nhiều shell khác nhau, bạn thường không thể sử dụng bashism - và điều này bao gồm các mảng chúng tôi đã sử dụng trong các giải pháp ở trên.

Tuy nhiên, chúng ta không cần sử dụng mảng để lặp lại "các phần tử" của chuỗi. Có một cú pháp được sử dụng trong nhiều shell để xóa các chuỗi con của chuỗi từ lần xuất hiện đầu tiên hoặc lần cuối của mẫu. Lưu ý rằng đó *là ký tự đại diện cho không hoặc nhiều ký tự:

(Việc thiếu cách tiếp cận này trong bất kỳ giải pháp nào được đăng cho đến nay là lý do chính khiến tôi viết câu trả lời này;)

${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

Theo giải thích của Score_Under :

#và %xóa chuỗi con phù hợp ngắn nhất có thể từ đầu và cuối chuỗi tương ứng, và

##và %%xóa chuỗi con phù hợp dài nhất có thể.

Sử dụng cú pháp trên, chúng ta có thể tạo một cách tiếp cận trong đó chúng ta trích xuất các "phần tử" của chuỗi con khỏi chuỗi bằng cách xóa các chuỗi con lên đến hoặc sau dấu phân cách.

Các codeblock dưới đây hoạt động tốt trong bash(bao gồm cả Mac OS bash),dấu gạch ngang, kshvà bận rộn'S tro:

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

Chúc vui vẻ!

Tôi đã thấy một vài câu trả lời tham khảo cutlệnh, nhưng tất cả chúng đều bị xóa. Có một điều kỳ lạ là không ai giải thích được điều đó, vì tôi nghĩ đó là một trong những lệnh hữu ích hơn để thực hiện loại điều này, đặc biệt là để phân tích các tệp nhật ký được phân tách.

Trong trường hợp tách ví dụ cụ thể này thành một mảng bash script, trcó thể hiệu quả hơn, nhưng cutcó thể được sử dụng và hiệu quả hơn nếu bạn muốn kéo các trường cụ thể từ giữa.

Thí dụ:

$ 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

Rõ ràng bạn có thể đặt nó vào một vòng lặp và lặp lại tham số -f để kéo từng trường một cách độc lập.

Điều này hữu ích hơn khi bạn có tệp nhật ký được phân tách bằng các hàng như thế này:

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

cutrất thuận tiện để có thể vào cattập tin này và chọn một trường cụ thể để xử lý thêm.

Điều này làm việc cho tôi:

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

Cách tiếp cận này:

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

Nguồn

Tôi nghĩ AWK là lệnh tốt nhất và hiệu quả để giải quyết vấn đề của bạn. AWK được bao gồm theo mặc định trong hầu hết mọi bản phân phối Linux.

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

sẽ cho

bla@some.com john@home.com

Tất nhiên, bạn có thể lưu trữ từng địa chỉ email bằng cách xác định lại trường in awk.

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

Điều này cũng hoạt động:

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

Hãy cẩn thận, giải pháp này không phải lúc nào cũng đúng. Trong trường hợp bạn chỉ vượt qua "bla@some.com", nó sẽ chỉ định nó cho cả ADD1 và ADD2.

Một cách khác về câu trả lời của Darron , đây là cách tôi thực hiện:

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

Trong Bash, một cách chống đạn, sẽ hoạt động ngay cả khi biến của bạn chứa dòng mới:

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

Nhìn:

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

Mẹo để làm việc này là sử dụng -dtùy chọn read(dấu phân cách) với một dấu phân cách trống, do đó readbuộc phải đọc mọi thứ nó được cho ăn. Và chúng tôi cung cấp readchính xác nội dung của biến in, không có dòng mới nhờ printf. Lưu ý rằng chúng tôi cũng đang đặt dấu phân cách printfđể đảm bảo rằng chuỗi được truyền đến readcó dấu phân cách. Không có nó, readsẽ cắt các trường trống tiềm năng:

$ 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]="")'

các lĩnh vực trống trailing được bảo tồn.

Cập nhật cho Bash≥4.4

Kể từ Bash 4.4, nội dung dựng sẵn mapfile(aka readarray) hỗ trợ -dtùy chọn chỉ định dấu phân cách. Do đó một cách kinh điển khác là:

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

Làm thế nào về một lớp lót này, nếu bạn không sử dụng mảng:

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

Không cần thiết lập IFS

Nếu bạn chỉ có một dấu hai chấm, bạn có thể làm điều đó:

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

bạn sẽ nhận được:

b = foo
c = bar

Dưới đây là 3 lớp lót sạch sẽ:

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

trong đó IFSphân định các từ dựa trên dấu phân cách và ()được sử dụng để tạo một mảng . Sau đó [@]được sử dụng để trả lại mỗi mục dưới dạng một từ riêng biệt.

Nếu bạn có bất kỳ mã nào sau đó, bạn cũng cần khôi phục $IFS, ví dụ unset IFS.

Hàm Bash / zsh sau đây phân tách đối số đầu tiên của nó trên dấu phân cách được đưa ra bởi đối số thứ hai:

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
}

Ví dụ, lệnh

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

sản lượng

a
b
c

Đầu ra này có thể, ví dụ, được dẫn đến các lệnh khác. Thí dụ:

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

So với các giải pháp khác được đưa ra, giải pháp này có những ưu điểm sau:

• IFSkhông bị ghi đè: Do phạm vi động của các biến cục bộ, việc ghi đè IFSlên một vòng lặp làm cho giá trị mới bị rò rỉ vào các lệnh gọi hàm được thực hiện từ bên trong vòng lặp.

• Mảng không được sử dụng: Đọc một chuỗi thành một mảng bằng cách sử dụng readcờ -atrong Bash và -Atrong zsh.

Nếu muốn, chức năng có thể được đưa vào một tập lệnh như sau:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

bạn có thể áp dụng awk cho nhiều tình huống

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

bạn cũng có thể sử dụng cái này

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

Có một cách đơn giản và thông minh như thế này:

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

Nhưng bạn phải sử dụng gnu xargs, BSD xargs không thể hỗ trợ -d delim. Nếu bạn sử dụng apple mac như tôi. Bạn có thể cài đặt gnu xargs:

brew install findutils

sau đó

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

Đây là cách đơn giản nhất để làm điều đó.

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

Có một số câu trả lời thú vị ở đây (errator đặc biệt

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

Bây giờ ${a[0]}, ${a[1]}vv, như bạn mong đợi. Sử dụng ${#a[*]}cho số lượng các điều khoản. Hoặc lặp đi lặp lại, tất nhiên:

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

LƯU Ý QUAN TRỌNG:

Điều này hoạt động trong trường hợp không có không gian để lo lắng, giải quyết vấn đề của tôi, nhưng có thể không giải quyết được vấn đề của bạn. Đi với $IFS(các) giải pháp trong trường hợp đó.

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

Đầu ra

bla@some.com
john@home.com

Hệ thống: Ubuntu 12.04.1

Nếu không có không gian, tại sao không?

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

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

Sử dụng tích sethợp để tải lên $@mảng:

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

Sau đó, hãy để bữa tiệc bắt đầu:

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

Hai lựa chọn thay thế bourne-ish trong đó không yêu cầu mảng bash:

Trường hợp 1 : Giữ cho nó đẹp và đơn giản: Sử dụng NewLine làm Dấu tách bản ghi ... ví dụ:

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

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

Lưu ý: trong trường hợp đầu tiên này, không có quy trình phụ nào được chia rẽ để hỗ trợ thao tác danh sách.

Ý tưởng: Có thể đáng để sử dụng NL rộng rãi trong nội bộ và chỉ chuyển đổi sang RS khác khi tạo kết quả cuối cùng ra bên ngoài .

Trường hợp 2 : Sử dụng dấu ";" như một dấu phân tách hồ sơ ... ví dụ.

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"

Trong cả hai trường hợp, một danh sách phụ có thể được tạo trong vòng lặp vẫn tồn tại sau khi vòng lặp hoàn thành. Điều này hữu ích khi thao tác danh sách trong bộ nhớ, thay vào đó lưu trữ danh sách trong tệp. {ps giữ bình tĩnh và tiếp tục B-)}

Ngoài các câu trả lời tuyệt vời đã được cung cấp, nếu đó chỉ là vấn đề in ra dữ liệu bạn có thể xem xét sử dụng awk:

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

Cái này đặt dấu tách trường thành ;, để nó có thể lặp qua các trường bằng một forvòng lặp và in tương ứng.

Kiểm tra

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

Với đầu vào khác:

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

Trong Android shell, hầu hết các phương thức được đề xuất không hoạt động:

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

Công việc là gì:

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

trong đó //có nghĩa là thay thế toàn cầu.

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

Đầu ra:

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

Giải thích: Phép gán đơn giản sử dụng dấu ngoặc đơn () chuyển đổi danh sách được phân tách bằng dấu chấm phẩy thành một mảng với điều kiện bạn có IFS chính xác trong khi thực hiện điều đó. Vòng lặp FOR tiêu chuẩn xử lý các mục riêng lẻ trong mảng đó như bình thường. Lưu ý rằng danh sách được cung cấp cho biến IN phải được trích dẫn "cứng", nghĩa là với các dấu chọn đơn.

IFS phải được lưu và khôi phục vì Bash không coi một nhiệm vụ giống như một lệnh. Một cách giải quyết khác là bọc phần gán bên trong một hàm và gọi hàm đó bằng IFS đã sửa đổi. Trong trường hợp đó, việc lưu / khôi phục IFS riêng biệt là không cần thiết. Cảm ơn "Bize" đã chỉ ra điều đó.

Được rồi các bạn!

Đây là câu trả lời của tôi!

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

Tại sao phương pháp này là "tốt nhất" đối với tôi?

Vì hai lý do:

1. Bạn không cần phải thoát khỏi dấu phân cách;
2. Bạn sẽ không gặp vấn đề với các khoảng trống . Giá trị sẽ được phân tách đúng trong mảng!

[]'S

Một lớp lót để phân tách một chuỗi cách nhau bởi ';' thành một mảng là:

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

Điều này chỉ đặt IFS trong một nhánh con, vì vậy bạn không phải lo lắng về việc lưu và khôi phục giá trị của nó.

Có thể không phải là giải pháp thanh lịch nhất, nhưng hoạt động với *và không gian:

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

Đầu ra

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

Ví dụ khác (dấu phân cách ở đầu và cuối):

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

Về cơ bản, nó loại bỏ mọi nhân vật khác hơn là ;làm delimsví dụ. ;;;. Sau đó, nó forlặp từ 1đến number-of-delimitersnhư được tính bởi ${#delims}. Bước cuối cùng là $isử dụng phần thứ một một cách an toàn cut.