У меня есть эта строка хранится в переменной:

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

Теперь я хотел бы разделить строки по ;разделителю, чтобы у меня было:

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

Я не обязательно нужен ADDR1и ADDR2переменные. Если они являются элементами массива, это даже лучше.

После предложений из ответов, приведенных ниже, я получил следующее:

#!/usr/bin/env bash

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

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

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

Вывод:

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

Было решение, включающее установку Internal_field_separator (IFS) в ;. Я не уверен, что случилось с этим ответом, как вы IFSвернетесь к настройкам по умолчанию?

RE: IFSрешение, я попробовал это, и оно работает, я сохраняю старое IFSи затем восстанавливаю это:

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

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

IFS=$OIFS

Кстати, когда я пытался

mails2=($IN)

Я получил только первую строку при печати в цикле, без скобок вокруг $INэто работает.

Вы можете установить переменную внутреннего разделителя полей (IFS), а затем разрешить ее анализ в массив. Когда это происходит в команде, тогда присваивание IFSпроисходит только среде этой отдельной команды (to read). Затем он анализирует входные данные в соответствии со IFSзначением переменной в массив, который мы затем можем перебрать.

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

Он будет анализировать одну строку элементов, разделенных ;, помещая ее в массив. Материал для обработки всего $IN, каждый раз одна строка ввода разделяется ;:

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

Взято из скриптового массива Bash :

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

Объяснение:

Эта конструкция заменяет все вхождения ';'(начальная //означает глобальную замену) в строке INна ' '(один пробел), а затем интерпретирует строку, разделенную пробелом, как массив (это то, что делают окружающие скобки).

Синтаксис, используемый внутри фигурных скобок для замены каждого ';'символа на ' 'символ, называется расширением параметра .

Есть несколько распространенных ошибок:

1. Если в исходной строке есть пробелы, вам нужно использовать IFS :
   • IFS=':'; arrIN=($IN); unset IFS;
2. Если в исходной строке есть пробелы и разделителем является новая строка, вы можете установить IFS с помощью:
   • IFS=$'\n'; arrIN=($IN); unset IFS;

Если вы не возражаете обработать их немедленно, мне нравится делать это:

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

Вы можете использовать этот тип цикла для инициализации массива, но, вероятно, есть более простой способ сделать это. Надеюсь, это поможет, хотя.

Совместимый ответ

Есть много разных способов сделать это в удар,

Тем не менее, важно сначала отметить, что bashимеет много специальных функций (так называемых bashisms ), которые не будут работать ни в одном другомракушка,

В частности, массивы , ассоциативные массивы и подстановка шаблонов , которые используются в решениях в этом посте, а также в других цепочках , являются ошибками и могут не работать под другими оболочками, которые используют многие люди.

Например: на моем Debian GNU / Linux есть стандартная оболочка под названиемтире; Я знаю многих людей, которые любят использовать другую оболочку под названиемКШ; и есть также специальный инструмент под названиемBusyBox с его собственным интерпретатором оболочки (ясень).

Запрашиваемая строка

Строка, которая будет разбита в приведенном выше вопросе:

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

Я буду использовать модифицированную версию этой строки, чтобы убедиться, что мое решение устойчиво к строкам, содержащим пробелы, которые могут нарушить другие решения:

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

Разделить строку на основе разделителя в удар (версия> = 4.2)

В чистом виде bash мы можем создать массив с элементами, разделенными временным значением для IFS ( разделитель входного поля ). IFS, помимо прочего, сообщает, bashкакой символ (символы) он должен рассматривать как разделитель между элементами при определении массива:

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

В более новых версиях bash, предварив команду с определением МФСА изменяет IFS для этой команды только и сбрасывает его в предыдущее значение сразу же после этого. Это означает, что мы можем сделать выше всего одну строку:

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'

Мы можем видеть, что строка INбыла сохранена в массив с именем 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>'

(Мы также можем отобразить содержимое этих переменных, используя 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>")

Обратите внимание, что readэто самый быстрый способ сделать разделение, потому что нет никаких вызванных вилок или внешних ресурсов.

Как только массив определен, вы можете использовать простой цикл для обработки каждого поля (или, вернее, каждого элемента в массиве, который вы сейчас определили):

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

Или вы можете удалить каждое поле из массива после обработки, используя подход смещения , который мне нравится:

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

И если вам нужна простая распечатка массива, вам даже не нужно зацикливаться на нем:

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

Обновление: недавно удар > = 4.4

В новых версиях bashвы также можете играть с командой mapfile:

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

Этот синтаксис сохраняет специальные символы, новые строки и пустые поля!

Если вы не хотите включать пустые поля, вы можете сделать следующее:

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

С помощью mapfileвы также можете пропустить объявление массива и неявно «зацикливаться» на элементах с разделителями, вызывая функцию для каждого:

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

(Примечание: \0конец строки формата бесполезен, если вам не нужны пустые поля в конце строки или они отсутствуют.)

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.

Или вы можете использовать <<<, и в теле функции включить некоторую обработку для удаления новой строки:

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.

Разделить строку на основе разделителя в ракушка

Если вы не можете использовать bashили если вы хотите написать что-то, что можно использовать во многих различных оболочках, вы часто не можете использовать bashisms - и это включает в себя массивы, которые мы использовали в решениях выше.

Однако нам не нужно использовать массивы для циклического перебора «элементов» строки. Существует синтаксис, используемый во многих оболочках для удаления подстрок строки из первого или последнего вхождения шаблона. Обратите внимание, что *подстановочный знак обозначает ноль или более символов:

(Отсутствие такого подхода в любом опубликованном решении является основной причиной, по которой я пишу этот ответ;)

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

#и %удалите максимально короткую подходящую подстроку из начала и конца строки соответственно, и

##и %%удалите максимально длинную подходящую подстроку.

Используя приведенный выше синтаксис, мы можем создать подход, в котором мы извлекаем «элементы» подстроки из строки, удаляя подстроки до или после разделителя.

Кодовый блок ниже хорошо работает в удар(включая Mac OS bash),тире, КШ, а также BusyBox«s ясень:

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

Радоваться, веселиться!

Я видел пару ответов со ссылкой на cutкоманду, но все они были удалены. Немного странно, что никто не уточнил это, потому что я думаю, что это одна из наиболее полезных команд для такого типа вещей, особенно для анализа файлов журнала с разделителями.

В случае разбиения этого конкретного примера на массив сценариев bash, trвозможно, он более эффективен, но cutего можно использовать, и он более эффективен, если вы хотите извлечь определенные поля из середины.

Пример:

$ 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

Очевидно, вы можете поместить это в цикл и выполнить итерацию параметра -f для независимого извлечения каждого поля.

Это становится более полезным, когда у вас есть лог-файл с разделителями со строками вроде этого:

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

cutочень удобно иметь возможность catэтого файла и выбрать конкретное поле для дальнейшей обработки.

Это сработало для меня:

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

Как насчет этого подхода:

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

Источник

Я думаю, что AWK - лучшая и эффективная команда для решения вашей проблемы. AWK включен по умолчанию почти во все дистрибутивы Linux.

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

дам

bla@some.com john@home.com

Конечно, вы можете сохранить каждый адрес электронной почты, переопределив поле печати awk.

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

Это также работает:

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

Будьте осторожны, это решение не всегда правильно. Если вы передадите только «bla@some.com», он назначит его как ADD1, так и ADD2.

Другой ответ на ответ Даррона , вот как я это делаю:

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

В Bash, пуленепробиваемый способ, который будет работать, даже если ваша переменная содержит символы новой строки:

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

Смотреть:

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

Хитрость для этого заключается в том, чтобы использовать -dопцию read(разделитель) с пустым разделителем, так что readон вынужден читать все, что ему дают. И мы добавляем readименно содержимое переменной in, без завершающей строки, благодаря printf. Обратите внимание, что мы также добавляем разделитель, printfчтобы убедиться, что переданная строка readимеет конечный разделитель. Без него readобрезал бы потенциальные конечные пустые поля:

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

конечное пустое поле сохраняется.

Обновление для Bash≥4.4

Начиная с Bash 4.4, встроенная функция mapfile(aka readarray) поддерживает -dвозможность указания разделителя. Отсюда и другой канонический способ:

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

Как насчет этого одного лайнера, если вы не используете массивы:

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

Без настройки IFS

Если у вас есть только двоеточие, вы можете сделать это:

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

ты получишь:

b = foo
c = bar

Вот чистый 3-х вкладыш:

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

где IFSслова разграничиваются на основе разделителя и ()используются для создания массива . затем[@] используется для возврата каждого элемента как отдельного слова.

Если у вас есть какой-либо код после этого, вам также необходимо восстановить $IFS, например unset IFS.

Следующая функция Bash / zsh разделяет свой первый аргумент на разделитель, заданный вторым аргументом:

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
}

Например, команда

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

доходность

a
b
c

Этот вывод может, например, передаваться другим командам. Пример:

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

По сравнению с другими решениями, данное имеет следующие преимущества:

• IFSне переопределяется: из-за динамического определения области действия даже локальных переменных переопределение IFSпо циклу вызывает утечку нового значения в вызовы функций, выполняемые из цикла.

• Массивы не используются: для чтения строки в массив readнеобходимо использовать флаг -aв Bash и -Azsh.

При желании функция может быть помещена в скрипт следующим образом:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

Вы можете применить awk во многих ситуациях

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

также вы можете использовать это

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

Существует простой и умный способ, как это:

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

Но вы должны использовать gnu xargs, BSD xargs не может поддерживать -d delim. Если вы используете Apple Mac, как я. Вы можете установить GNU XARGS:

brew install findutils

тогда

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

Это самый простой способ сделать это.

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

Здесь есть несколько классных ответов (errator esp.), Но для чего-то аналогичного разделению на другие языки - что я и имел в виду в первоначальном вопросе - я остановился на этом:

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

Теперь ${a[0]}и ${a[1]}т. Д., Как и следовало ожидать. Используйте ${#a[*]}для ряда условий. Или, конечно, повторить:

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

ВАЖНАЯ ЗАМЕТКА:

Это работает в тех случаях, когда нет места для беспокойства, что решило мою проблему, но не может решить вашу. Перейти с $IFSрешением (ями) в этом случае.

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

Вывод

bla@some.com
john@home.com

Система: Ubuntu 12.04.1

Если нет места, почему бы не это?

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

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

Используйте setвстроенный для загрузки $@массива:

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

Тогда пусть вечеринка начнется:

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

Две альтернативы bourne-ish, где ни один не требует массивов bash:

Случай 1 : Делайте это красиво и просто: используйте NewLine в качестве разделителя записей ... например.

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

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

Примечание: в этом первом случае ни один подпроцесс не разветвляется, чтобы помочь с манипулированием списком.

Идея: Может быть, стоит использовать NL для внутреннего использования , и преобразовывать его в другой RS только при внешнем генерировании конечного результата .

Случай 2 : использование «;» в качестве разделителя записей ... например.

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"

В обоих случаях под-список может быть составлен в цикле постоянным после завершения цикла. Это полезно при работе со списками в памяти, вместо хранения списков в файлах. {ps сохраняйте спокойствие и продолжайте B-)}

Помимо фантастических ответов, которые уже были предоставлены, если это просто вопрос распечатки данных, которые вы можете использовать awk:

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

Это устанавливает разделитель полей на ;, чтобы он мог перебирать поля сfor цикла и печатать соответственно.

Тестовое задание

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

С другим входом:

$ 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 большинство предложенных методов просто не работают:

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

Что работает это:

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

где //означает глобальную замену.

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

Вывод:

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

Объяснение: Простое присваивание с использованием круглых скобок () преобразует список, разделенный точкой с запятой, в массив, если при этом у вас есть правильный IFS. Стандартный цикл FOR обрабатывает отдельные элементы в этом массиве как обычно. Обратите внимание, что список, заданный для переменной IN, должен быть «жестко» заключен в кавычки, то есть с одиночными тиками.

IFS должен быть сохранен и восстановлен, так как Bash не обрабатывает назначение так же, как команда. Альтернативный обходной путь - обернуть назначение внутри функции и вызвать эту функцию с измененным IFS. В этом случае отдельное сохранение / восстановление IFS не требуется. Спасибо за "Бизе" за указание на это.

Ладно, ребята!

Вот мой ответ!

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

Почему этот подход "лучший" для меня?

По двум причинам:

1. Вам не нужно избегать разделителя;
2. У вас не будет проблем с пробелами . Значение будет правильно разделено в массиве!

[] 'S

Однострочник для разделения строки, разделенной ';' в массив это:

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

Это только устанавливает IFS в подоболочке, поэтому вам не нужно беспокоиться о сохранении и восстановлении его значения.

Возможно, не самое элегантное решение, но работает с *пробелами:

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

Выходы

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

Другой пример (разделители в начале и в конце):

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

В основном это удаляет каждый символ, кроме ;создания, delimsнапример. ;;;, Затем он выполняет forцикл от 1до, number-of-delimitersкак считается ${#delims}. Последний шаг - это безопасное $iиспользование cut.