Wie spalte ich eine Zeichenfolge auf einem Trennzeichen in Bash?

Habe ich diesen string in einer Variablen gespeichert:

IN="[email protected];[email protected]"

Nun würde ich gerne splitten der strings durch ; Trennzeichen, so dass ich habe:

ADDR1="[email protected]"
ADDR2="[email protected]"

Brauche ich nicht unbedingt die ADDR1 und ADDR2 Variablen. Wenn Sie Elemente in einem array, ist das noch besser.

Nach Anregungen aus den Antworten unten, landete ich mit den folgenden das ist, was ich wurde nach:

#!/usr/bin/env bash

IN="[email protected];[email protected]"

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

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

Ausgabe:

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

Es wurde eine Lösung mit Einstellung Internal_field_separator (IFS);. Ich bin nicht sicher, was passiert mit ihm, wie setzen Sie IFS auf Standard zurück?

RE: IFS Lösung, ich versuchte dies und es funktioniert, ich halte die alten IFSund dann wieder:

IN="[email protected];[email protected]"

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

IFS=$OIFS

BTW, als ich versucht

mails2=($IN)

Habe ich nur die erste Zeichenfolge in der Ausgabe in der Schleife, ohne Klammern um $IN es funktioniert.

InformationsquelleAutor der Frage stefanB | 2009-05-28

917

Können Sie die internal field separator (IFS) variable, und lassen Sie ihn dann zu Parsen und in ein array. Wenn dies geschieht in einem Befehl, dann wird die Zuordnung zu IFS erfolgt nur zu diesem einzigen Befehl, der die Umgebung ( read ). Anschließend analysiert die Eingaben gemäß der IFS Wert der variable in ein array, und die kann man dann Durchlaufen.
```
IFS=';' read -ra ADDR <<< "$IN"
for i in "${ADDR[@]}"; do
    # process "$i"
done
```
Wird es Parsen einer Zeile von Elementen, getrennt durch ;schob es in ein array. Sachen, die für die Verarbeitung ganz $INjedes mal, wenn eine Zeile der Eingabe getrennt durch ;:
```
 while IFS=';' read -ra ADDR; do
      for i in "${ADDR[@]}"; do
          # process "$i"
      done
 done <<< "$IN"
```
InformationsquelleAutor der Antwort Johannes Schaub - litb
743

Entnommen Bash-shell-script, split-array:
```
IN="[email protected];[email protected]"
arrIN=(${IN//;/ })
```
Erklärung:

Diese Konstruktion ersetzt alle vorkommen von ';' (die erste // bedeutet global replace) in der Zeichenkette IN mit ' ' (ein einzelnes Leerzeichen), dann interpretiert das Leerzeichen als Trennzeichen Zeichenfolge als ein array (das ist das, was die umgebenden Klammern).

Die verwendete syntax innerhalb der geschweiften Klammern zu ersetzen, die jeder ';' Charakter mit einem ' ' Charakter heißt Parameter Expansion.

Gibt es einige typische Hinweise:
1. Wenn der ursprüngliche string der Leerzeichen enthält, müssen Sie IFS:
  - IFS=':'; arrIN=($IN); unset IFS;
2. Wenn der ursprüngliche string der Leerzeichen und das Trennzeichen ist eine neue Linie, die Sie festlegen können, IFS mit:
  - IFS=$'\n'; arrIN=($IN); unset IFS;
InformationsquelleAutor der Antwort palindrom
207

Wenn Sie nichts dagegen haben, verarbeiten Sie diese sofort, ich mag, dies zu tun:
```
for i in $(echo $IN | tr ";" "\n")
do
  # process
done
```
Könnte man diese Art von Schleife, um ein array zu initialisieren, aber es gibt wahrscheinlich einen einfacheren Weg, es zu tun. Hoffe, das hilft, aber.

InformationsquelleAutor der Antwort Chris Lutz
121

Kompatibel beantworten

Dieser Frage ALSO, es gibt bereits eine Menge von verschiedenen Weg, um dies zu tun, in bash.
Aber bash hat viele Besondere Funktionen, so genannte bashism, die gut funktionieren, aber das funktioniert nicht in jedem anderen Schale.

Insbesondere arraysassoziatives arrayund pattern substitution sind Reine bashisms und funktioniert nicht unter anderen Schalen.

Auf meine Debian GNU/Linuxes ist ein standard shell namens Bindestrichaber ich kenne viele Leute, die wie zu verwenden ksh.

Schließlich in sehr kleine situation, es gibt ein spezielles tool namens busybox mit seiner eigenen shell-interpreter (ash).

Gewünschten Text

Den string-Beispiel in Frage ALSO ist:
```
IN="[email protected];[email protected]"
```
Werden, denn dies könnte nützlich sein, mit Leerzeichen und als Leerzeichen ändern könnte, das Ergebnis der routine, ich bevorzuge in diesem Beispiel-string:
```
 IN="[email protected];[email protected];Full Name <[email protected]>"
```
Split-string basierend auf Trennzeichen in bash (version >=4.2)

Unter Reine bash, verwenden wir arrays und IFS:
```
var="[email protected];[email protected];Full Name <[email protected]>"
```
~~oIFS="$IFS" IFS=";" declare -a fields=($var) IFS="$oIFS" unset oIFS~~
```
IFS=\; read -a fields <<<"$var"
```
Verwendung dieser syntax unter den letzten bash nicht ändern $IFS für die aktuelle Sitzung, sondern nur für den aktuellen Befehl:
```
set | grep ^IFS=
IFS=$' \t\n'
```
Nun den string var aufgeteilt und gespeichert in ein array (namens fields):
```
set | grep ^fields=\\\|^var=
fields=([0]="[email protected]" [1]="[email protected]" [2]="Full Name <[email protected]>")
var='[email protected];[email protected];Full Name <[email protected]>'
```
Könnten wir die Anfrage für die Variablen Inhalte mit declare -p:
```
declare -p var fields
declare -- var="[email protected];[email protected];Full Name <[email protected]>"
declare -a fields=([0]="[email protected]" [1]="[email protected]" [2]="Full Name <[email protected]>")
```
read ist die quickiest Art und Weise zu tun, die Trennung, weil es keine Gabeln und keine externen Ressourcen genannt.

Von dort aus können Sie mit der syntax, die Sie bereits wissen, für die Verarbeitung der einzelnen Felder:
```
for x in "${fields[@]}";do
    echo "> [$x]"
    done
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]
```
oder drop jedes Feld nach der Bearbeitung (ich mag diese Verlagerung Ansatz):
```
while [ "$fields" ] ;do
    echo "> [$fields]"
    fields=("${fields[@]:1}")
    done
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]
```
oder auch für den einfachen Ausdruck (kürzere syntax):
```
printf "> [%s]\n" "${fields[@]}"
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]
```
Split-string basierend auf Trennzeichen in Schale

Aber wenn Sie etwas schreiben, nutzbar unter vielen Muscheln, die Sie haben, um nicht verwenden bashisms.

Gibt es eine syntax, die in vielen shells, die für die Spaltung einer Schnur über ersten oder letzten vorkommen eines Zeichens:
```
${var#*SubStr}  # will drop begin of string up to first occur of `SubStr`
${var##*SubStr} # will drop begin of string up to last occur of `SubStr`
${var%SubStr*}  # will drop part of string from last occur of `SubStr` to the end
${var%%SubStr*} # will drop part of string from first occur of `SubStr` to the end
```
(Das fehlen dieser ist der Hauptgrund meiner Antwort Publikation 😉

Wie bereits von Score_Under:

# und % löschen Sie den kürzesten passenden string und

## und %% löschen Sie die längste möglich.

Diesem kleinen Beispiel script funktioniert auch unter bash Bindestrich ksh busybox und wurde getestet unter Mac-OS-bash:
```
var="[email protected];[email protected];Full Name <[email protected]>"
while [ "$var" ] ;do
    iter=${var%%;*}
    echo "> [$iter]"
    [ "$var" = "$iter" ] && \
        var='' || \
        var="${var#*;}"
  done
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]
```
Spaß haben!

InformationsquelleAutor der Antwort F. Hauri

Wie wäre dieser Ansatz:

IN="[email protected];[email protected]" 
set -- "$IN" 
IFS=";"; declare -a Array=($*) 
echo "${Array[@]}" 
echo "${Array[0]}" 
echo "${Array[1]}"

Quelle

InformationsquelleAutor der Antwort

72

Ich habe gesehen, ein paar Antworten verweisen auf die cut Befehl, aber Sie haben alle schon gelöscht. Es ist ein wenig seltsam, dass sich niemand erarbeitet hat, weil ich denke, es ist eines der nützlichsten Befehlen für tun, diese Art der Sache, vor allem für die Analyse getrennte log-Dateien.

Im Fall der Aufspaltung dieses spezifische Beispiel in ein bash-script array tr ist wahrscheinlich effizienter, aber cut verwendet werden kann, und ist effektiver, wenn Sie möchten, ziehen Sie bestimmte Felder von der Mitte.

Beispiel:
```
$ echo "[email protected];[email protected]" | cut -d ";" -f 1
bla@some.com
$ echo "[email protected];[email protected]" | cut -d ";" -f 2
john@home.com
```
Können Sie offensichtlich, dass in eine Schleife, und wiederholen den -f-parameter zu ziehen jedes Feld einzeln.

Diese bekommt mehr sinnvoll, wenn Sie eine getrennte log-Datei mit Zeilen wie dieser:
```
2015-04-27|12345|some action|an attribute|meta data
```
cut ist sehr praktisch, um in der Lage sein, um cat diese Datei und wählen Sie einen bestimmten Bereich für die weitere Verarbeitung.

InformationsquelleAutor der Antwort DougW

Dieser arbeitete für mich:

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

InformationsquelleAutor der Antwort Steven Lizarazo

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

InformationsquelleAutor der Antwort lothar

57

Funktioniert das auch:
```
IN="[email protected];[email protected]"
echo ADD1=`echo $IN | cut -d \; -f 1`
echo ADD2=`echo $IN | cut -d \; -f 2`
```
Vorsicht, diese Lösung ist nicht immer richtig. In Fall, dass Sie pass "[email protected]" nur, es ordnet Sie beide ADD1 und ADD2.

InformationsquelleAutor der Antwort Ashok
32

Ich denke AWK ist die beste und effizienteste Befehl, um Ihr problem zu lösen. AWK ist enthalten in der Bash standardmäßig in fast allen Linux-distribution.
```
echo "[email protected];[email protected]" | awk -F';' '{print $1,$2}'
```
geben
```
bla@some.com john@home.com
```
Natürlich können die Speicherung der einzelnen E-Mail-Adresse durch die Neudefinition des awk-print-Feld.

InformationsquelleAutor der Antwort Tony
25

Anders Die Antwort von Darrondas ist, wie ich es mache:
```
IN="[email protected];[email protected]"
read ADDR1 ADDR2 <<<$(IFS=";"; echo $IN)
```
InformationsquelleAutor der Antwort nickjb
23

In der Bash, eine Kugel-Beweis Weg, dass funktioniert sogar, wenn die variable enthält Zeilenumbrüche:
```
IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")
```
Aussehen:
```
$ 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")'
```
Den trick für diese arbeiten ist die Verwendung der -d Möglichkeit read (delimiter) mit einem empty delimiter, so dass read ist gezwungen, alles zu Lesen, es ist gefüttert. Und wir füttern read mit genau der Inhalt der variable in mit ohne abschließendes newline Dank printf. Beachten Sie, dass wir sind auch dabei, das Trennzeichen in printf um sicherzustellen, dass die Zeichenfolge übergeben, um read hat eine nachgestellte Trennzeichen. Ohne Sie read würde trim Potenzial nachgestellte leere Felder:
```
$ 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]="")'
```
das leere Feld erhalten.

Update für Bash≥4.4

Da Bash 4.4, die vordefiniert mapfile (aka readarray) unterstützt die -d option geben Sie ein Trennzeichen. Damit ein anderes kanonische Weg ist:
```
mapfile -d ';' -t array < <(printf '%s;' "$in")
```
InformationsquelleAutor der Antwort gniourf_gniourf
18

Wie über diese eine, liner, wenn du nicht mit arrays:
```
IFS=';' read ADDR1 ADDR2 <<<$IN
```
InformationsquelleAutor der Antwort Darron
16

Ohne Einstellung der IFS -

Wenn Sie nur noch ein Doppelpunkt das können Sie tun:
```
a="foo:bar"
b=${a%:*}
c=${a##*:}
```
erhalten Sie:
```
b = foo
c = bar
```
InformationsquelleAutor der Antwort Emilien Brigand
14

Hier ist eine saubere 3-liner:
```
in="foo@bar;bizz@buzz;fizz@buzz;buzz@woof"
IFS=';' list=($in)
for item in "${list[@]}"; do echo $item; done
```
wo IFS begrenzen Wörter basierend auf den separator und die () verwendet wird, um eine array. Dann [@] zurück, jeden Artikel als separates Wort.

Wenn Sie noch irgendwelche code nach, dass, müssen Sie auch wiederherstellen $IFS z.B. unset IFS.

InformationsquelleAutor der Antwort kenorb
7

Gibt es eine einfache und intelligente Art und Weise, wie diese:
```
echo "add:sfff" | xargs -d: -i  echo {}
```
Aber Sie müssen gnu-xargs, BSD xargs nicht unterstützen -d delim. Wenn Sie apple mac, wie ich. Sie können installieren, gnu xargs :
```
brew install findutils
```
dann
```
echo "add:sfff" | gxargs -d: -i  echo {}
```
InformationsquelleAutor der Antwort Victor Choy

Dies ist der einfachste Weg, es zu tun.

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

InformationsquelleAutor der Antwort Prospero

4

Dem folgenden Bash/zsh-Funktion teilt das erste argument auf das Trennzeichen gegeben durch das zweite 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
}
```
Beispielsweise den Befehl
```
$ split 'a;b;c' ';'
```
Erträge
```
a
b
c
```
Diese Ausgabe kann zum Beispiel an andere Befehle. Beispiel:
```
$ split 'a;b;c' ';' | cat -n
1   a
2   b
3   c
```
Im Vergleich zu den anderen Lösungen gegeben, diese hat die folgenden Vorteile:
- IFS wird nicht überschrieben:, da dynamisches scoping auch lokale Variablen überschreiben IFS über eine Schleife führt den neuen Wert ein Leck in Funktionsaufrufe durchgeführt, die in der Schleife.
- Arrays nicht verwendet werden: Lesen Sie einen string in ein array mit read erfordert die Flagge -a in Bash und -A im zsh.
Falls gewünscht, kann die Funktion in einem Skript wie folgt:
```
#!/usr/bin/env bash

split() {
    # ...
}

split "$@"
```
InformationsquelleAutor der Antwort Halle Knast

IN="[email protected];[email protected]"
IFS=';'
read -a IN_arr <<< "${IN}"
for entry in "${IN_arr[@]}"
do
    echo $entry
done

Ausgabe

bla@some.com
john@home.com

System : Ubuntu 12.04.1

InformationsquelleAutor der Antwort rashok

können Sie anwenden, awk, um viele Situationen

echo "[email protected];[email protected]"|awk -F';' '{printf "%s\n%s\n", $1, $2}'

auch Sie können diese

echo "[email protected];[email protected]"|awk -F';' '{print $1,$2}' OFS="\n"

InformationsquelleAutor der Antwort shuaihanhungry

Wenn kein Platz ist, Warum nicht?

IN="[email protected];[email protected]"
arr=(`echo $IN | tr ';' ' '`)

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

InformationsquelleAutor der Antwort ghost

2

Gibt es ein paar Coole Antworten hier (errator esp.), aber für etwas Analog zu split in anderen Sprachen-das ist, was ich fand, die ursprüngliche Frage zu meine-ich ließ mich auf dieses:
```
IN="[email protected];[email protected]"
declare -a a="(${IN/;/})";
```
Nun ${a[0]}${a[1]} usw. sind wie man es erwarten würde. Verwenden ${#a[*]} für die Anzahl der Bedingungen. Oder Durchlaufen, natürlich:
```
for i in ${a[*]}; do echo $i; done
```
WICHTIGER HINWEIS:

Dies funktioniert in den Fällen, wo es keine Räume zu sorgen, das mein problem gelöst, aber kann Sie nicht lösen, Ihre. Gehen Sie mit der $IFS Lösung(en) in diesem Fall.

InformationsquelleAutor der Antwort eukras

Verwenden Sie die set built-in zu laden, bis die $@ array:

IN="[email protected];[email protected]"
IFS=';'; set $IN; IFS=$' \t\n'

Dann, lasst die party beginnen:

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

InformationsquelleAutor der Antwort jeberle

1

Beiden bourne-ish alternativen, wo weder erfordern die bash-arrays:

Fall 1: Halten Sie es schön und einfach: Verwenden Sie ein NewLine als Datensatz-Trennzeichen... zB.
```
IN="[email protected]
[email protected]"

while read i; do
  # process "$i" ... eg.
    echo "[email:$i]"
done <<< "$IN"
```
Hinweis: in diesem ersten Fall kein sub-Prozess abgespalten, um mit Hilfe der Liste manipulation.

Idee: Vielleicht lohnt es sich, mit NL ausgiebig internund nur die Konvertierung auf einen anderen RS bei der Generierung des endgültigen Ergebnisses extern.

Fall 2: Mit einem ";" als satztrennzeichen... zB.
```
NL="
" IRS=";" ORS=";"

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

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

IN="[email protected];[email protected]"
IN="$(conv_IRS ";" <<< "$IN")"

while read i; do
  # process "$i" ... eg.
    echo -n "[email:$i]$ORS"
done <<< "$IN"
```
In beiden Fällen ist eine sub-Liste verfasst werden kann innerhalb der Schleife ist persistent, nachdem die Schleife abgeschlossen wurde. Dies ist nützlich bei der Manipulation von Listen im Speicher, anstatt das speichern von Listen in Dateien. {p.s. keep calm and carry on-B-) }

InformationsquelleAutor der Antwort NevilleDNZ
1

Abgesehen von der fantastischen Antworten, wurden bereits zur Verfügung gestellt, wenn es ist nur eine Frage der Ausdruck der Daten können Sie erwägen, mit awk:
```
awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"
```
Dieser legt die Trennzeichen für Felder ;so dass es eine Schleife durch die Felder mit einem for Schleife und Druck entsprechend an.

Test
```
$ IN="[email protected];[email protected]"
$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"
> [bla@some.com]
> [john@home.com]
```
Mit einem Eingang:
```
$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "a;b;c   d;e_;f"
> [a]
> [b]
> [c   d]
> [e_]
> [f]
```
InformationsquelleAutor der Antwort fedorqui

In der Android-shell, die meisten der vorgeschlagenen Methoden einfach nicht funktionieren:

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

Was funktioniert ist:

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

wo // bedeutet weltweiten Austausch.

InformationsquelleAutor der Antwort 18446744073709551615

Okay Jungs!

Hier ist meine Antwort!

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

Warum dieser Ansatz ist "das beste" für mich?

Wegen zwei Gründen:

Sie nicht brauchen, um zu entkommen das Trennzeichen;
Werden Sie nicht haben, problem mit Leerzeichen. Der Wert wird ordnungsgemäß getrennt im array!

[]'s

InformationsquelleAutor der Antwort Eduardo Lucio

0

Einen one-liner nach split einen string, getrennt durch ';' in ein array ist:
```
IN="[email protected];[email protected]"
ADDRS=( $(IFS=";" echo "$IN") )
echo ${ADDRS[0]}
echo ${ADDRS[1]}
```
Diese legt nur wenns in einer subshell, so dass Sie nicht haben, um sorgen über das speichern und die Wiederherstellung seiner Wert.

InformationsquelleAutor der Antwort Michael Hale
0
```
IN='[email protected];[email protected];Charlie Brown <[email protected];!"#$%&/()[]{}*? 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
```
Ausgabe:
```
bla@some.com
john@home.com
Charlie Brown <cbrown@acme.com
!"#$%&/()[]{}*? are no problem
simple is beautiful :-)
```
Erklärung: Einfache Zuweisung mit Klammern () konvertiert Semikolon getrennte Liste in ein array, sofern Sie die richtige IFS dabei. Standard-FOR-Schleife verarbeitet einzelne Elemente im array wie gewohnt.
Beachten Sie, dass die Liste, die für die IN-variable muss "hart" zitiert, das heißt, mit einzelnen ticks.

Wenns sein muss, gespeichert und wiederhergestellt werden, da die Bash nicht die Behandlung einer Zuweisung die gleiche Weise wie ein Befehl. Eine Alternative Problemumgehung ist, um wickeln Sie die Zuordnung innerhalb einer Funktion, und rufen Sie die Funktion mit einem modifizierten IFS. In diesem Fall trennen, speichern/wiederherstellen der IFS ist nicht erforderlich. Vielen Dank für "Bize" für den Hinweis.

InformationsquelleAutor der Antwort ajaaskel
0

Vielleicht nicht die eleganteste Lösung, funktioniert aber mit * Raum:
```
IN="bla@so me.com;*;[email protected]"
for i in `delims=${IN//[^;]}; seq 1 $((${#delims} + 1))`
do
   echo "> [`echo $IN | cut -d';' -f$i`]"
done
```
Ausgänge
```
> [bla@so me.com]
> [*]
> [john@home.com]
```
Anderen Beispiel (Trennzeichen am Anfang und am Ende):
```
IN=";bla@so me.com;*;[email protected];"
> []
> [bla@so me.com]
> [*]
> [john@home.com]
> []
```
Im Grunde ist es entfernt alle anderen Zeichen als ; machen delims zB. ;;;. Dann macht es for Schleife aus 1 zu number-of-delimiters als gezählt ${#delims}. Der Letzte Schritt ist sicher das $iTEN Teil mit cut.

InformationsquelleAutor der Antwort Petr Újezdský

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Kompatibel beantworten

Gewünschten Text

Split-string basierend auf Trennzeichen in bash (version >=4.2)

Split-string basierend auf Trennzeichen in Schale

Update für Bash≥4.4

Test