Как разбить строку на разделителе в Bash?

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

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) на ;. Я не уверен, что случилось с этим ответом, как вы reset IFS вернулись к умолчанию?

RE: IFS solution, я пробовал это, и он работает, я сохраняю старый 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 она работает.

+1759
28 мая '09 в 2:03
источник поделиться
36 ответов
  • 1
  • 2

Вы можете установить переменную internal field separator (IFS), а затем разрешить ее анализировать в массив. Когда это происходит в команде, тогда назначение IFS происходит только в этой среде с одной командой (до 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"
+1085
28 мая '09 в 2:23
источник

Взято из Bash shell script split array:

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

Пояснение:

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

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

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

  • Если исходная строка содержит пробелы, вам нужно будет использовать IFS:
    • IFS=':'; arrIN=($IN); unset IFS;
  • Если исходная строка содержит пробелы, а разделитель - это новая строка, вы можете установить IFS с помощью:
    • IFS=$'\n'; arrIN=($IN); unset IFS;
+858
10 мар. '11 в 9:00
источник

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

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

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

+222
28 мая '09 в 2:09
источник

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

На этот вопрос SO уже есть много разных способов сделать это в . Но у bash есть много специальных функций, так называемый bashism, которые хорошо работают, но не работают ни в одном другом .

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

В моем Debian GNU/Linux есть стандартная оболочка под названием , но я знаю многих людей, которые любят использовать .

Наконец, в очень маленькой ситуации есть специальный инструмент под названием с собственным интерпретатором оболочки ().

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

Пример строки в вопросе SO:

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

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

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

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

Под чистым bash мы можем использовать массивы и IFS:

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

oIFS="$IFS"
IFS=";"
declare -a fields=($var)
IFS="$oIFS"
unset oIFS

IFS=\; read -a fields <<<"$IN"

Использование этого синтаксиса в недавнем bash не меняет $IFS для текущего сеанса, а только для текущей команды:

set | grep ^IFS=
IFS=$' \t\n'

Теперь строка var разделяется и сохраняется в массив (именованные fields):

set | grep ^fields=\\\|^var=
fields=([0]="bla@some.com" [1]="john@home.com" [2]="Full Name <fulnam@other.org>")
var='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 - самый быстрый способ выполнить разделение, потому что нет никаких вилок и не вызывается никаких внешних ресурсов.

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

for x in "${fields[@]}";do
    echo "> [$x]"
    done
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]

или отбросить каждое поле после обработки (мне нравится этот подход смещения):

while [ "$fields" ] ;do
    echo "> [$fields]"
    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

Вы можете играть с mapfile:

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

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

Если вам не нужны пустые поля, вы можете:

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

Но вы можете использовать поля через функцию:

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.

Или Удалить новую строку, добавленную с помощью <<< синтаксиса bash в функции:

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

Будет отображать тот же результат:

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.

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

Но если бы вы написать что - то полезное под многими оболочками, вы должны не использовать bashisms.

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

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

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

Как указано Score_Under:

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

## и %% удаляют самое длинное из возможных.

где # и ## означают слева (начало) строки, и

% и %% означают справа (конец) строки.

Этот небольшой пример сценария хорошо работает в , , , и также был протестирован в Mac-OS bash:

var="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
while [ "$var" ] ;do
    iter=${var%%;*}
    echo "> [$iter]"
    [ "$var" = "$iter" ] && \
        var='' || \
        var="${var#*;}"
  done
> [bla@some.com]
> [john@home.com]
> [Full Name <fulnam@other.org>]

Повеселись!

+163
13 апр. '13 в 14:20
источник

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

В случае разделения этого конкретного примера на массив bash script 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 этого файла и выбрать конкретное поле для дальнейшей обработки.

+131
27 апр. '15 в 18:20
источник

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

string="1;2"
echo $string | cut -d';' -f1 # output is 1
echo $string | cut -d';' -f2 # output is 2
+96
11 авг. '16 в 20:45
источник

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

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

Источник

+84
28 мая '09 в 10:31
источник
echo "bla@some.com;john@home.com" | sed -e 's/;/\n/g'
bla@some.com
john@home.com
+62
28 мая '09 в 2:12
источник

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

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.

+62
08 сент. '12 в 5:01
источник

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

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

дам

bla@some.com john@home.com

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

+38
14 янв. '13 в 6:33
источник

Другой подход к Darron answer, вот как я это делаю:

IN="bla@some.com;john@home.com"
read ADDR1 ADDR2 <<<$(IFS=";"; echo $IN)
+30
05 июл. '11 в 13:41
источник

В 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 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")
+26
26 июн. '14 в 9:11
источник

Это должно работать везде:

echo "luke;yoda;leila" | tr ";" "\n"

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

+22
03 дек. '17 в 0:40

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

IFS=';' read ADDR1 ADDR2 <<<$IN
+21
13 сент. '10 в 20:10
источник

Вот чистый 3-лайнер:

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

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

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

+19
11 сент. '15 в 20:54
источник

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

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

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

вы получите:

b = foo
c = bar
+16
01 авг. '16 в 13:15
источник

Следующая функция 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 и -a в zsh.

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

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"
+9
24 мая '17 в 8:42
источник

Существует простой и понятный способ:

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

Но вы должны использовать gnu xargs, BSD xargs can not support -d delim. Если вы используете яблочный mac, как я. Вы можете установить gnu xargs:

brew install findutils

затем

echo "add:sfff" | gxargs -d: -i  echo {}
+7
16 сент. '15 в 3:34
источник

вы можете применить 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"
+6
20 янв. '18 в 15:54
источник

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

spo='one;two;three'
OIFS=$IFS
IFS=';'
spo_array=($spo)
IFS=$OIFS
echo ${spo_array[*]}
+5
25 сент. '11 в 1:09
источник

Здесь есть несколько интересных ответов (ошибочный вариант), но для чего-то аналогичного расколу на других языках - вот что я понял в исходном вопросе - я решил:

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 в этом случае.

+4
22 окт. '12 в 7:10
источник
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

+3
25 окт. '16 в 12:41
источник

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

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

echo ${arr[0]}
echo ${arr[1]}
+2
24 апр. '13 в 13:13
источник

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

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

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

Test

$ 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]
+2
08 янв. '15 в 10:21
источник

Две альтернативы 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"

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

+2
02 сент. '13 в 6:30
источник

Хорошо, ребята!

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

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

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

Из-за двух причин:

  • Вам не нужно скрывать разделитель;
  • У вас не будет проблемы с пробелами. Значение будет правильно разделено в массиве!

[] 's

+1
04 апр. '16 в 19:54
источник
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 не требуется. Спасибо за "Bize" за указание на это.

+1
10 окт. '14 в 11:33
источник

Используйте встроенный 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
+1
30 апр. '13 в 3:10
источник

В оболочке 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

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

+1
20 февр. '15 в 10:49
источник

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

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.

0
26 февр. '16 в 12:20
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос