Почему вырезать не удается с помощью bash, а не zsh?

Я создаю файл с разделенными табуляцией полями.

echo foo$'\t'bar$'\t'baz$'\n'foo$'\t'bar$'\t'baz > input

У меня есть следующий скрипт с именем zsh.sh

#!/usr/bin/env zsh
while read line; do
    <<<$line cut -f 2
done < "$1"

Я проверяю это.

$ ./zsh.sh input
bar
bar

Это отлично работает. Однако, когда я изменяю первую строку, чтобы вызвать bashвместо этого, это терпит неудачу.

$ ./bash.sh input
foo bar baz
foo bar baz

Почему это терпит неудачу bashи работает с zsh?

Дополнительное устранение неполадок

• Использование прямых путей в шебанге вместо того envже самого поведения.
• Трубопровод с echoиспользованием здесь-строки <<<$lineтакже приводит к тому же самому поведению. то есть echo $line | cut -f 2.
• Использование awkвместо cut работает для обеих оболочек. то есть <<<$line awk '{print $2}'.

Что происходит, это bashзаменяет вкладки пробелами. Вы можете избежать этой проблемы, говоря "$line"вместо этого, или явно сокращая пробелы.

Это связано с тем <<< $line, bashчто разделение слов выполняется (хотя и не глобально), так $lineкак оно там не заключено в кавычки, а затем соединяет результирующие слова с пробелом (и помещает их во временный файл, после которого следует символ новой строки и делает его стандартным cut).

$ a=a,b,,c bash -c 'IFS=","; sed -n l <<< $a'
a b  c$

tabслучается в значении по умолчанию $IFS:

$ a=$'a\tb'  bash -c 'sed -n l <<< $a'
a b$

Решение с помощью bashкавычки переменной.

$ a=$'a\tb' bash -c 'sed -n l <<< "$a"'
a\tb$

Обратите внимание, что это единственная оболочка, которая делает это. zsh(откуда <<<взято, вдохновлено портом Unix rc) ksh93, mkshи yashкоторые также поддерживают <<<, не делают этого.

Когда речь идет о массивах mksh, yashи zshприсоединиться на первый символ $IFS, bashи ksh93на пространстве.

$ mksh -c 'a=(1 2); IFS=:; sed -n l <<< "${a[@]}"'
1:2$
$ yash -c 'a=(1 2); IFS=:; sed -n l <<< "${a[@]}"'
1:2$
$ ksh -c 'a=(1 2); IFS=:; sed -n l <<< "${a[@]}"'
1 2$
$ zsh -c 'a=(1 2); IFS=:; sed -n l <<< "${a[@]}"'
1:2$
$ bash -c 'a=(1 2); IFS=:; sed -n l <<< "${a[@]}"'
1 2$

Существует разница между zsh/ yashи mksh(по крайней мере, версия R52), когда $IFSпусто:

$ mksh -c 'a=(1 2); IFS=; sed -n l <<< "${a[@]}"'
1 2$
$ zsh -c 'a=(1 2); IFS=; sed -n l <<< "${a[@]}"'
12$

Поведение является более согласованным для всех оболочек, когда вы используете "${a[*]}"(за исключением того, что mkshошибка $IFSостается пустой).

Во- echo $line | ...первых, это обычный оператор split + glob во всех Bourne-подобных оболочках, но zsh(и обычные проблемы, связанные с echo).

Проблема в том, что вы не цитируете $line. Чтобы исследовать, измените два сценария, чтобы они просто печатали $line:

#!/usr/bin/env bash
while read line; do
    echo $line
done < "$1"

и

#!/usr/bin/env zsh
while read line; do
    echo $line
done < "$1"

Теперь сравните их вывод:

$ bash.sh input 
foo bar baz
foo bar baz
$ zsh.sh input 
foo    bar    baz
foo    bar    baz

Как вы можете видеть, поскольку вы не цитируете $line, вкладки неправильно интерпретируются bash. Zsh, кажется, справляется с этим лучше. Теперь по умолчанию cutиспользуется \tв качестве разделителя полей. Следовательно, поскольку ваш bashсценарий потребляет вкладки (из-за оператора split + glob), он cutвидит только одно поле и действует соответственно. То, что вы действительно запускаете, это:

$ echo "foo bar baz" | cut -f 2
foo bar baz

Итак, чтобы ваш скрипт работал как положено в обеих оболочках, заключите вашу переменную в кавычки:

while read line; do
    <<<"$line" cut -f 2
done < "$1"

Затем оба выдают одинаковый результат:

$ bash.sh input 
bar
bar
$ zsh.sh input 
bar
bar

Как уже было сказано, более переносимый способ использования переменной - заключить ее в кавычки:

$ printf '%s\t%s\t%s\n' foo bar baz
foo    bar    baz
$ l="$(printf '%s\t%s\t%s\n' foo bar baz)"
$ <<<$l     sed -n l
foo bar baz$

$ <<<"$l"   sed -n l
foo\tbar\tbaz$

В bash есть разница в реализации:

l="$(printf '%s\t%s\t%s\n' foo bar baz)"; <<<$l  sed -n l

Это результат большинства оболочек:

/bin/sh         : foo bar baz$
/bin/b43sh      : foo bar baz$
/bin/bash       : foo bar baz$
/bin/b44sh      : foo\tbar\tbaz$
/bin/y2sh       : foo\tbar\tbaz$
/bin/ksh        : foo\tbar\tbaz$
/bin/ksh93      : foo\tbar\tbaz$
/bin/lksh       : foo\tbar\tbaz$
/bin/mksh       : foo\tbar\tbaz$
/bin/mksh-static: foo\tbar\tbaz$
/usr/bin/ksh    : foo\tbar\tbaz$
/bin/zsh        : foo\tbar\tbaz$
/bin/zsh4       : foo\tbar\tbaz$

Только bash разделяет переменную справа от <<<кавычек.
Однако это было исправлено в bash версии 4.4.
Это означает, что значение $IFSвлияет на результат <<<.

С линией:

l=(1 2 3); IFS=:; sed -n l <<<"${l[*]}"

Все оболочки используют первый символ IFS для объединения значений.

/bin/y2sh       : 1:2:3$
/bin/sh         : 1:2:3$
/bin/b43sh      : 1:2:3$
/bin/b44sh      : 1:2:3$
/bin/bash       : 1:2:3$
/bin/ksh        : 1:2:3$
/bin/ksh93      : 1:2:3$
/bin/lksh       : 1:2:3$
/bin/mksh       : 1:2:3$
/bin/zsh        : 1:2:3$
/bin/zsh4       : 1:2:3$

При этом "${l[@]}"необходим пробел для разделения различных аргументов, но некоторые оболочки предпочитают использовать значение из IFS (это правильно?).

/bin/y2sh       : 1:2:3$
/bin/sh         : 1 2 3$
/bin/b43sh      : 1 2 3$
/bin/b44sh      : 1 2 3$
/bin/bash       : 1 2 3$
/bin/ksh        : 1 2 3$
/bin/ksh93      : 1 2 3$
/bin/lksh       : 1:2:3$
/bin/mksh       : 1:2:3$
/bin/zsh        : 1:2:3$
/bin/zsh4       : 1:2:3$

При нулевом IFS значения должны быть объединены, как в этой строке:

a=(1 2 3); IFS=''; sed -n l <<<"${a[*]}"

/bin/y2sh       : 123$
/bin/sh         : 123$
/bin/b43sh      : 123$
/bin/b44sh      : 123$
/bin/bash       : 123$
/bin/ksh        : 123$
/bin/ksh93      : 123$
/bin/lksh       : 1 2 3$
/bin/mksh       : 1 2 3$
/bin/zsh        : 123$
/bin/zsh4       : 123$

Но и lksh, и mksh не могут этого сделать.

Если мы перейдем к списку аргументов:

l=(1 2 3); IFS=''; sed -n l <<<"${l[@]}"

/bin/y2sh       : 123$
/bin/sh         : 1 2 3$
/bin/b43sh      : 1 2 3$
/bin/b44sh      : 1 2 3$
/bin/bash       : 1 2 3$
/bin/ksh        : 1 2 3$
/bin/ksh93      : 1 2 3$
/bin/lksh       : 1 2 3$
/bin/mksh       : 1 2 3$
/bin/zsh        : 123$
/bin/zsh4       : 123$

И yash, и zsh не могут разделить аргументы. Это ошибка?