чтение в bash на файле с разделителями табуляции без сворачивания пустых полей

Я пытаюсь прочитать многострочный разделенный вкладками файл в bash. Формат таков, что ожидаются пустые поля. К сожалению, оболочка разрушается вместе разделителями полей, которые находятся рядом друг с другом, так:

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

...в отличие от желаемого выхода <one> <> <three>.

можно ли это решить, не прибегая к отдельному языку (например, awk)?

10
bash

5 ответов

вот подход с некоторыми тонкостями:

  • входные данные из любого места становятся псевдо-2D массивом в основном коде (избегая общей проблемы, когда данные доступны только на одном этапе конвейера).
  • нет использования awk, tr или других внешних прогов
  • пара доступа get/put, чтобы скрыть синтаксис hairier
  • работает на строках с разделителями табуляции, используя param matching вместо IFS=

код. file_data и file_input предназначены только для генерации ввода, как будто из внешней команды, вызванной из скрипта. data и cols может быть параметризован для get и put вызовы и т. д., Но этот скрипт не заходит так далеко. 

#!/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= c= i ; (( i = cols * r + c )) ; echo "${data[$i]}" ; }
put () { local r= c= i ; (( i = cols * r + c )) ; data[$i]="" ; }

# 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

выход:

$ ./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
3

обязательно

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

Я немного переставил пример, но только для того, чтобы он работал в любой оболочке Posix.

Update: да, кажется, что пробел особенный, по крайней мере, если он находится в IFS. См. вторую половину этого абзаца из 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.
10

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

$ 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

вот быстрая и простая функция, которую я использую, которая позволяет избежать вызова внешних программ или ограничения диапазона входных символов. Он работает только в bash (я думаю).

если он должен учитывать больше переменных, чем полей, однако, он должен быть изменен вдоль ответа Чарльза Даффи.

# 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 "" <<< "${input%%[$IFS]*}"
                input="${input#*[$IFS]}"
                shift
        done
        IFS= read -r "" <<< "$input"
}
3

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

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 "" '%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 "" '%s\t%s' "${!1}" "$element"
            else
                printf -v "" '%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 "" '%s' ''
            shift
        done
    fi

    # reset IFS to its original value (or the default, if it was
    # formerly unset)
    IFS="$old_ifs"
}

использование следующим образом:

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