Analizar una matriz usando IFS con valores de espacio no blancos crea elementos vacíos.
Incluso usar tr -spara reducir múltiples delimitaciones a una sola delimitación no es suficiente.
Un ejemplo puede explicar el problema con mayor claridad.
¿Hay alguna forma de lograr resultados "normales" mediante un ajuste de IFS (¿hay una configuración asociada para cambiar el comportamiento de IFS? ... es decir, actuar de la misma manera que el espacio en blanco predeterminado 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>"

Aquí está la salida

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

Para eliminar múltiples caracteres delimitadores consecutivos (sin espacio), se pueden usar dos expansiones de parámetros (cadena / matriz). El truco consiste en establecer la IFSvariable en la cadena vacía para la expansión del parámetro de matriz.

Esto está documentado en man bashvirtud de la división de palabras :

Los argumentos nulos implícitos sin comillas, resultantes de la expansión de parámetros que no tienen valores, se eliminan.

(
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
)

Desde la página de bashmanual:

Cualquier carácter en IFS que no sea espacio en blanco IFS, junto con cualquier carácter de espacio en blanco IFS adyacente, delimita un campo. Una secuencia de caracteres de espacio en blanco IFS también se trata como un delimitador.

Significa que el espacio en blanco IFS (espacio, tabulación y nueva línea) no se trata como los otros separadores. Si desea obtener exactamente el mismo comportamiento con un separador alternativo, puede hacer un intercambio de separador con la ayuda de tro 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

La %#%#%#%#%cosa es un valor mágico para reemplazar los espacios posibles dentro de los campos, se espera que sea "único" (o muy poco vinculado). Si está seguro de que nunca habrá espacio en los campos, simplemente suelte esta parte).

Como bash IFS no proporciona una forma interna de tratar los caracteres delimitadores consecutivos como un único delimitador (para delimitadores que no son espacios en blanco), he creado una versión de todo bash (vs.utilizando una llamada externa, por ejemplo, tr, awk, sed )

Puede manejar IFS de múltiples caracteres.

A continuación se resu su tiempo de ejecución; ts, junto con pruebas similares para el try awkopciones que aparecen en esta / Una página Q ... Las pruebas se basan en 10000 itterations de sólo la construcción de la arrray (sin E / S) ...

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

Aquí está la salida

# 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"

Aquí está el guión

#!/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

También puedes hacerlo con gawk, pero no es bonito:

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

salidas

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

La respuesta simple es: colapsar todos los delimitadores en uno (el primero).
Eso requiere un bucle (que se ejecuta menos de log(N)veces):

 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

Todo lo que queda por hacer es dividir correctamente la cadena en un delimitador e imprimirla:

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

No es necesario set -fni cambiar IFS.
Probado con espacios, líneas nuevas y caracteres globales. Todo el trabajo. Bastante lento (como debería esperarse que sea un ciclo de shell).
Pero solo para bash (bash 4.4+ debido a la opción -dde readarray).

sh

Una versión de shell no puede usar una matriz, la única matriz disponible son los parámetros posicionales.
Usar tr -ses solo una línea (IFS no cambia en el script):

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

E imprimirlo:

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

Todavía lento, pero no mucho más.

El comando commandno es válido en Bourne.
En zsh, commandllama solo a comandos externos y hace que eval falle si commandse usa.
En ksh, incluso con command, el valor de IFS cambia en el ámbito global.
Y commandhace que la división falle en los shells relacionados con mksh (mksh, lksh, posh) Al eliminar el comando, commandel código se ejecuta en más shells. Pero: la eliminación commandhará que IFS conserve su valor en la mayoría de los shells (eval es un valor incorporado especial) excepto en bash (sin modo posix) y zsh en modo predeterminado (sin emulación). No se puede hacer que este concepto funcione en zsh predeterminado con o sin command.

Múltiples caracteres IFS

Sí, IFS podría tener varios caracteres, pero cada carácter generará un argumento:

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

Saldrá:

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

Con bash, puede omitir la commandpalabra si no está en la emulación sh / POSIX. El comando fallará en ksh93 (IFS mantiene el valor cambiado). En zsh, el comando commandhace que zsh intente buscar evalcomo un comando externo (que no encuentra) y falla.

Lo que sucede es que los únicos caracteres IFS que se contraen automáticamente en un delimitador son espacios en blanco IFS.
Un espacio en IFS colapsará todos los espacios consecutivos en uno. Una pestaña colapsará todas las pestañas. Un espacio y una pestaña contraerán series de espacios y / o pestañas en un delimitador. Repita la idea con nueva línea.

Para colapsar varios delimitadores se requieren algunos malabarismos.
Suponiendo que ASCII 3 (0x03) no se usa en la entrada 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.

La mayoría de los comentarios sobre ksh, zsh y bash (about commande IFS) todavía se aplican aquí.

Un valor de $'\0'sería menos probable en la entrada de texto, pero las variables bash no pueden contener NUL ( 0x00).

No hay comandos internos en sh para hacer las mismas operaciones de cadena, por lo que tr es la única solución para los scripts sh.