lire dans bash sur un fichier délimité par des tabulations sans effondrement de champs vides

Je suis en train de lire plusieurs lignes séparées par des tabulations fichier bash. Le format est telle que les champs vides sont attendus. Malheureusement, la coquille s'effondre ensemble séparateurs de champ qui sont à côté les uns des autres, de la manière suivante:

# IFS=$'\t'
# read one two three <<<$'one\t\tthree'
# printf '<%s> ' "$one" "$two" "$three"; printf '\n'
<one> <three> <>

...plutôt que le résultat désiré de <one> <> <three>.

Cela peut-il être résolu sans avoir recours à une autre langue (comme awk)?

source d'informationauteur Charles Duffy

  1. 3

    Voici une approche avec quelques subtilités:

    • données d'entrée à partir de la mesure devient un pseudo-tableau 2D dans le code principal (en évitant un problème commun où les données ne sont disponibles que dans un délai d'un stade, d'un pipeline).
    • aucune utilisation de awk, tr, ou d'autres progs
    • un get/put accesseur paire de cacher les poilus de la syntaxe
    • travaux sur l'onglet délimité par des lignes en utilisant des param correspondant au lieu des IFS=

    Le code. file_data et file_input sont juste pour la génération d'entrée, comme si à partir d'une commande externe appelé par le script. data et cols pourrait être paramétrés pour le get et put appels, etc, mais ce script ne va pas aussi loin. 

    #!/bin/bash
file_data=( $'\t\t'       $'\t\tbC'     $'\tcB\t'     $'\tdB\tdC'   \
$'eA\t\t'     $'fA\t\tfC'   $'gA\tgB\t'   $'hA\thB\thC' )
file_input () { printf '%s\n' "${file_data[@]}" ; }  # simulated input file
delim=$'\t'
# the IFS=$'\n' has a side-effect of skipping blank lines; acceptable:
OIFS="$IFS" ; IFS=$'\n' ; oset="$-" ; set -f
lines=($(file_input))                    # read the "file"
set -"$oset" ; IFS="$OIFS" ; unset oset  # cleanup the environment mods.
# the read-in data has (rows * cols) fields, with cols as the stride:
data=()
cols=0
get () { local r=$1 c=$2 i ; (( i = cols * r + c )) ; echo "${data[$i]}" ; }
put () { local r=$1 c=$2 i ; (( i = cols * r + c )) ; data[$i]="$3" ; }
# convert the lines from input into the pseudo-2D data array:
i=0 ; row=0 ; col=0
for line in "${lines[@]}" ; do
line="$line$delim"
while [ -n "$line" ] ; do
case "$line" in
*${delim}*) data[$i]="${line%%${delim}*}" ; line="${line#*${delim}}" ;;
*)          data[$i]="${line}"            ; line=                     ;;
esac
(( ++i ))
done
[ 0 = "$cols" ] && (( cols = i )) 
done
rows=${#lines[@]}
# output the data array as a matrix, using the get accessor
for    (( row=0 ; row < rows ; ++row )) ; do
printf 'row %2d: ' $row
for (( col=0 ; col < cols ; ++col )) ; do
printf '%5s ' "$(get $row $col)"
done
printf '\n'
done

    De sortie:

    $ ./tabtest 
row  0:                   
row  1:                bC 
row  2:          cB       
row  3:          dB    dC 
row  4:    eA             
row  5:    fA          fC 
row  6:    gA    gB       
row  7:    hA    hB    hC
  2. 10

    Sûr

    IFS=,
echo $'one\t\tthree' | tr \\11 , | (
read one two three
printf '<%s> ' "$one" "$two" "$three"; printf '\n'
)

    J'ai réorganisé l'exemple de juste un peu, mais seulement pour le faire fonctionner dans tout le shell Posix.

    Mise à jour: Ouais, il semble que l'espace blanc est spécial, au moins si c'est en IFS. Voir la deuxième moitié de ce point de bash(1):

       The shell treats each character of IFS as a delimiter, and  splits  the
results of the other expansions into words on these characters.  If IFS
is unset, or its value is exactly <space><tab><newline>,  the  default,
then  any  sequence  of IFS characters serves to delimit words.  If IFS
has a value other than the default, then sequences  of  the  whitespace
characters  space  and  tab are ignored at the beginning and end of the
word, as long as the whitespace character is in the value  of  IFS  (an
IFS whitespace character).  Any character in IFS that is not IFS white-
space, along with any adjacent IFS whitespace  characters,  delimits  a
field.   A  sequence  of IFS whitespace characters is also treated as a
delimiter.  If the value of IFS is null, no word splitting occurs.
  3. 4

    Il n'est pas nécessaire d'utiliser trmais il est nécessaire que IFS est un caractère non-blanc (sinon multiples obtenir effondrée pour les célibataires comme vous l'avez vu).

    $ IFS=, read -r one two three <<<'one,,three'
$ printf '<%s> ' "$one" "$two" "$three"; printf '\n'
<one> <> <three>
$ var=$'one\t\tthree'
$ var=${var//$'\t'/,}
$ IFS=, read -r one two three <<< "$var"
$ printf '<%s> ' "$one" "$two" "$three"; printf '\n'
<one> <> <three>
$ idel=$'\t' odel=','
$ var=$'one\t\tthree'
$ var=${var//$idel/$odel}
$ IFS=$odel read -r one two three <<< "$var"
$ printf '<%s> ' "$one" "$two" "$three"; printf '\n'
<one> <> <three>
  4. 3

    Voici un rapide et simple de la fonction j'utilise ça évite d'appel de programmes externes ou la limitation de la plage de caractères d'entrée. Il fonctionne en bash uniquement (je suppose).

    Si c'est pour permettre plus de variables que de champs, cependant, il doit être modifié, le long de la Charles Duffy réponse.

    # Substitute for `read -r' that doesn't merge adjacent delimiters.
myread() {
local input
IFS= read -r input || return $?
while [[ "$#" -gt 1 ]]; do
IFS= read -r "$1" <<< "${input%%[$IFS]*}"
input="${input#*[$IFS]}"
shift
done
IFS= read -r "$1" <<< "$input"
}
  5. 3

    J'ai écrit une fonction qui fonctionne autour de cette question. Cette mise en oeuvre particulière est particulier à propos de l'onglet séparées par des colonnes et des retour à la ligne séparées par des lignes, mais cette limitation peut être enlevé comme un exercice simple:

    read_tdf_line() {
local default_ifs=$' \t\n'
local n line element at_end old_ifs
old_ifs="${IFS:-${default_ifs}}"
IFS=$'\n'
if ! read -r line ; then
return 1
fi
at_end=0
while read -r element; do
if (( $# > 1 )); then
printf -v "$1" '%s' "$element"
shift
else
if (( at_end )) ; then
# replicate read behavior of assigning all excess content
# to the last variable given on the command line
printf -v "$1" '%s\t%s' "${!1}" "$element"
else
printf -v "$1" '%s' "$element"
at_end=1
fi
fi
done < <(tr '\t' '\n' <<<"$line")
# if other arguments exist on the end of the line after all
# input has been eaten, they need to be blanked
if ! (( at_end )) ; then
while (( $# )) ; do
printf -v "$1" '%s' ''
shift
done
fi
# reset IFS to its original value (or the default, if it was
# formerly unset)
IFS="$old_ifs"
}

    D'utilisation comme suit:

    # read_tdf_line one two three rest <<<$'one\t\tthree\tfour\tfive'
# printf '<%s> ' "$one" "$two" "$three" "$rest"; printf '\n'
<one> <> <three> <four       five>