Синтаксический анализ массива с использованием IFS с не-белыми пробелами создает пустые элементы.
Даже использования tr -sдля сокращения нескольких разделителей до одного раздела недостаточно.
Пример может объяснить проблему более четко.
Есть ли способ достичь "нормальных" результатов с помощью настройки IFS (есть ли связанные настройки для изменения поведения IFS? .... т.е. действовать так же, как пробельные символы по умолчанию МФС.

var=" abc  def   ghi    "
echo "============== IFS=<default>"
arr=($var)
for x in ${!arr[*]} ; do
   echo "# arr[$x] \"${arr[x]}\""
done
#
sfi="$IFS" ; IFS=':'
set -f # Disable file name generation (globbing)
       # (This  data won't "glob", but unless globbing     
       #  is actually needed, turn if off, because   
       #  unusual/unexpected combinations of data can glob!
       #  and they can do it in the most obscure ways...  
       #  With IFS, "you're not in Kansas any more! :)  
var=":abc::def:::ghi::::"
echo "============== IFS=$IFS"
arr=($var)
for x in ${!arr[*]} ; do
   echo "# arr[$x] \"${arr[x]}\""
done
echo "============== IFS=$IFS and tr"
arr=($(echo -n "$var"|tr -s "$IFS"))
for x in ${!arr[*]} ; do
   echo "# arr[$x] \"${arr[x]}\""
done
set +f     # enable globbing 
IFS="$sfi" # re-instate original IFS val
echo "============== IFS=<default>"

Вот вывод

============== IFS=<default>
# arr[0] "abc"
# arr[1] "def"
# arr[2] "ghi"
============== IFS=:
# arr[0] ""
# arr[1] "abc"
# arr[2] ""
# arr[3] "def"
# arr[4] ""
# arr[5] ""
# arr[6] "ghi"
# arr[7] ""
# arr[8] ""
# arr[9] ""
============== IFS=: and tr
# arr[0] ""
# arr[1] "abc"
# arr[2] "def"
# arr[3] "ghi"
============== IFS=<default>

Для удаления нескольких (не пробельных) последовательных символов-разделителей можно использовать два (строки / массива) расширения параметров. Хитрость заключается в том, чтобы установить IFSпеременную в пустую строку для расширения параметра массива.

Это описано в man bashразделе « Разделение слов» :

Не приведенные в кавычки неявные нулевые аргументы, являющиеся результатом расширения параметров, которые не имеют значений, удаляются.

(
set -f
str=':abc::def:::ghi::::'
IFS=':'
arr=(${str})
IFS=""
arr=(${arr[@]})

echo ${!arr[*]}

for ((i=0; i < ${#arr[@]}; i++)); do 
   echo "${i}: '${arr[${i}]}'"
done
)

С bashmanpage:

Любой символ в IFS, который не является пробелом IFS, наряду с любыми соседними символами пробела IFS ограничивает поле. Последовательность пробельных символов IFS также рассматривается как разделитель.

Это означает, что пробелы IFS (пробел, табуляция и новая строка) не обрабатываются как другие разделители. Если вы хотите получить точно такое же поведение с альтернативным разделителем, вы можете выполнить замену разделителя с помощью trили sed:

var=":abc::def:::ghi::::"
arr=($(echo -n $var | sed 's/ /%#%#%#%#%/g;s/:/ /g'))
for x in ${!arr[*]} ; do
   el=$(echo -n $arr | sed 's/%#%#%#%#%/ /g')
   echo "# arr[$x] \"$el\""
done

Эта %#%#%#%#%вещь является магическим значением для замены возможных пробелов внутри полей, ожидается, что она будет «уникальной» (или очень нелепой). Если вы уверены, что в полях никогда не будет места, просто отбросьте эту часть).

Поскольку bash IFS не предоставляет внутренний способ обработки последовательных символов-разделителей как одного разделителя (для разделителей без пробелов), я собрал версию полностью bash (в отличие от использования внешнего вызова, например, tr, awk, sed). )

Он может обрабатывать мульти-символ IFS ..

Вот его результаты во время выполнения, наряду с аналогичными тестами для параметров trи awk, показанными на этой странице Q / A ... Тесты основаны на 10000 итерациях простого построения массива (без ввода-вывода) ...

pure bash     3.174s (28 char IFS)
call (awk) 0m32.210s  (1 char IFS) 
call (tr)  0m32.178s  (1 char IFS) 

Вот вывод

# dlm_str  = :.~!@#$%^&()_+-=`}{][ ";></,
# original = :abc:.. def:.~!@#$%^&()_+-=`}{][ ";></,'single*quote?'..123:
# unified  = :abc::::def::::::::::::::::::::::::::::'single*quote?'::123:
# max-w 2^ = ::::::::::::::::
# shrunk.. = :abc:def:'single*quote?':123:
# arr[0] "abc"
# arr[1] "def"
# arr[2] "'single*quote?'"
# arr[3] "123"

Вот сценарий

#!/bin/bash

# Note: This script modifies the source string. 
#       so work with a copy, if you need the original. 
# also: Use the name varG (Global) it's required by 'shrink_repeat_chars'
#
# NOTE: * asterisk      in IFS causes a regex(?) issue,     but  *  is ok in data. 
# NOTE: ? Question-mark in IFS causes a regex(?) issue,     but  ?  is ok in data. 
# NOTE: 0..9 digits     in IFS causes empty/wacky elements, but they're ok in data.
# NOTE: ' single quote  in IFS; don't know yet,             but  '  is ok in data.
# 
function shrink_repeat_chars () # A 'tr -s' analog
{
  # Shrink repeating occurrences of char
  #
  # $1: A string of delimiters which when consecutively repeated and are       
  #     considered as a shrinkable group. A example is: "   " whitespace delimiter.
  #
  # $varG  A global var which contains the string to be "shrunk".
  #
# echo "# dlm_str  = $1" 
# echo "# original = $varG" 
  dlms="$1"        # arg delimiter string
  dlm1=${dlms:0:1} # 1st delimiter char  
  dlmw=$dlm1       # work delimiter  
  # More than one delimiter char
  # ============================
  # When a delimiter contains more than one char.. ie (different byte` values),    
  # make all delimiter-chars in string $varG the same as the 1st delimiter char.
  ix=1;xx=${#dlms}; 
  while ((ix<xx)) ; do # Where more than one delim char, make all the same in varG  
    varG="${varG//${dlms:$ix:1}/$dlm1}"
    ix=$((ix+1))
  done
# echo "# unified  = $varG" 
  #
  # Binary shrink
  # =============
  # Find the longest required "power of 2' group needed for a binary shrink
  while [[ "$varG" =~ .*$dlmw$dlmw.* ]] ; do dlmw=$dlmw$dlmw; done # double its length
# echo "# max-w 2^ = $dlmw"
  #
  # Shrik groups of delims to a single char
  while [[ ! "$dlmw" == "$dlm1" ]] ; do
    varG=${varG//${dlmw}$dlm1/$dlm1}
    dlmw=${dlmw:$((${#dlmw}/2))}
  done
  varG=${varG//${dlmw}$dlm1/$dlm1}
# echo "# shrunk.. = $varG"
}

# Main
  varG=':abc:.. def:.~!@#$%^&()_+-=`}{][ ";></,'\''single*quote?'\''..123:' 
  sfi="$IFS"; IFS=':.~!@#$%^&()_+-=`}{][ ";></,' # save original IFS and set new multi-char IFS
  set -f                                         # disable globbing
  shrink_repeat_chars "$IFS" # The source string name must be $varG
  arr=(${varG:1})    # Strip leading dlim;  A single trailing dlim is ok (strangely
  for ix in ${!arr[*]} ; do  # Dump the array
     echo "# arr[$ix] \"${arr[ix]}\""
  done
  set +f     # re-enable globbing   
  IFS="$sfi" # re-instate the original IFS
  #
exit

Вы также можете сделать это с gawk, но это не красиво:

var=":abc::def:::ghi::::"
out=$( gawk -F ':+' '
  {
    # strip delimiters from the ends of the line
    sub("^"FS,"")
    sub(FS"$","")
    # then output in a bash-friendly format
    for (i=1;i<=NF;i++) printf("\"%s\" ", $i)
    print ""
  }
' <<< "$var" )
eval arr=($out)
for x in ${!arr[*]} ; do
  echo "# arr[$x] \"${arr[x]}\""
done

выходы

# arr[0] "abc"
# arr[1] "def"
# arr[2] "ghi"

Ответ прост: сверните все разделители в один (первый).
Это требует цикла (который выполняется меньше, чем log(N)раз):

 var=':a bc::d ef:#$%_+$$%      ^%&*(*&*^
 $#,.::ghi::*::'                           # a long test string.
 d=':@!#$%^&*()_+,.'                       # delimiter set
 f=${d:0:1}                                # first delimiter
 v=${var//["$d"]/"$f"};                    # convert all delimiters to
 :                                         # the first of the delimiter set.
 tmp=$v                                    # temporal variable (v).
 while
     tmp=${tmp//["$f"]["$f"]/"$f"};        # collapse each two delimiters to one
     [[ "$tmp" != "$v" ]];                 # If there was a change
 do
     v=$tmp;                               # actualize the value of the string.
 done

Осталось только правильно разделить строку на один разделитель и вывести ее:

 readarray -td "$f" arr < <(printf '%s%s' "$v"'' "$f")
 printf '<%s>' "${arr[@]}" ; echo

Нет необходимости set -fни менять IFS.
Протестировано с пробелами, символами новой строки и глобусными символами. Все работают. Довольно медленный (как и следовало ожидать от цикла оболочки).
Но только для bash (bash 4.4+ из-за опции -dreadarray).

ш

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

 set -f; IFS=$f command eval set -- '$(echo "$var" | tr -s "$d" "[$f*]" )""'

И распечатать это:

 printf '<%s>' "$@" ; echo

Все еще медленно, но не намного.

Команда commandнедопустима в Борне.
В zsh commandвызывает только внешние команды и приводит к сбою eval, если commandиспользуется.
В ksh, даже при том command, что значение IFS изменяется в глобальной области видимости.
И commandделает разделение неудачным в оболочках, связанных с mksh (mksh, lksh, posh). Удаление команды commandзаставляет код работать на большем количестве оболочек. Но: удаление commandзаставит IFS сохранять свое значение в большинстве оболочек (eval - это специальная встроенная функция), за исключением bash (без режима posix) и zsh в режиме по умолчанию (без эмуляции). Эту концепцию нельзя заставить работать по умолчанию в zsh, с или без command.

Многосимвольный IFS

Да, IFS может быть многосимвольным, но каждый символ будет генерировать один аргумент:

 set -f; IFS="$d" command eval set -- '$(echo "$var" )""'
 printf '<%s>' "$@" ; echo

Будет выводить:

 <><a bc><><d ef><><><><><><><><><      ><><><><><><><><><
 ><><><><><><ghi><><><><><>

С bash вы можете опустить commandслово, если не в эмуляции sh / POSIX. Команда завершится ошибкой в ​​ksh93 (IFS сохраняет измененное значение). В zsh команда commandзаставляет zsh пытаться найти evalвнешнюю команду (которую она не находит) и завершается неудачно.

То, что происходит, - то, что единственные символы IFS, которые автоматически свернуты в один разделитель, являются пробелом IFS.
Один пробел в IFS свернет все последовательные пробелы в один. Одна вкладка свернет все вкладки. Один пробел и одна вкладка сворачивают серии пробелов и / или табуляций в один разделитель. Повторите идею с новой строкой.

Чтобы свернуть несколько разделителей, требуется некоторое жонглирование.
Предполагая, что ASCII 3 (0x03) не используется во входных данных var:

 var=${var// /$'\3'}                       # protect spaces
 var=${var//["$d"]/ }                      # convert all delimiters to spaces
 set -f;                                   # avoid expanding globs.
 IFS=" " command eval set -- '""$var""'    # split on spaces.
 set -- "${@//$'\3'/ }"                    # convert spaces back.

Большинство комментариев о ksh, zsh и bash (about commandи IFS) все еще применимы здесь.

Значение $'\0'будет менее вероятным при вводе текста, но переменные bash не могут содержать NUL ( 0x00).

В sh нет внутренних команд для выполнения одинаковых строковых операций, поэтому tr - единственное решение для sh-скриптов.