Bir değişken depolanan bu dize var:

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

Şimdi ben dizeleri ;ayırıcı tarafından bölmek istiyorum ki ben var:

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

ADDR1Ve ADDR2değişkenlerine mutlaka ihtiyacım yok . Eğer daha iyi bir dizinin elemanları ise.

Aşağıdaki cevapların önerilerinden sonra, şu şekilde olduğum şeyle sonuçlandım:

#!/usr/bin/env bash

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

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

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

Çıktı:

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

Internal_field_separator (IFS) olarak ayarlanmasıyla ilgili bir çözüm vardı ;. Bu cevapta ne olduğundan emin değilim, IFSvarsayılana nasıl sıfırlarsınız ?

RE: IFSçözüm, bunu denedim ve işe yarıyor, eski tutmak IFSve sonra geri yüklemek:

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

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

IFS=$OIFS

BTW, denediğimde

mails2=($IN)

Sadece ilk dizgiyi döngüde yazdırırken, etrafında köşeli parantez olmadan aldım $IN.

Dahili alan ayırıcı (IFS) değişkenini ayarlayabilir ve bir diziye ayrıştırmasına izin verebilirsiniz . Bu bir komutta gerçekleştiğinde, atama IFSyalnızca o komutun ortamına (to read) gerçekleşir. Daha sonra girdiyi, IFSdeğişken değerine göre bir diziye ayrıştırır ve bunu yineleyebiliriz.

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

;Bir dizi öğeyi bir diziye iterek ayırarak ayrıştırır . $INHer biri bir satır girdi ile ayırarak tümünü işlemek için ;:

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

Alındığı Bash kabuğu komut bölünmüş dizisi :

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

Açıklama:

Bu yapı tüm oluşumları değiştirir ';'(başlangıç //dizesinde araçlarla küresel değiştirin) INile ' ', daha sonra (tek bir boşluk) (en şey bu parantez yapmak) bir dizi olarak boşlukla sınırlandırılmış dize yorumlar.

Kıvrımlı parantezlerin içinde kullanılan ve her ';'karakteri bir ' 'karakterle değiştirmek için kullanılan sözdizimine Parameter Expansion ( Parametre Genişletme) adı verilir .

Bazı yaygın gotcha'lar var:

1. Orijinal dizede boşluklar varsa, IFS kullanmanız gerekir :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Orijinal dizede boşluklar varsa ve ayırıcı yeni bir satırsa, IFS'yi aşağıdakilerle ayarlayabilirsiniz :
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Onları hemen işlemek sakıncası yoksa, bunu yapmak istiyorum:

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

Bir diziyi başlatmak için bu tür bir döngü kullanabilirsiniz, ancak muhtemelen bunu yapmanın daha kolay bir yolu vardır. Umarım bu yardımcı olur.

Uyumlu cevap

Bunu yapmanın birçok farklı yolu var darbe.

Bununla birlikte, ilk olarak bash, diğerlerinde çalışmayan birçok özel özelliğe (sözde bashisms ) sahip olduğunu not etmek önemlidir.kabuk.

Özellikle, bu yazıdaki çözümlerde ve iplikteki diğerlerinde kullanılan diziler , ilişkilendirilebilir diziler ve kalıp ikamesi , bashislerdir ve birçok insanın kullandığı diğer kabuklar altında çalışmayabilir .

Mesela: Benim üzerinde Debian GNU / Linux , bir var standart denilen kabuktire; Başka bir kabuk kullanmayı seven birçok insan tanıyorumksh; ve ayrıca özel bir araç varbusybox kendi kabuk yorumlayıcısıyla (kül).

İstenen dize

Yukarıdaki soruya bölünecek dize:

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

Çözümümün diğer çözümleri kırabilecek boşluk içeren dizelere sağlam olmasını sağlamak için bu dizenin değiştirilmiş bir sürümünü kullanacağım:

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

Dizeyi ayırıcıya dayalı olarak ayır darbe (sürüm> = 4.2)

Olarak saf bash , biz oluşturabilir dizi için geçici bir değer ile elemanlarının bölünmüş IFS ( giriş alanı ayırıcı ). IFS, diğer şeylerin yanı sıra, bashbir diziyi tanımlarken öğeler arasında hangi karakterlere sınırlayıcı olarak davranması gerektiğini söyler :

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

bashKomutunun daha yeni sürümlerinde , bir komutun bir IFS tanımıyla öneklendirilmesi, yalnızca bu komutun IFS'sini değiştirir ve hemen ardından önceki değerine sıfırlar. Bu, yukarıdakileri yalnızca bir satırda yapabileceğimiz anlamına gelir:

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'

Dizenin noktalı virgülle bölünmüş INadlı bir dizide saklandığını görebiliriz 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>'

(Bu değişkenlerin içeriğini de kullanarak görüntüleyebiliriz 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>")

Bölme yapmanın readen hızlı yolunun bu olduğuna dikkat edin çünkü çağrılan çatal veya dış kaynak yoktur .

Dizi tanımlandıktan sonra, her alanı (veya dizideki şimdi tanımladığınız her öğeyi) işlemek için basit bir döngü kullanabilirsiniz:

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

Ya da benim gibi bir kaydırma yaklaşımı kullanarak işledikten sonra dizi her alanı bırakabilirsiniz :

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

Ve dizinin basit bir çıktısını almak istiyorsanız, bunun üzerinde döngü yapmanız bile gerekmez:

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

Güncelleme: son darbe > = 4.4

Yeni sürümlerinde, bashşu komutla da oynayabilirsiniz mapfile:

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

Bu sözdizimi özel karakterleri, yeni satırları ve boş alanları korur!

Boş alanlar eklemek istemiyorsanız aşağıdakileri yapabilirsiniz:

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

İle mapfile, bir dizi bildirmeyi atlayabilir ve her birinde bir işlev çağırarak sınırlandırılmış öğeler üzerinde dolaylı olarak "döngü" oluşturabilirsiniz:

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

(Not: \0Dizenin sonundaki boş alanları umursamıyorsanız veya yoksa, biçim dizesinin sonundaki işe yaramaz.)

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.

Veya kullanabilirsiniz <<<ve işlev gövdesinde eklediği satırsonu bırakmak için bazı işlemler içerir:

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.

Dizeyi ayırıcıya dayalı olarak ayır kabuk

Eğer kullanamıyorsanız bashsize yazma için birçok farklı kabuklar kullanılabilir şey istiyorsanız, ya, sık sık can not kullanmak bashisms - ve bu yukarıda çözümlerde kullanıyorum dizileri içerir.

Ancak, bir dizenin "öğeleri" üzerinde döngü oluşturmak için diziler kullanmamız gerekmez. Bir desenin ilk veya son oluşumundan bir dizenin alt dizelerini silmek için birçok kabukta kullanılan bir sözdizimi vardır . *Sıfır veya daha fazla karakter anlamına gelen joker karakter olduğunu unutmayın :

(Şimdiye kadar yayınlanan herhangi bir çözümde bu yaklaşımın olmaması, bu cevabı yazmamın ana nedenidir;)

${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 tarafından açıklandığı gibi :

#ve sırasıyla dizenin başlangıcından ve sonundan% mümkün olan en kısa eşleşen alt dizeyi silin ve

##ve %%mümkün olan en uzun alt dizeyi silin.

Yukarıdaki sözdizimini kullanarak, alt dizeyi ayırıcıya kadar veya sonra silerek alt dizge "elemanları" dizeden ayıkladığımız bir yaklaşım oluşturabiliriz.

Aşağıdaki kod bloğu, darbe(Mac OS'ler dahil bash),tire, ksh, ve busybox'ler kül:

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

İyi eğlenceler!

cutKomuta referans veren birkaç cevap gördüm, ama hepsi silindi. Kimsenin bunun üzerinde durmaması biraz garip, çünkü bu tür şeyleri yapmak için, özellikle sınırlandırılmış günlük dosyalarını ayrıştırmak için daha kullanışlı komutlardan biri olduğunu düşünüyorum.

Bu özel örneğin bir bash kod dizisine bölünmesi durumunda tr, muhtemelen daha verimlidir, ancak cutkullanılabilir ve belirli alanları ortasından çekmek istiyorsanız daha etkilidir.

Misal:

$ 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

Açıkça bir döngüye koyabilir ve her alanı bağımsız olarak çekmek için -f parametresini yineleyebilirsiniz.

Bu, aşağıdaki gibi satırlara sahip sınırlandırılmış bir günlük dosyanız olduğunda daha kullanışlı olur:

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

cutcatbu dosyayı açmak ve daha sonraki işlemler için belirli bir alanı seçmek çok kullanışlıdır .

Bu benim için çalıştı:

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

Bu yaklaşıma ne dersiniz:

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

Kaynak

AWK , sorununuzu çözmek için en iyi ve verimli komut olduğunu düşünüyorum . AWK, hemen hemen her Linux dağıtımında varsayılan olarak bulunur.

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

verecek

bla@some.com john@home.com

Elbette awk yazdırma alanını yeniden tanımlayarak her e-posta adresini saklayabilirsiniz.

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

Bu ayrıca işe yarar:

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

Dikkatli olun, bu çözüm her zaman doğru değildir. Yalnızca "bla@some.com" u geçmeniz durumunda, hem ADD1 hem de ADD2'ye atayacaktır.

Darron'un cevabına farklı bir bakış , bunu şu şekilde yapıyorum:

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

Bash'te, değişkeniniz yeni satırlar içeriyor olsa bile işe yarayacak kurşun geçirmez bir yol:

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

Bak:

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

Bunun işe yarayacağı şey -d, read(sınırlayıcı) seçeneğini boş bir sınırlayıcı ile kullanmaktır, böylece readbeslendiği her şeyi okumak zorunda kalır. Ve readdeğişkenin içeriği ile besliyoruz in, çünkü takip eden yeni satır olmadan printf. Ayrıca printf, iletilen dizenin readsonunda bir sınırlayıcı bulunduğundan emin olmak için ayırıcıyı da eklediğimizi unutmayın . Onsuz, readpotansiyel boş alanları keserdi:

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

sondaki boş alan korunur.

Bash≥4.4 için güncelleme

Bash 4.4'ten beri yerleşik mapfile(aka readarray) -dbir sınırlayıcı belirtme seçeneğini destekler . Dolayısıyla başka bir kanonik yol:

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

Dizileri kullanmıyorsanız, bu tek astar hakkında:

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

IFS'yi ayarlamadan

Sadece bir kolonunuz varsa bunu yapabilirsiniz:

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

Alacaksın:

b = foo
c = bar

İşte temiz bir 3-astar:

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

burada IFSayırıcıya dayalı sözcükleri sınırlar ve ()bir dizi oluşturmak için kullanılır . Ardından [@]her öğeyi ayrı bir sözcük olarak döndürmek için kullanılır.

Bundan sonra herhangi bir kodunuz varsa $IFS, örneğin geri yüklemeniz de gerekir unset IFS.

Aşağıdaki Bash / zsh işlevi, ilk bağımsız değişkenini ikinci bağımsız değişken tarafından verilen ayırıcıya böler:

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
}

Örneğin, komut

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

verim

a
b
c

Bu çıktı, örneğin, diğer komutlara yönlendirilebilir. Misal:

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

Verilen diğer çözümlerle karşılaştırıldığında, bu aşağıdaki avantajlara sahiptir:

• IFSgeçersiz kılınmaz: Yerel değişkenlerin dinamik kapsamı nedeniyle, IFSbir döngü üzerinden geçersiz kılma , yeni değerin döngü içinden gerçekleştirilen işlev çağrılarına sızmasına neden olur.

• Diziler kullanılmaz: Bir dizeyi kullanarak bir diziye okumak için Bash ve zsh'de readbayrak gerekir .-a-A

İstenirse, işlev aşağıdaki gibi bir komut dosyasına yerleştirilebilir:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

awk'yi birçok duruma uygulayabilirsiniz

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

ayrıca bunu kullanabilirsiniz

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

Bunun gibi basit ve akıllı bir yol var:

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

Ama gnu xargs kullanmalısınız, BSD xargs -d sınırlamasını destekleyemez. Benim gibi apple mac kullanıyorsanız. Gnu xargs yükleyebilirsiniz:

brew install findutils

sonra

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

Bunu yapmanın en basit yolu bu.

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

Burada bazı güzel cevaplar var (errator esp.), Ancak diğer dillere bölmek için benzer bir şey için - bu, orijinal soruyu aldım demek - buna karar verdim:

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

Şimdi ${a[0]}, ${a[1]}vs, beklediğiniz gibi. ${#a[*]}Terim sayısı için kullanın . Ya da yinelemek gerekirse:

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

ÖNEMLİ NOT:

Bu, endişelenecek yerlerin olmadığı, sorunumu çözdüğü, ancak sizinkinizi çözemeyeceği durumlarda işe yarar. İle gidin $IFSbu durumda çözelti (ler).

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

Çıktı

bla@some.com
john@home.com

Sistem: Ubuntu 12.04.1

Yer yoksa, neden olmasın?

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

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

Diziyi setyüklemek için yerleşik olanı kullanın $@:

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

Sonra partinin başlamasına izin verin:

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

Her ikisinin bash dizileri gerektirmediği iki bourne-ish alternatifi:

Durum 1 : Güzel ve basit tutun: Kayıt Ayırıcı olarak NewLine kullanın ... örn.

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

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

Not: Bu ilk durumda, liste manipülasyonuna yardımcı olacak hiçbir alt süreç çatallanmaz.

Fikir: Belki de NL'yi dahili olarak kapsamlı bir şekilde kullanmaya ve harici olarak nihai sonucu oluştururken sadece farklı bir RS'ye dönüştürmeye değer .

Durum 2 : Bir ";" bir kayıt ayırıcı olarak ... örn.

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"

Her iki durumda da, döngü tamamlandıktan sonra döngü içinde bir alt liste oluşturulabilir. Bu, listeleri listelerde değiştirirken, dosyaları listelerde saklarken yararlıdır. {ps sakin olun ve devam edin B-)}

Daha önce verilen fantastik cevapların yanı sıra, sadece kullanmayı düşündüğünüz verileri yazdırmakla ilgiliyse awk:

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

Bu, alan ayırıcısını ;, bir döngü ile alanlar arasında fordöngü yapıp buna göre yazdıracak şekilde ayarlar .

Ölçek

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

Başka bir girişle:

$ 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 kabuğunda, önerilen yöntemlerin çoğu işe yaramaz:

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

Ne işe yarar:

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

burada //küresel değiştirme anlamına gelir.

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

Çıktı:

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

Açıklama: Parantez () kullanılarak yapılan basit atama, noktalı virgülle ayrılmış listeyi, bunu yaparken doğru IFS'ye sahip olmanız koşuluyla bir diziye dönüştürür. Standart FOR döngüsü, bu dizideki öğeleri tek tek her zamanki gibi işler. IN değişkeni için verilen listenin "sert", yani tek kenelerle belirtilmesi gerektiğine dikkat edin.

Bash bir atamaya komutla aynı şekilde davranmadığı için IFS kaydedilmeli ve geri yüklenmelidir. Alternatif bir çözüm, atamayı bir işlevin içine sarmak ve bu işlevi değiştirilmiş bir IFS ile çağırmaktır. Bu durumda, IFS'nin ayrı olarak kaydedilmesi / geri yüklenmesi gerekmez. "Bize" işaret ettiğiniz için teşekkür ederiz.

Tamam çocuklar!

İşte cevabım!

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

Neden bu yaklaşım benim için "en iyisi"?

İki nedenden dolayı:

1. Sınırlayıcıdan kaçmanıza gerek yoktur ;
2. Boş alanlarda sorun yaşamayacaksınız . Değer dizide düzgün şekilde ayrılacaktır!

[] 'İn

';' İle ayrılmış bir dizeyi bölmek için tek astar bir diziye:

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

Bu yalnızca IFS'yi bir alt kabukta ayarlar, bu nedenle değerini kaydetme ve geri yükleme konusunda endişelenmenize gerek yoktur.

Belki de en zarif çözüm değil, aynı zamanda *ve boşluklarla çalışır :

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

çıktılar

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

Diğer örnek (başlangıç ​​ve bitişteki sınırlayıcılar):

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

Temelde, örneğin ;yapmaktan başka her karakteri kaldırır delims. ;;;. Sonra yapar fordöngüyü 1için number-of-delimitersile sayılmıştır olarak ${#delims}. Son adım, bu $iparçayı kullanarak güvenli bir şekilde elde etmektir cut.