J'ai cette chaîne stockée dans une variable:

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

Maintenant, je voudrais diviser les chaînes par ;délimiteur afin d'avoir:

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

Je n'ai pas nécessairement besoin des variables ADDR1et ADDR2. Si ce sont des éléments d'un tableau, c'est encore mieux.

Après les suggestions des réponses ci-dessous, je me suis retrouvé avec ce qui était ce que je recherchais:

#!/usr/bin/env bash

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

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

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

Production:

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

Il y avait une solution impliquant de définir Internal_field_separator (IFS) sur ;. Je ne sais pas ce qui s'est passé avec cette réponse, comment pouvez-vous réinitialiser les IFSparamètres par défaut?

RE: IFSsolution, j'ai essayé ça et ça marche, je garde l'ancien IFSpuis le restaure:

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

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

IFS=$OIFS

BTW, quand j'ai essayé

mails2=($IN)

Je n'ai obtenu la première chaîne que lors de l'impression en boucle, sans crochets, $INcela fonctionne.

Vous pouvez définir la variable de séparateur de champ interne (IFS), puis la laisser analyser dans un tableau. Lorsque cela se produit dans une commande, l'affectation à IFSn'a lieu que dans l'environnement de cette commande unique (à read). Il analyse ensuite l'entrée en fonction de la IFSvaleur de la variable dans un tableau, que nous pouvons ensuite parcourir.

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

Il analysera une ligne d'éléments séparés par ;, en la poussant dans un tableau. Trucs pour le traitement de l'ensemble $IN, à chaque fois une ligne d'entrée séparée par ;:

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

Tiré du tableau de division du script shell Bash :

IN="[email protected];[email protected]"
arrIN=(${IN//;/ })

Explication:

Cette construction remplace toutes les occurrences de ';'(le premier //signifie le remplacement global) dans la chaîne INpar ' '(un seul espace), puis interprète la chaîne délimitée par des espaces comme un tableau (c'est ce que font les parenthèses environnantes).

La syntaxe utilisée à l'intérieur des accolades pour remplacer chaque ';'caractère par un ' 'caractère est appelée Expansion des paramètres .

Il existe quelques pièges courants:

1. Si la chaîne d'origine contient des espaces, vous devrez utiliser IFS :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Si la chaîne d'origine contient des espaces et que le délimiteur est une nouvelle ligne, vous pouvez définir IFS avec:
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Si cela ne vous dérange pas de les traiter immédiatement, j'aime faire ceci:

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

Vous pouvez utiliser ce type de boucle pour initialiser un tableau, mais il existe probablement un moyen plus simple de le faire. J'espère que cela vous aidera.

Réponse compatible

Il existe de nombreuses façons de le faire dans frapper.

Cependant, il est important de noter d'abord qu'il basha de nombreuses fonctionnalités spéciales (soi-disant bashismes ) qui ne fonctionneront dans aucune autrecoquille.

En particulier, les tableaux , les tableaux associatifs et la substitution de modèles , qui sont utilisés dans les solutions de cet article ainsi que d'autres dans le fil, sont des bashismes et peuvent ne pas fonctionner sous d'autres shells que beaucoup de gens utilisent.

Par exemple: sur mon Debian GNU / Linux , il y a un shell standard appelétiret; Je connais beaucoup de gens qui aiment utiliser un autre shell appeléksh; et il y a aussi un outil spécial appeléoccupé avec son propre interprète shell (cendre).

Chaîne demandée

La chaîne à séparer dans la question ci-dessus est:

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

J'utiliserai une version modifiée de cette chaîne pour m'assurer que ma solution est robuste aux chaînes contenant des espaces blancs, ce qui pourrait casser d'autres solutions:

IN="[email protected];[email protected];Full Name <[email protected]>"

Fractionner la chaîne en fonction du délimiteur dans frapper (version> = 4.2)

En pur bash , on peut créer un tableau avec des éléments divisés par une valeur temporaire pour IFS (le séparateur de champ d'entrée ). L'IFS, entre autres, indique bashquel (s) caractère (s) il doit traiter comme un délimiteur entre les éléments lors de la définition d'un tableau:

IN="[email protected];[email protected];Full Name <[email protected]>"

# save original IFS value so we can restore it later
oIFS="$IFS"
IFS=";"
declare -a fields=($IN)
IFS="$oIFS"
unset oIFS

Dans les versions plus récentes de bash, le fait de préfixer une commande avec une définition IFS modifie l'IFS pour cette commande uniquement et la réinitialise à la valeur précédente immédiatement après. Cela signifie que nous pouvons faire ce qui précède en une seule ligne:

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'

Nous pouvons voir que la chaîne INa été stockée dans un tableau nommé fields, divisé sur les points-virgules:

set | grep ^fields=\\\|^IN=
# fields=([0]="[email protected]" [1]="[email protected]" [2]="Full Name <[email protected]>")
# IN='[email protected];[email protected];Full Name <[email protected]>'

(Nous pouvons également afficher le contenu de ces variables en utilisant declare -p:)

declare -p IN fields
# declare -- IN="[email protected];[email protected];Full Name <[email protected]>"
# declare -a fields=([0]="[email protected]" [1]="[email protected]" [2]="Full Name <[email protected]>")

Notez que read c'est le moyen le plus rapide de faire le fractionnement car il n'y a pas de fourches ou de ressources externes appelées.

Une fois le tableau défini, vous pouvez utiliser une simple boucle pour traiter chaque champ (ou, plutôt, chaque élément du tableau que vous avez maintenant défini):

# `"${fields[@]}"` expands to return every element of `fields` array as a separate argument
for x in "${fields[@]}" ;do
    echo "> [$x]"
    done
# > [[email protected]]
# > [[email protected]]
# > [Full Name <[email protected]>]

Ou vous pouvez supprimer chaque champ du tableau après le traitement à l'aide d'un approche de décalage , que j'aime:

while [ "$fields" ] ;do
    echo "> [$fields]"
    # slice the array 
    fields=("${fields[@]:1}")
    done
# > [[email protected]]
# > [[email protected]]
# > [Full Name <[email protected]>]

Et si vous voulez juste une simple impression du tableau, vous n'avez même pas besoin de le parcourir:

printf "> [%s]\n" "${fields[@]}"
# > [[email protected]]
# > [[email protected]]
# > [Full Name <[email protected]>]

Mise à jour: récente frapper > = 4,4

Dans les versions plus récentes de bash, vous pouvez également jouer avec la commande mapfile:

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

Cette syntaxe préserve les caractères spéciaux, les nouvelles lignes et les champs vides!

Si vous ne souhaitez pas inclure de champs vides, vous pouvez procéder comme suit:

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

Avec mapfile, vous pouvez également sauter la déclaration d'un tableau et implicitement "boucler" sur les éléments délimités, en appelant une fonction sur chacun:

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

(Remarque: la \0fin de la chaîne de format est inutile si vous ne vous souciez pas des champs vides à la fin de la chaîne ou s'ils ne sont pas présents.)

mapfile < <(echo -n "$IN") -td \; -c 1 -C myPubliMail

# Seq:      0: Sending mail to '[email protected]', done.
# Seq:      1: Sending mail to '[email protected]', done.
# Seq:      2: Sending mail to 'Full Name <[email protected]>', done.

Ou vous pouvez utiliser <<<, et dans le corps de la fonction, inclure un traitement pour supprimer la nouvelle ligne qu'il ajoute:

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 '[email protected]', done.
# Seq:      1: Sending mail to '[email protected]', done.
# Seq:      2: Sending mail to 'Full Name <[email protected]>', done.

Fractionner la chaîne en fonction du délimiteur dans coquille

Si vous ne pouvez pas utiliser bash, ou si vous voulez écrire quelque chose qui peut être utilisé dans de nombreux shells différents, vous ne pouvez souvent pas utiliser de bashismes - et cela inclut les tableaux que nous avons utilisés dans les solutions ci-dessus.

Cependant, nous n'avons pas besoin d'utiliser des tableaux pour faire une boucle sur les "éléments" d'une chaîne. Il existe une syntaxe utilisée dans de nombreux shells pour supprimer les sous-chaînes d'une chaîne de la première ou de la dernière occurrence d'un modèle. Notez que* s'agit d'un caractère générique qui représente zéro ou plusieurs caractères:

(L'absence de cette approche dans toute solution publiée jusqu'à présent est la principale raison pour laquelle j'écris cette réponse;)

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

Comme expliqué par Score_Under :

#et %supprimer la sous-chaîne correspondante la plus courte possible respectivement au début et à la fin de la chaîne, et

##et %%supprimez la sous-chaîne correspondante la plus longue possible.

En utilisant la syntaxe ci-dessus, nous pouvons créer une approche où nous extrayons des "éléments" de sous-chaîne de la chaîne en supprimant les sous-chaînes jusqu'au délimiteur ou après.

Le bloc de code ci-dessous fonctionne bien dans frapper(y compris Mac OS bash),tiret, ksh, et occupéc'est cendre:

IN="[email protected];[email protected];Full Name <[email protected]>"
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
# > [[email protected]]
# > [[email protected]]
# > [Full Name <[email protected]>]

S'amuser!

J'ai vu quelques réponses faisant référence à la cutcommande, mais elles ont toutes été supprimées. C'est un peu étrange que personne n'ait développé cela, car je pense que c'est l'une des commandes les plus utiles pour faire ce genre de chose, en particulier pour analyser des fichiers journaux délimités.

Dans le cas de la division de cet exemple spécifique en un tableau de scripts bash, trest probablement plus efficace, mais cutpeut être utilisé, et est plus efficace si vous souhaitez extraire des champs spécifiques du milieu.

Exemple:

$ echo "[email protected];[email protected]" | cut -d ";" -f 1
bla@some.com
$ echo "[email protected];[email protected]" | cut -d ";" -f 2
john@home.com

Vous pouvez évidemment mettre cela en boucle et itérer le paramètre -f pour extraire chaque champ indépendamment.

Cela devient plus utile lorsque vous disposez d'un fichier journal délimité avec des lignes comme celle-ci:

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

cutest très pratique pour pouvoir accéder à catce fichier et sélectionner un champ particulier pour un traitement ultérieur.

Cela a fonctionné pour moi:

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

Que diriez-vous de cette approche:

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

La source

Je pense qu'AWK est la commande la meilleure et la plus efficace pour résoudre votre problème. AWK est inclus par défaut dans presque toutes les distributions Linux.

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

va donner

bla@some.com john@home.com

Bien sûr, vous pouvez stocker chaque adresse e-mail en redéfinissant le champ d'impression awk.

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

Cela fonctionne également:

IN="[email protected];[email protected]"
echo ADD1=`echo $IN | cut -d \; -f 1`
echo ADD2=`echo $IN | cut -d \; -f 2`

Attention, cette solution n'est pas toujours correcte. Si vous passez "[email protected]" uniquement, il l'assignera à la fois à ADD1 et ADD2.

Une approche différente de la réponse de Darron, voici comment je le fais:

IN="[email protected];[email protected]"
read ADDR1 ADDR2 <<<$(IFS=";"; echo $IN)

Dans Bash, une méthode à l'épreuve des balles, cela fonctionnera même si votre variable contient des retours à la ligne:

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

Regardez:

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

L'astuce pour que cela fonctionne est d'utiliser l' -doption de read(délimiteur) avec un délimiteur vide, ce qui readoblige à lire tout ce qui est alimenté. Et nous alimentons readexactement le contenu de la variable in, sans retour à la ligne grâce à printf. Notez que nous mettons également le délimiteur printfpour nous assurer que la chaîne passée à reada un délimiteur de fin. Sans cela, readcouperait les champs vides en fin potentiels:

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

le champ vide de fin est conservé.

Mise à jour pour Bash≥4.4

Depuis Bash 4.4, la fonction intégrée mapfile(aka readarray) prend en charge l' -doption de spécifier un délimiteur. Par conséquent, une autre voie canonique est:

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

Que diriez-vous de cette doublure, si vous n'utilisez pas de tableaux:

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

Sans paramétrer l'IFS

Si vous n'avez qu'un seul colon, vous pouvez le faire:

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

tu auras:

b = foo
c = bar

Voici un 3-liner propre:

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

où IFSdélimite les mots en fonction du séparateur et ()est utilisé pour créer un tableau . Puis [@]est utilisé pour renvoyer chaque élément en tant que mot distinct.

Si vous avez du code après cela, vous devez également restaurer $IFS, par exemple unset IFS.

La fonction Bash / zsh suivante divise son premier argument sur le délimiteur donné par le deuxième 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
}

Par exemple, la commande

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

les rendements

a
b
c

Cette sortie peut, par exemple, être redirigée vers d'autres commandes. Exemple:

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

Par rapport aux autres solutions proposées, celle-ci présente les avantages suivants:

• IFSn'est pas redéfini: en raison de la portée dynamique des variables locales, même, la redéfinition d' IFSune boucle provoque une fuite de la nouvelle valeur dans les appels de fonction effectués à partir de la boucle.

• Les tableaux ne sont pas utilisés: la lecture d'une chaîne dans un tableau à l'aide de readnécessite l'indicateur -adans Bash et -Adans zsh.

Si vous le souhaitez, la fonction peut être placée dans un script comme suit:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

vous pouvez appliquer awk à de nombreuses situations

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

vous pouvez également l'utiliser

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

Il existe un moyen simple et intelligent comme celui-ci:

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

Mais vous devez utiliser gnu xargs, BSD xargs ne supporte pas -d delim. Si vous utilisez Apple Mac comme moi. Vous pouvez installer gnu xargs:

brew install findutils

puis

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

C'est la façon la plus simple de le faire.

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

Il y a des réponses intéressantes ici (errator en particulier), mais pour quelque chose d'analogue à diviser dans d'autres langues - c'est ce que j'ai pris pour la question initiale - je me suis installé sur ceci:

IN="[email protected];[email protected]"
declare -a a="(${IN/;/ })";

Maintenant ${a[0]}, ${a[1]}etc, sont comme vous vous en doutez. Utilisez ${#a[*]}pour le nombre de termes. Ou pour itérer, bien sûr:

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

NOTE IMPORTANTE:

Cela fonctionne dans les cas où il n'y a pas d'espace à s'inquiéter, ce qui a résolu mon problème, mais peut ne pas résoudre le vôtre. Allez avec la $IFS(les) solution (s) dans ce cas.

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

Production

bla@some.com
john@home.com

Système: Ubuntu 12.04.1

S'il n'y a pas d'espace, pourquoi pas ça?

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

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

Utilisez le setintégré pour charger la $@baie:

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

Ensuite, laissez la fête commencer:

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

Deux alternatives bourne-ish où aucune ne nécessite de tableaux bash:

Cas 1 : Restez simple et agréable: utilisez un NewLine comme séparateur d'enregistrement ... par exemple.

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

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

Remarque: dans ce premier cas, aucun sous-processus n'est bifurqué pour aider à la manipulation de la liste.

Idée: Peut-être que cela vaut la peine d'utiliser NL de manière intensive en interne , et de convertir uniquement en un RS différent lors de la génération du résultat final en externe .

Cas 2 : utilisation d'un ";" comme séparateur d'enregistrement ... par exemple.

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"

Dans les deux cas, une sous-liste peut être composée au sein de la boucle est persistante une fois la boucle terminée. Ceci est utile lors de la manipulation de listes en mémoire, au lieu de stocker des listes dans des fichiers. {ps reste calme et continue B-)}

Outre les réponses fantastiques qui ont déjà été fournies, s'il s'agit simplement d'imprimer les données, vous pouvez envisager d'utiliser awk:

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

Cela définit le séparateur de champs sur ;, afin qu'il puisse parcourir les champs avec une forboucle et imprimer en conséquence.

Tester

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

Avec une autre entrée:

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

Dans le shell Android, la plupart des méthodes proposées ne fonctionnent tout simplement pas:

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

Ce qui fonctionne, c'est:

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

où //signifie remplacement global.

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

Production:

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

Explication: L'affectation simple à l'aide de parenthèses () convertit la liste séparée par des points-virgules en un tableau à condition que vous disposiez de l'IFS correct pour ce faire. La boucle FOR standard gère les éléments individuels de ce tableau comme d'habitude. Notez que la liste donnée pour la variable IN doit être "dure" entre guillemets, c'est-à-dire avec des ticks simples.

IFS doit être enregistré et restauré car Bash ne traite pas une affectation de la même manière qu'une commande. Une autre solution consiste à encapsuler l'affectation à l'intérieur d'une fonction et à appeler cette fonction avec un IFS modifié. Dans ce cas, une sauvegarde / restauration séparée d'IFS n'est pas nécessaire. Merci pour "Bize" de l'avoir signalé.

D'accord les gars!

Voici ma réponse!

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

Pourquoi cette approche est "la meilleure" pour moi?

Pour deux raisons:

1. Vous n'avez pas besoin d'échapper au délimiteur;
2. Vous n'aurez aucun problème avec les espaces vides . La valeur sera correctement séparée dans le tableau!

[]

Une ligne pour séparer une chaîne séparée par ';' dans un tableau est:

IN="[email protected];[email protected]"
ADDRS=( $(IFS=";" echo "$IN") )
echo ${ADDRS[0]}
echo ${ADDRS[1]}

Cela ne définit IFS que dans un sous-shell, vous n'avez donc pas à vous soucier de l'enregistrement et de la restauration de sa valeur.

Peut-être pas la solution la plus élégante, mais fonctionne avec *et les espaces:

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

Les sorties

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

Autre exemple (délimiteurs au début et à la fin):

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

Fondamentalement, il supprime tous les caractères autres que la ;création, delimspar exemple. ;;;. Ensuite, il forboucle de 1à number-of-delimiterscomme compté par ${#delims}. La dernière étape consiste à obtenir en toute sécurité la $ipièce en utilisant cut.