Цей рядок у мене зберігається в змінній:

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лише відбувається оточенню однієї команди (до 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є багато особливих особливостей (так званих башизмів ), які не працюватимуть ні в якому іншомуоболонки.

Зокрема, масиви , асоціативні масиви та заміна шаблонів , які використовуються в рішеннях на цій посаді, а також інші в потоці, є башизмами і можуть не працювати під іншими оболонками , якими користуються багато людей.

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

Запитаний рядок

Рядок, який слід розділити у вищезазначеному питанні, є:

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або хочете написати щось, що може бути використано у багатьох різних оболонках, ви часто не можете використовувати башизми - і це включає масиви, які ми використовували у вищезазначених рішеннях.

Однак нам не потрібно використовувати масиви для переходу на "елементи" рядка. Існує синтаксис, який використовується в багатьох оболонках для видалення підрядків рядка з першого або останнього появи шаблону. Зауважте, що *це підстановка, яка означає нуль або більше символів:

(Відсутність такого підходу в будь-якому досі розміщеному рішенні є основною причиною написання цієї відповіді;)

${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),тире, кш, і busbox'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(ака 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 та -Aв zsh.

При бажанні функцію можна ввести в сценарій наступним чином:

#!/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. Якщо ви використовуєте яблучний мак, як я. Ви можете встановити 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[*]}

Тут є кілька цікавих відповідей (помилковий есп.), Але для того, щоб щось аналогічне розділенню іншими мовами, - що я вважав оригінальним питанням, - я вирішив це:

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 всередині , а лише переходити до іншого РС, коли генерує кінцевий результат зовнішньо .

Випадок 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. У вас не виникне проблем із порожніми пробілами . Значення буде належним чином відокремлено в масиві!

[]

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

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.