Mam ten ciąg przechowywany w zmiennej:

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

Teraz chciałbym podzielić ciągi znaków według ;ogranicznika, aby:

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

Niekoniecznie potrzebuję zmiennych ADDR1i ADDR2. Jeśli są to elementy tablicy, które są jeszcze lepsze.

Po sugestiach z poniższych odpowiedzi, skończyłem z następującymi, co było po:

#!/usr/bin/env bash

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

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

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

Wynik:

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

Było rozwiązanie polegające na ustawieniu Internal_field_separator (IFS) na ;. Nie jestem pewien, co się stało z tą odpowiedzią, w jaki sposób przywracasz IFSustawienia domyślne?

RE: IFSrozwiązanie, próbowałem tego i działa, zachowuję stary, IFSa następnie przywracam:

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

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

IFS=$OIFS

BTW, kiedy próbowałem

mails2=($IN)

Pierwszy ciąg mam tylko podczas drukowania w pętli, ale bez nawiasów wokół $INniego działa.

Możesz ustawić zmienną wewnętrznego separatora pól (IFS), a następnie pozwolić jej przeanalizować w tablicy. Kiedy dzieje się tak w poleceniu, wówczas przypisanie do IFSma miejsce tylko w środowisku (pojedynczym) tego polecenia read. Następnie analizuje dane wejściowe zgodnie z IFSwartością zmiennej w tablicy, którą możemy następnie iterować.

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

Spowoduje to przeanalizowanie jednego wiersza elementów oddzielonych przez ;, popychając go do tablicy. Rzeczy do przetwarzania w całości $IN, za każdym razem jeden wiersz danych wejściowych oddzielony ;:

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

Zaczerpnięty z podzielonej tablicy skryptów powłoki Bash :

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

Wyjaśnienie:

Konstrukcja ta zastępuje wszystkie wystąpienia ';'(początkowy //środków globalny zastąpić) w ciągu INz ' '(pojedyncza spacja), a następnie interpretuje ciąg oddzielonych znakiem spacji jako tablica (to co otaczające nawiasy zrobić).

Składnia zastosowana w nawiasach klamrowych w celu zastąpienia każdego ';'znaku ' 'znakiem nosi nazwę Rozszerzenie parametru .

Istnieje kilka typowych błędów:

1. Jeśli oryginalny ciąg ma spacje, musisz użyć IFS :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Jeśli oryginalny ciąg ma spacje, a separator jest nowym wierszem, możesz ustawić IFS za pomocą:
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Jeśli nie masz nic przeciwko natychmiastowemu ich przetworzeniu, lubię to:

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

Możesz użyć tego rodzaju pętli do zainicjowania tablicy, ale prawdopodobnie jest to łatwiejszy sposób. Mam nadzieję, że to pomaga.

Kompatybilna odpowiedź

Można to zrobić na wiele różnych sposobów grzmotnąć.

Jednak ważne jest, aby najpierw zauważyć, że bashma wiele specjalnych funkcji (tak zwanych baszizmów ), które nie będą działać w żadnej innejmuszla.

W szczególności tablice , tablice asocjacyjne i podstawianie wzorców , które są używane w rozwiązaniach w tym poście, a także inne w wątku, są bashizmami i mogą nie działać pod innymi powłokami, z których korzysta wiele osób.

Na przykład: w moim Debian GNU / Linux jest standardowa powłoka o nazwiedziarskość; Znam wielu ludzi, którzy lubią używać innej powłoki o nazwieksh; i istnieje również specjalne narzędzie o nazwiebusybox z własnym tłumaczem powłoki (popiół).

Żądany ciąg

Ciąg do podzielenia w powyższym pytaniu to:

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

Użyję zmodyfikowanej wersji tego ciągu, aby upewnić się, że moje rozwiązanie jest odporne na ciągi zawierające białe znaki, które mogłyby uszkodzić inne rozwiązania:

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

Podziel ciąg na podstawie separatora w grzmotnąć (wersja> = 4.2)

W czystej postaci bash możemy utworzyć tablicę z elementami podzielonymi przez tymczasową wartość dla IFS ( separator pola wejściowego ). IFS wskazuje między innymi, bashktóre znaki należy traktować jako ogranicznik między elementami podczas definiowania tablicy:

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

W nowszych wersjach bash, poprzedzając polecenie z definicji zmienia IFS IFS dla tego polecenia tylko i resetuje go do poprzedniej wartości zaraz potem. Oznacza to, że możemy to zrobić w jednym wierszu:

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'

Widzimy, że ciąg INzostał zapisany w tablicy o nazwie fieldspodzielonej na średniki:

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

(Możemy również wyświetlić zawartość tych zmiennych za pomocą 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>")

Zauważ, że readjest to najszybszy sposób wykonania podziału, ponieważ nie ma wywoływanych widelców ani zasobów zewnętrznych.

Po zdefiniowaniu tablicy możesz użyć prostej pętli do przetworzenia każdego pola (a raczej każdego elementu w tablicy, którą teraz zdefiniowałeś):

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

Lub możesz usunąć każde pole z tablicy po przetworzeniu przy użyciu metody przesunięcia , co lubię:

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

A jeśli chcesz po prostu wydrukować tablicę, nie musisz jej nawet zapętlać:

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

Aktualizacja: ostatnia grzmotnąć > = 4,4

W nowszych wersjach bashmożesz także grać za pomocą polecenia mapfile:

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

Ta składnia chroni specjalne znaki, znaki nowej linii i puste pola!

Jeśli nie chcesz dołączać pustych pól, możesz wykonać następujące czynności:

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

Za pomocą mapfilemożna również pominąć deklarowanie tablicy i niejawnie „zapętlić” ograniczane elementy, wywołując funkcję na każdym:

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

(Uwaga: \0na końcu łańcucha formatu jest bezużyteczne, jeśli nie obchodzi Cię puste pole na końcu łańcucha lub nie ma ich).

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.

Lub możesz użyć <<<, a w treści funkcji włącz trochę przetwarzania, aby usunąć nowy wiersz, który dodaje:

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.

Podziel ciąg na podstawie separatora w muszla

Jeśli nie możesz użyć bashlub chcesz napisać coś, co można wykorzystać w wielu różnych powłokach, często nie możesz użyć bashism - i obejmuje to tablice, których używaliśmy w powyższych rozwiązaniach.

Nie musimy jednak używać tablic do zapętlania „elementów” łańcucha. W wielu powłokach stosowana jest składnia do usuwania podciągów ciągu od pierwszego lub ostatniego wystąpienia wzorca. Pamiętaj, że *jest to symbol wieloznaczny oznaczający zero lub więcej znaków:

(Brak tego podejścia w jakimkolwiek opublikowanym rozwiązaniu jest głównym powodem, dla którego piszę tę odpowiedź;)

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

Jak wyjaśniono w Score_Under :

#i %usuń możliwie najkrótsze pasujące podciąg odpowiednio z początku i końca łańcucha, oraz

##i %%usuń możliwie najdłuższy pasujący podciąg.

Korzystając z powyższej składni, możemy stworzyć podejście, w którym wyodrębniamy „elementy” podłańcucha z ciągu, usuwając podciągi do separatora lub po nim.

Poniższy blok kodu działa dobrze w grzmotnąć(w tym Mac OS bash),dziarskość, ksh, i busybox„s popiół:

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

Baw się dobrze!

Widziałem kilka odpowiedzi dotyczących cutpolecenia, ale wszystkie zostały usunięte. To trochę dziwne, że nikt o tym nie rozwinął, ponieważ uważam, że jest to jedno z bardziej użytecznych poleceń do robienia tego typu rzeczy, szczególnie do analizowania plików dziennika z ogranicznikami.

W przypadku podzielenia tego konkretnego przykładu na tablicę skryptów bash, trjest prawdopodobnie bardziej wydajny, ale cutmożna go użyć i jest bardziej skuteczny, jeśli chcesz wyciągnąć określone pola ze środka.

Przykład:

$ 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

Możesz oczywiście umieścić to w pętli i iterować parametr -f, aby pobrać każde pole niezależnie.

Staje się to bardziej przydatne, gdy masz plik dziennika z ogranicznikami taki jak ten:

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

cutjest bardzo przydatne, aby móc catten plik i wybrać konkretne pole do dalszego przetwarzania.

To działało dla mnie:

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

Co powiesz na to podejście:

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

Źródło

Myślę, że AWK to najlepsze i skuteczne polecenie do rozwiązania twojego problemu. AWK jest domyślnie dołączany do prawie każdej dystrybucji Linuksa.

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

da

bla@some.com john@home.com

Oczywiście możesz zapisać każdy adres e-mail, zmieniając pole drukowania awk.

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

Działa to również:

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

Uważaj, to rozwiązanie nie zawsze jest poprawne. Jeśli przekażesz tylko „bla@some.com”, przypisze to zarówno do ADD1, jak i ADD2.

Inne podejście do odpowiedzi Darrona , oto jak to robię:

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

W Bash: kuloodporny sposób, który zadziała, nawet jeśli twoja zmienna zawiera nowe linie:

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

Popatrz:

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

Sztuczka, aby to zadziałało, polega na użyciu -dopcji read(separatora) z pustym separatorem, aby readzmuszony był odczytać wszystko, co jest zasilane. I karmimy readsię dokładnie zawartością zmiennej in, dzięki czemu nie ma końca nowej linii printf. Pamiętaj, że umieszczamy również ogranicznik, printfaby upewnić się, że przekazywany ciąg readma ogranicznik końcowy. Bez niego readprzycinałoby potencjalne końcowe pola puste:

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

końcowe puste pole zostaje zachowane.

Aktualizacja dla Bash ≥4.4

Od wersji Bash 4.4 wbudowane mapfile(aka readarray) obsługuje -dopcję określania separatora. Stąd innym kanonicznym sposobem jest:

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

Co powiesz na ten jeden liniowiec, jeśli nie używasz tablic:

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

Bez ustawiania IFS

Jeśli masz tylko jeden dwukropek, możesz to zrobić:

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

dostaniesz:

b = foo
c = bar

Oto czysty 3-liniowy:

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

gdzie IFSrozgraniczaj słowa na podstawie separatora i ()służy do tworzenia tablicy . Następnie [@]służy do zwracania każdego elementu jako osobnego słowa.

Jeśli masz później kod, musisz również przywrócić $IFS, np unset IFS.

Następująca funkcja Bash / zsh dzieli swój pierwszy argument na separator podany przez drugi argument:

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
}

Na przykład polecenie

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

daje

a
b
c

Dane wyjściowe mogą być na przykład przesyłane potokowo do innych poleceń. Przykład:

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

W porównaniu z innymi podanymi rozwiązaniami, to ma następujące zalety:

• IFSnie jest zastępowane: Z powodu dynamicznego określania zasięgu nawet zmiennych lokalnych, zastąpienie IFSw pętli powoduje wyciek nowej wartości do wywołań funkcji wykonywanych z poziomu pętli.

• Tablice nie są używane: wczytywanie ciągu do tablicy przy użyciu readwymaga flagi -aw Bash i -Aw zsh.

W razie potrzeby funkcję można umieścić w skrypcie w następujący sposób:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

możesz zastosować awk w wielu sytuacjach

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

możesz także tego użyć

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

Istnieje prosty i sprytny sposób:

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

Ale musisz użyć gnu xargs, BSD xargs nie może obsługiwać -d delim. Jeśli używasz Apple Mac jak ja. Możesz zainstalować gnu xargs:

brew install findutils

następnie

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

To najprostszy sposób na zrobienie tego.

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

Jest tu kilka fajnych odpowiedzi (errator esp.), Ale dla czegoś analogicznego do podzielenia się na inne języki - to właśnie rozumiałem pierwotne pytanie - postanowiłem:

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

Teraz ${a[0]}, ${a[1]}itp, to jak można by oczekiwać. Użyj ${#a[*]}dla wielu terminów. Lub w celu iteracji, oczywiście:

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

WAŻNA UWAGA:

Działa to w przypadkach, gdy nie ma się o co martwić, co rozwiązało mój problem, ale może nie rozwiązać twojego. $IFSW takim przypadku skorzystaj z rozwiązania (rozwiązań).

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

Wynik

bla@some.com
john@home.com

System: Ubuntu 12.04.1

Jeśli nie ma miejsca, dlaczego nie to?

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

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

Użyj setwbudowanego, aby załadować $@tablicę:

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

Następnie zacznij przyjęcie:

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

Dwie alternatywne opcje, w których żadna nie wymaga tablic bash:

Przypadek 1 : Zachowaj prostotę i prostotę: użyj NewLine jako separatora rekordów ... np.

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

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

Uwaga: w tym pierwszym przypadku żaden podproces nie jest rozwidlany, aby pomóc w manipulowaniu listami.

Pomysł: Być może warto intensywnie stosować NL wewnętrznie , a konwersję do innego RS można generować tylko zewnętrznie .

Przypadek 2 : Używanie „;” jako separator rekordów ... np.

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"

W obu przypadkach można utworzyć podlistę w pętli, która jest trwała po zakończeniu pętli. Jest to przydatne podczas manipulowania listami w pamięci zamiast przechowywania list w plikach. {ps zachowaj spokój i kontynuuj B-)}

Oprócz fantastycznych odpowiedzi, które już zostały udzielone, jeśli chodzi tylko o wydrukowanie danych, które możesz rozważyć przy użyciu awk:

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

Spowoduje to ustawienie separatora pól na ;, aby mógł on zapętlać pola za pomocą forpętli i odpowiednio drukować.

Test

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

Z innym wejściem:

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

W powłoce Androida większość proponowanych metod po prostu nie działa:

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

Co działa to:

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

gdzie //oznacza globalną wymianę.

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

Wynik:

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

Objaśnienie: Proste przypisanie za pomocą nawiasu () przekształca listę oddzieloną średnikami w tablicę, pod warunkiem, że podczas wykonywania tej operacji masz poprawny IFS. Standardowa pętla FOR obsługuje poszczególne elementy w tej tablicy jak zwykle. Zauważ, że lista podana dla zmiennej IN musi być „twarda”, tzn. Z pojedynczymi tikami.

IFS musi zostać zapisany i przywrócony, ponieważ Bash nie traktuje przypisania w taki sam sposób jak polecenia. Alternatywnym obejściem jest zawinięcie przypisania do funkcji i wywołanie tej funkcji za pomocą zmodyfikowanego IFS. W takim przypadku oddzielne zapisywanie / przywracanie IFS nie jest potrzebne. Dzięki za „Bize” za zwrócenie na to uwagi.

Okej chłopaki!

Oto moja odpowiedź!

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

Dlaczego takie podejście jest dla mnie „najlepsze”?

Z dwóch powodów:

1. Nie musisz uciekać z ogranicznika;
2. Nie będziesz mieć problemu z pustymi spacjami . Wartość zostanie poprawnie rozdzielona w tablicy!

[]

Jednowarstwowy do dzielenia łańcucha rozdzielonego znakiem „;” w tablicę jest:

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

To tylko ustawia IFS w podpowłoce, więc nie musisz się martwić o zapisywanie i przywracanie jego wartości.

Może nie jest to najbardziej eleganckie rozwiązanie, ale działa z *i spacjami:

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

Wyjścia

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

Inny przykład (ograniczniki na początku i na końcu):

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

Zasadniczo usuwa każdą postać inną niż ;tworzenie delimsnp. ;;;. Następnie wykonuje forpętlę od 1do, number-of-delimiterszgodnie z obliczeniami ${#delims}. Ostatnim krokiem jest bezpieczne zdobycie $itej części cut.