Eu tenho essa string armazenada em uma variável:

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

Agora eu gostaria de dividir as strings por ;delimitador para que eu tenha:

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

Eu não necessariamente precisa do ADDR1e ADDR2variáveis. Se eles são elementos de uma matriz, é ainda melhor.

Após sugestões das respostas abaixo, acabei com o seguinte:

#!/usr/bin/env bash

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

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

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

Resultado:

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

Havia uma solução envolvendo a configuração Internal_field_separator (IFS) como ;. Não sei o que aconteceu com essa resposta, como você redefineIFS padrão?

RE: IFSsolução, eu tentei isso e funciona, eu mantenho o antigo IFSe depois restauro:

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

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

IFS=$OIFS

BTW, quando eu tentei

mails2=($IN)

Eu só consegui a primeira string ao imprimi-la em loop, sem colchetes ao redor $INdela.

Você pode definir a variável separador interno de campo (IFS) e, em seguida, deixá-la analisar em uma matriz. Quando isso acontece em um comando, a atribuição a IFSocorre apenas no ambiente desse comando (a read). Em seguida, analisa a entrada de acordo com o IFSvalor da variável em uma matriz, sobre a qual podemos iterar.

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

Ele analisará uma linha de itens separados por ;, empurrando-a para uma matriz. Material para processar todo $IN, cada vez que uma linha de entrada é separada por ;:

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

Retirado da matriz dividida do script do shell Bash :

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

Explicação:

Essa construção substitui todas as ocorrências de ';'(a inicial //significa substituição global) na cadeia de caracteres INpor' ' (um único espaço) e interpreta a cadeia delimitada por espaço como uma matriz (é o que os parênteses circundantes fazem).

A sintaxe usada dentro das chaves para substituir cada ';'caractere por um ' 'caractere é denominada Expansão de parâmetro .

Existem algumas dicas comuns:

1. Se a sequência original tiver espaços, você precisará usar o IFS :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Se a sequência original tiver espaços e o delimitador for uma nova linha, você poderá configurar o IFS com:
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Se você não se importa em processá-los imediatamente, eu gosto de fazer isso:

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

Você pode usar esse tipo de loop para inicializar uma matriz, mas provavelmente existe uma maneira mais fácil de fazer isso. Espero que isso ajude, no entanto.

Resposta compatível

Existem várias maneiras diferentes de fazer isso em bater.

No entanto, é importante notar que existembash muitos recursos especiais (os chamados basismos ) que não funcionarão em nenhum outroConcha.

Em particular, matrizes , matrizes associativas e substituição padrão , que são utilizados nas soluções neste post, bem como outros no segmento, são bashisms e não podem trabalhar sob outras conchas que muitas pessoas usam.

Por exemplo: no meu Debian GNU / Linux , existe um padrão shell chamadotraço; Conheço muitas pessoas que gostam de usar outro shell chamadoksh; e também há uma ferramenta especial chamadabusybox com seu próprio interpretador de shell (cinza)

Sequência solicitada

A string a ser dividida na pergunta acima é:

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

Usarei uma versão modificada dessa cadeia para garantir que minha solução seja robusta para cadeias que contenham espaço em branco, o que poderia interromper outras soluções:

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

Dividir string com base no delimitador em bater (versão> = 4.2)

Em termos puros bash , podemos criar uma matriz com elementos divididos por um valor temporário para o IFS (o separador de campos de entrada ). O IFS, entre outras coisas, informa bashquais caracteres deve ser tratado como um delimitador entre os elementos ao definir uma matriz:

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

Em versões mais recentes do bash, prefixando um comando com uma definição IFS altera as IFS para esse comando única e redefine para o valor anterior imediatamente depois. Isso significa que podemos fazer o acima em apenas uma linha:

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'

Podemos ver que a string INfoi armazenada em uma matriz chamada fields, dividida em ponto e vírgula:

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

(Também podemos exibir o conteúdo dessas variáveis ​​usando 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>")

Observe que readé a maneira mais rápida de fazer a divisão, porque não há garfos ou recursos externos chamados.

Depois que a matriz é definida, você pode usar um loop simples para processar cada campo (ou melhor, cada elemento da matriz que você definiu agora):

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

Ou você pode soltar cada campo da matriz após o processamento usando uma abordagem de deslocamento , que eu gosto:

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

E se você quer apenas uma impressão simples da matriz, não precisa nem fazer um loop sobre ela:

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

Atualização: recente bater > = 4.4

Nas versões mais recentes do bash, você também pode jogar com o comando mapfile:

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

Essa sintaxe preserva caracteres especiais, novas linhas e campos vazios!

Se você não quiser incluir campos vazios, faça o seguinte:

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

Com mapfile, você também pode pular a declaração de uma matriz e implicitamente "fazer um loop" sobre os elementos delimitados, chamando uma função em cada:

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

(Nota: a \0sequência no final da sequência de formatação é inútil se você não se importa com campos vazios no final da sequência ou eles não estiverem presentes.)

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.

Ou você pode usar <<<e, no corpo da função, incluir algum processamento para descartar a nova linha que ele adiciona:

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.

Dividir string com base no delimitador em Concha

Se você não pode usar bash, ou se deseja escrever algo que possa ser usado em muitas conchas diferentes, geralmente não pode usar basismos - e isso inclui as matrizes que usamos nas soluções acima.

No entanto, não precisamos usar matrizes para fazer um loop sobre os "elementos" de uma string. Há uma sintaxe usada em muitos shells para excluir substrings de uma string da primeira ou da última ocorrência de um padrão. Observe que *é um curinga que representa zero ou mais caracteres:

(A falta dessa abordagem em qualquer solução postada até agora é o principal motivo pelo qual estou escrevendo esta resposta;)

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

Conforme explicado por Score_Under :

#e %exclua a substring correspondente mais curta possível do início e do final da string, respectivamente, e

##e %%exclua a substring correspondente mais longa possível.

Usando a sintaxe acima, podemos criar uma abordagem na qual extraímos "elementos" de substring da string excluindo as substrings até ou após o delimitador.

O código de bloqueio abaixo funciona bem em bater (incluindo Mac OS's bash ),traço, kshe busyboxé cinza:

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

Diverta-se!

Vi algumas respostas referenciando o cutcomando, mas todas foram excluídas. É um pouco estranho que ninguém tenha elaborado isso, porque acho que é um dos comandos mais úteis para fazer esse tipo de coisa, especialmente para analisar arquivos de log delimitados.

No caso de dividir este exemplo específico em uma matriz de scripts bash, tré provavelmente mais eficiente, mas cutpode ser usado e é mais eficaz se você deseja extrair campos específicos do meio.

Exemplo:

$ 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

Obviamente, você pode colocar isso em um loop e iterar o parâmetro -f para extrair cada campo independentemente.

Isso se torna mais útil quando você tem um arquivo de log delimitado com linhas como esta:

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

cuté muito útil para poder acessar catesse arquivo e selecionar um campo específico para processamento adicional.

Isso funcionou para mim:

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

Que tal essa abordagem:

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

Fonte

Acho que o AWK é o comando melhor e eficiente para resolver seu problema. O AWK é incluído por padrão em quase todas as distribuições Linux.

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

darei

bla@some.com john@home.com

É claro que você pode armazenar cada endereço de e-mail redefinindo o campo awk print.

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

Isso também funciona:

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

Cuidado, esta solução nem sempre está correta. Caso você passe "bla@some.com" apenas, ele será atribuído a ambos ADD1 e ADD2.

Uma visão diferente da resposta de Darron , é assim que eu faço:

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

No Bash, à prova de balas, isso funcionará mesmo que sua variável contenha novas linhas:

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

Veja:

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

O truque para isso funcionar é usar a -dopção de read(delimitador) com um delimitador vazio, para que readseja forçado a ler tudo o que é alimentado. E nós alimentamos readexatamente o conteúdo da variável in, sem nova linha à direita graças a printf. Observe que também estamos colocando o delimitador printfpara garantir que a sequência passada readtenha um delimitador à direita. Sem ele, readapararia possíveis campos vazios à direita:

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

o campo vazio à direita é preservado.

Atualização para Bash≥4.4

Desde o Bash 4.4, o built-in mapfile(aka readarray) suporta a -dopção de especificar um delimitador. Portanto, outra maneira canônica é:

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

Que tal esse liner único, se você não estiver usando matrizes:

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

Sem configurar o IFS

Se você tiver apenas dois pontos, poderá fazer isso:

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

você vai ter:

b = foo
c = bar

Aqui está um 3-liner limpo:

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

onde IFSdelimita as palavras com base no separador e ()é usado para criar uma matriz . Em seguida, [@]é usado para retornar cada item como uma palavra separada.

Se você tiver algum código depois disso, também precisará restaurar $IFS, por exemplo unset IFS.

A seguinte função Bash / zsh divide seu primeiro argumento no delimitador fornecido pelo segundo argumento:

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
}

Por exemplo, o comando

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

rendimentos

a
b
c

Essa saída pode, por exemplo, ser canalizada para outros comandos. Exemplo:

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

Comparado com as outras soluções fornecidas, esta possui as seguintes vantagens:

• IFSnão é substituída: devido ao escopo dinâmico de variáveis ​​locais, a substituição de IFSum loop faz com que o novo valor vaze nas chamadas de função realizadas de dentro do loop.

• Matrizes não são usadas: a leitura de uma string em uma matriz usando readrequer o sinalizador -ano Bash e -Ano zsh.

Se desejado, a função pode ser colocada em um script da seguinte maneira:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

você pode aplicar o awk a muitas situações

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

Também você pode usar isso

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

Existe uma maneira simples e inteligente como esta:

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

Mas você deve usar o gnu xargs, o BSD xargs não pode suportar -d delim. Se você usa o Apple Mac como eu. Você pode instalar o gnu xargs:

brew install findutils

então

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

Esta é a maneira mais simples de fazer isso.

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

Existem algumas respostas legais aqui (errator esp.), Mas para algo análogo se dividir em outros idiomas - que é o que eu entendi a pergunta original -, decidi sobre isso:

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

Agora ${a[0]}, ${a[1]}etc, são como você esperaria. Use ${#a[*]}para o número de termos. Ou para iterar, é claro:

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

NOTA IMPORTANTE:

Isso funciona nos casos em que não há espaços com que se preocupar, o que resolveu o meu problema, mas pode não resolver o seu. Vá com a $IFS(s) solução (s) nesse caso.

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

Resultado

bla@some.com
john@home.com

Sistema: Ubuntu 12.04.1

Se não houver espaço, por que não isso?

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

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

Use o setbuilt-in para carregar a $@matriz:

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

Então, deixe a festa começar:

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

Duas alternativas de bourne-ish em que nenhuma delas exige matrizes de bash:

Caso 1 : Mantenha-o agradável e simples: use uma Nova Linha como separador de registros ... por exemplo.

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

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

Nota: neste primeiro caso, nenhum subprocesso é bifurcado para ajudar na manipulação da lista.

Idéia: Talvez valha a pena usar NL extensivamente internamente e apenas converter em um RS diferente ao gerar o resultado final externamente .

Caso 2 : Usando um ";" como um separador de registros ... por exemplo.

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"

Nos dois casos, uma sub-lista pode ser composta dentro do loop é persistente após a conclusão do loop. Isso é útil ao manipular listas na memória, em vez de armazenar listas em arquivos. {ps mantenha a calma e continue B-)}

Além das respostas fantásticas que já foram fornecidas, se for apenas uma questão de imprimir os dados, considere usar awk:

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

Isso define o separador de campo como ;, para que ele possa percorrer os campos com um forloop e imprimir adequadamente.

Teste

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

Com outra entrada:

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

No shell do Android, a maioria dos métodos propostos simplesmente não funciona:

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

O que funciona é:

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

onde //significa substituição global.

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

Resultado:

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

Explicação: A atribuição simples usando parênteses () converte a lista separada por ponto e vírgula em uma matriz, desde que você tenha o IFS correto ao fazer isso. O loop FOR padrão lida com itens individuais nessa matriz, como de costume. Observe que a lista fornecida para a variável IN deve ser "difícil" entre aspas, ou seja, com marcações simples.

O IFS deve ser salvo e restaurado, pois o Bash não trata uma atribuição da mesma maneira que um comando. Uma solução alternativa é agrupar a atribuição dentro de uma função e chamar essa função com um IFS modificado. Nesse caso, não é necessário salvar / restaurar separadamente o IFS. Obrigado por "Bize" por apontar isso.

Ok pessoal!

Aqui está a minha resposta!

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

Por que essa abordagem é "a melhor" para mim?

Por duas razões:

1. Você não precisa escapar do delimitador;
2. Você não terá problemas com espaços em branco . O valor será separado corretamente na matriz!

[]

Uma linha para dividir uma sequência separada por ';' em uma matriz é:

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

Isso define apenas o IFS em um subshell, para que você não precise se preocupar em salvar e restaurar seu valor.

Talvez não seja a solução mais elegante, mas trabalha com *espaços:

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

Saídas

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

Outro exemplo (delimitadores no início e no final):

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

Basicamente, ele remove todos os personagens que não ;fazer delims, por exemplo. ;;;. Em seguida, ele faz um forloop de 1para number-of-delimitersconforme contado ${#delims}. O passo final é obter a $iparte th com segurança cut.