руководство пользователя для gnu awk

5. чтение входных файлов

• 5.1 как ввод разделяется на записи
• 5.2 обследование полей
• 5.3 непостоянные количества полей
• 5.4 изменение содержимого поля
• 5.5 указание, как разделять поля
  • 5.5.1 основы разделения полей
  • 5.5.2 использование регулярных выражений для разделения полей
  • 5.5.3 превращение каждого знака в отдельное поле
  • 5.5.4 установка fs из командной строки
  • 5.5.5 обзор разделения полей
• 5.6 чтение данных фиксированной ширины
• 5.7 многострочные записи
• 5.8 явный ввод по getline
  • 5.8.1 введение в getline
  • 5.8.2 использование getline без аргументов
  • 5.8.3 использование getline в переменную
  • 5.8.4 использование getline из файла
  • 5.8.5 использование getline в переменную из файла
  • 5.8.6 использование getline из конвейера
  • 5.8.7 использование getline в переменную из конвейера
  • 5.8.8 обзор вариантов getline

в обычной awk-программе весь вход читается либо со стандартного входа (по умолчанию с клавиатуры, но часто и с конвейера из другой команды ) или с файлов, имена которых вы указываете в командной строке awk.если вы указываете входные файлы, awk читает их подряд, сначала все данные с одного, затем переходит к следующему. имя текущего входного файла хранится в встроенной переменной filename (см. главу 10 [встроенные переменные], стр. 115).

ввод читается в единицах, называемых записями, и обрабатывается по правилам вашей программы запись за записью. по умолчанию, каждая запись есть одна строка (line). каждая запись автоматически разделяется на части, называемые полями. это делает более удобным для программы обработку частей записи. в редких случаях вам нужно использовать команду getline. она нужна тогда, когда нужен ввод с файлов не подряд, и она позволяет не указывать имена файлов в команде awk (см. раздел 5.8 [явный ввод с помощью getline], стр. 53).

5.1 как вход делится на записи

интерпретатор awk разделяет ввод для вашей программы на записи и поля. записи разделяются знаками, называемыми разделителями записей. по умолчанию, это знаки newline. поэтому по умолчанию записи совпадают со строками. вы можете использовать другие символы как разделители записей, присваивая их встроенной переменной rs.

значение rs можно менять в awk-программе, подобно другим переменным, оператором присваивания `=' (см. раздел 7.7 [присваивающие выражения], стр. 84). новый разделитель записей нужно заключать в кавычки для строковой константы. обычно это делается в начале исполнения, до обращения к вводу, так что самая первая запись будет читаться с нужным разделителем. чтобы сделать это, используйте специальный образец в begin (см. раздел 8.1.5 [специальные образцы begin и end], стр. 100).

 например:

awk 'begin { rs = "/" } ; { print $0 }' bbs-list

изменяет значение rs на "/" до чтения ввода. это цепочка, первый символ в которой есть слеш; в результате записи разделяются слешами. затем читается входной файл и второе правило в awk-программе (действие без образца) печатает каждую запись. поскольку каждый оператор печати добавляет newline в конец вывода, в результате выполнения этой awk-программы будет получена копия ввода, где каждый слеш заменен на newline.

вот результат исполнения программы на  `bbs-list':

$ awk 'begin { rs = "/" } ; { print $0 }' bbs-list
-| aardvark 555-5553 1200
-| 300 b
-| alpo-net 555-3412 2400
-| 1200
-| 300 a
-| barfly 555-7685 1200
-| 300 a
-| bites 555-1675 2400
-| 1200
-| 300 a
-| camelot 555-0542 300 c
-| core 555-2912 1200
-| 300 c
-| fooey 555-1234 2400
-| 1200
-| 300 b
-| foot 555-6699 1200
-| 300 b
-| macfoo 555-6480 1200
-| 300 a
-| sdace 555-3430 2400
-| 1200
-| 300 a
-| sabafoo 555-2127 1200
-| 300 c
-|

заметим, что запись с `camelot' bbs не разделена. в оригинальном файле данных (см. раздел 1.3 [файлы с данными для примеров], стр. 7), эта строка выглядит так:

camelot 555-0542 300 c

она содержит только одну baud rate; поэтому в записи нет слешей. другой способ изменить разделитель записей есть командная строка, использующая свойство присваивания переменной (см. раздел 14.2 [другие аргументы командной строки], стр. 165).

awk '{ print $0 }' rs="/" bbs-list

это присваивает rs значение `/' перед обработкой `bbs-list'. употребление необычного символа, такого как `/', для разделения записей приводит к правильному поведению в подавляющем большинстве случаев. однако, следующий (экстремальный) конвейер печатает неожиданную `1'. имеется одно поле, состоящее из newline. значение встроенной переменной nf есть количество полей в текущей записи.

$ echo | awk 'begin { rs = "a" } ; { print nf }'

-| 1

достижение конца ввода заканчивает текущую входную запись, даже если последний символ в файле не есть символ из rs (d.c.).

пустая цепочка "" (цепочка без символов) имеет специальный смысл в качестве значения rs: она означает, что записи разделяются одним или больше пробелами, и ничем другим. см. раздел 5.7 [многострочные записи], стр. 51, для деталей.

если изменить значение rs в процессе исполнения awk, новое значение будет использоваться для разделения следующих записей после окончания обработки текущей записи с прежним разделителем. по достижении конца этой записи gawk устанавливает переменную rt по тексту во вводе, предназначенному для rs. значения rs не ограничиваются одно-символьными цепочками. это может быть любое регулярное выражение (см. главу 4 [регулярные выражения], стр. 23). в общем случае, запись оканчивается на первой цепочке, соответствующей этому регулярному выражению; следующая запись начинается после конца этой цепочки. это общее правило работает и в обычном случае, когда rs имеет значение newline: запись кончается по началу следующей обнаруженной строки (следующее newline в вводе) и следующая запись начинается сразу после конца этой строки (с первого символа следующей). символ newline, поскольку он соответствует rs, не является частью записи.

когда rs есть простой символ, rt будет содержать то же значение. однако, если rs есть регулярное выражение, rt становится более полезной; она содержит фактически входной текст, который соответствует этому регулярному выражению. следующий пример иллюстрирует обе эти особенности. он устанавливает rs равной регулярному выражению, которое соответствует или newline, или ряду из одной или более букв верхнего регистра, выборочно начинающейся и/или кончающейся белым пробелом (см. главу 4 [регулярные выражения], стр. 23).

$ echo record 1 aaaa record 2 bbbb record 3 |
gawk 'begin { rs ="\n|( *[[:upper:]]+ *)"}
{ print "record =", $0, "and rt =", rt }'

-| record = record 1 and rt = aaaa
-| record = record 2 and rt = bbbb
-| record = record 3 and rt =
-|

использование rs в качестве регулярного выражения и переменной rt есть расширения gawk; они отсутствуют в режиме эмуляции (см. раздел 14.1 [параметры командной строки], стр. 161). в режиме эмуляции только первый символ в значении rs используется для определения конца записи. интерпретатор awk запоминает количество записей, прочитанных им из текущего входного файла. это число хранится в переменной fnr. она сбрасывается на 0 в начале чтения каждого файла. другая встроенная переменная, nr, содержит полное количество записей, прочтенных из входных файлов с данными. она начинает с 0 и никогда не сбрасывается автоматически на 0.

5.2 обследование полей

когда awk читает входную запись, она автоматически разделяется интерпретатором на части, называемые полями. по умолчанию, поля разделяются пробелами, как слова в строке. пробел в строке awk означает один или более пробелов, знаков tabs или newlines; другие символы, такие как formfeed и пр., которые имеют смысл пробелов (whitespace) в других языках, в awk не считаются таковыми. назначение полей --- облегчить доступ к соответствующим частям записи. если вы не хотите этим пользоваться, вы можете оперировать с целой записью, но поля --- это то, что делает простые программы awk очень удобными. для ссылки на поле в awk-пррограмме используют знак доллара,

 `$', с номером нужного поля после него.
 так, $1 есть ссылка на первое поле,

 $2 --- на второе и т.д.

 предположим, строка ввода есть:

 this seems like a pretty nice example.

здесь первое поле, или $1, есть `this';
второе поле, или $2, есть `seems'; и т.д.
заметим, что последнее поле, $7, есть  `example.'.
так как нет пробела
между `e' и `.', точка входит состав седьмого поля.

значение встроенной переменной nf есть количество полей в текущей записи. awk обновляет значение nf автоматически при каждом чтении записи. независимо от количества полей, последнее поле записи может быть представлено как $nf. таким образом, в предыдущем примере $nf будет то же, что и $7, т.е. `example.'. как это работает, объясняется ниже (см. раздел 5.3 [непостоянные номера полей], стр. 41). если вы пытаетесь сослаться на поле после последнего, $8, когда запись имеет только 7 полей, вы получаете пустую цепочку.

в posix awk символы newline не рассматриваются как пробелы (whitespace) для разделения полей. $0, что выглядит как ссылка на " нулевое" поле, представляет специальный случай: она представляет всю входную запись. $0 используется, когда вы не заинтересованы в поляхs.

приведем несколько примеров.

$ awk '$1 ~ /foo/ { print $0 }' bbs-list

-| fooey 555-1234 2400/1200/300 b
-| foot 555-6699 1200/300 b
-| macfoo 555-6480 1200/300 a
-| sabafoo 555-2127 1200/300 c

этот пример печатает каждую запись из файла `bbs-list', у которой первое поле содержит цепочку `foo'. оператор `~' называется оператор соответствия (см. раздел 4.1 [как использовать регулярные выражения], стр. 23); он проверяет соответствие цепочки (здесь это поле $1) данному регулярному выражению. следующий пример ищет `foo' в целой записи и печатает первое и последнее поля каждой входной записи, удовлетворяющей такому соответствию:

$ awk '/foo/ { print $1, $nf }' bbs-list
-| fooey b
-| foot b
-| macfoo a
-| sabafoo c

5.3 непостоянные номера полей

номер поля не обязан быть константой. любое выражение языка awk может быть использовано после `$' для ссылки на поле. значение выражения указывает номер поля. если значение есть не число, а цепочка, она конвертируется в номер.

рассмотрим такой пример:

awk '{ print $nr }'

напомним, что nr есть количество прочитанных до настоящего момента записей: один для первой записи, два во второй, и т.д. так что этот пример печатает первое поле первой записи, второе поле второй записи, и т.д. для двадцатой записи печатается поле номер 20; обычно запись имеет меньше 20 полей, так что это будет пустая строка.

вот другой пример использования выражения
в качестве номера поля:

awk '{ print $(2*2) }' bbs-list

awk должен вычислить выражение `(2*2)' и использовать его значение как номер поля для печати. знак `*' означает умножение, так что выражение `2*2' вычисляется как четыре. скобки употреблены для того, чтобы умножение было произведено до операции `$'; они необходимы всегда, когда в выражении для номера поля встречается бинарная операция. наш пример поэтому печатает операционные часы (четвертое поле) каждой строки файла `bbs-list'.

(все операторы awk перечислены в порядке убывания приоритета в разделе 7.14 [приоритет операторов (как операторы гнездятся)], стр. 94.) если вычисленный номер поля есть 0, вы получаете всю запись. так, $(2-2) имеет тот же смысл, что и $0. отрицательные номера полей недопустимы; такая ссылка обычно приводит к прекращению исполнения программы. (стандарт posix не предусматривает отрицательной ссылки на номер записи. gawk замечает это и прекращает выполнение программы. другие реализации awk могут вести себя по-другому.)

как упоминалось в разделе 5.2 [обследование полей], стр. 40, количество полей текущей записи содержится в встроенной переменной nf (см. также гл. 10 [встроенные переменны, стр. 115). выражение $nf не имеет специального смысла и использует значение nf как номер поля.

5.4 изменение содержимого поля

вы можете изменять содержимое поля, прочтенное awk, внутри awk-программы; эти изменения затрагивают только информацию, воспринятую программой как текущая входная запись. (сам ввод остается неизменным, awk никогда не изменяет входной файл.)

рассмотрим следующий пример и его результат:

$ awk '{ $3 = $2 - 10;
print $2, $3 }' inventory-shipped

-| 13 3
-| 15 5
-| 15 5...

знак `-' означает вычитание, так что эта программа изменяет поле три, $3, присваивая ему значение поля 2 минус десять, `$2 - 10'. (см. раздел 7.5 [арифметические операции], стр. 82.) затем поле два и новое значение для поля три печатаются.

для того, чтобы все это работало, текст в поле $2 должен иметь смысл как число; цепочка символов должна быть превращена в число, над которым компьютер может произвести арифметические действия. результат вычитания конвертируется опять в цепочку символов, которая становится полем три. см. раздел 7.4 [конверсия цепочек и чисел], стр. 81.

когда вы изменяете значение поля (воспринятого программой awk), текст входной записи пере вычисляется, чтобы содержать новое поле там, где было старое. поэтому $0 изменяется соответственно измененным полям. таким образом, программа печатает копию входного файла, в которой вторые поля в каждой записи уменьшены на 10.

$ awk '{ $2 = $2 - 10;
print $0 }' inventory-shipped

-| jan 3 25 15 115
-| feb 5 32 24 226
-| mar 5 24 34 228...

вы можете также присваивать содержание полям,
выходящим за рамки записи.

например,

$ awk '{ $6 = ($5 + $4 + $3 + $2) \
print $6 }' inventory-shipped

-| 168
-| 297
-| 301 ...

мы создали $6, значение которого есть сумма полей $2, $3, $4 и $5. знак `+' представляет сложение. для файла `inventory-shipped' $6 представляет общее количество пакетов, посланных морем в определенный месяц.

создание нового поля изменяет внутреннюю копию текущей записи, сделанную awk-программой, т.е. значение $0. так, если вы выполняете `print $0' после добавления поля, печатается запись с добавленным полем и с соответствующим количеством разделителей полей между ним и существовавшими ранее полями.

такое пере вычисление зависит от nf и изменяет nf (количество полей; см. раздел 5.2 [обследование полей], стр.40), и вследствие свойства, которое еще не рассматривалось, изменяет также разделитель выходных полей, ofs, который используется для разделения полей (см. раздел 6.3 [выходные разделители], стр. 63). например, nf присваивается значение номера старшего поля, которое вы создали.

заметим вместе с тем, что одна только ссылка на поле вне рамок записи не изменяет значения ни $0 ни nf. ссылка на поле вне записи производит только пустую цепочку.

например,

if ($(nf+1) != "")
	print "can't happen"
		else print "everything is normal"

напечатает `everything is normal', потому что nf+1 конечно выходит за рамки. (см. раздел 9.1 [оператор if-else], стр. 105, описывающий подробно операторы if-else. см. раздел 7.10 [печать переменных и выражения сравнения], стр. 88, с подробной информацией об операторе `!='.)

важно заметить, что присваивание значения существующему полю изменяет значение $0, но не меняет значение nf, даже если вы присваиваете пустую цепочку полю.

например:

$ echo a b c d | awk '{ ofs = ":"; $2 = "" print $0; print nf }'
-| a::c:d
-| 4

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

$ echo a b c d | awk '{ ofs = ":"; $2 = ""; $6 = "new" print $0; print nf }'
-| a::c:d::new
-| 6

создается вставленное поле $5 с пустым значением (оно показано второй парой соседних двоеточий, а nf получает значение шесть. уменьшение nf привет к потере значений полей, номера которых больше значения nf, и к пере вычислению $0. вот соответствующий пример:

$ echo a b c d e f | ../gawk '{ print "nf =", nf; nf = 3; print $0 }'
-| nf = 6
-| a b c

5.5 задание разделителей полей

этот раздел довольно длинен; в нем описывается одна из наиболее фундаментальных операций в awk.

5.5.1 основные сведения о разделении полей

разделитель полей, который является либо отдельным символом либо регулярным выражением, определяет способ разделения входной записи на поля. awk сканирует входную запись в поисках последовательности символов, соответствующей разделителю полей; сами поля представляют текст между разделителями.

в дальнейших примерах мы используем маркирующий символ "ffl" для представления пробелов в выходе. если разделитель полей есть `oo', то следующая строка:

moo goo gai pan

разбивается на три поля: `m', `fflg' и `fflgaifflpan'. отметим ведущие пробелы в значениях второго и третьего полей. разделитель полей представляется встроенной переменной fs. системные программисты, обратите внимание! в awk не используется имя ifs, используемое оболочками, совместимыми с posix (такими как bourne shell, sh, или gnu bourneagain shell, bash).

в awk-программе можно менять значение fs оператором присваивания, `=' (см. раздел 7.7 [присваивающие выражения], стр. 84). часто это удобно делать в начале выполнения, перед началом обработки ввода, так что самая первая запись будет читаться с правильным разделителем. чтобы это сделать, используйте специальный образец begin (см. раздел 8.1.5 [специальные образцы begin и end], стр. 100).

например, здесь мы присваиваем fs значение цепочки ",":

awk 'begin { fs = "," } ; { print $2 }'

из входной строки

john q. smith, 29 oak st., walamazoo, mi 42139

эта awk-программа извлечет и  напечатает цепочку

 `ffl29ffloakfflst.'.

иногда входные данные содержат разделительные символы, которые не разделяют поля таким образом, как вы полагаете, что они должны разделять. например, личное имя в предыдущем примере может иметь добавкой титул или суффикс, такой как `john q. smith, lxix'. для входной записи с таким именем: john q. smith, lxix, 29 oak st., walamazoo, mi 42139 предыдущая программа извлечет `ffllxix' вместо `ffl29ffloakfflst.'. если вы ожидаете, что программа напечатает адрес, вы будете очень удивлены. мораль такова: выбирайте структуру данных и символы-разделители тщательно, чтобы предотвратить подобные случаи.

как вы знаете, по умолчанию поля разделяются последовательностями белых пробелов (т.е. (пробелами, знаками tab и newline), но не единичными пробелами: два пробела подряд не ограничивают пустое поле. по умолчанию разделитель полей fs имеет значение цепочки, содержащей один пробел " ". если бы это значение интерпретировалось обычным путем, т.е. каждый пробел считался разделителем полей, то два пробела подряд содержали бы между собой пустое поле. этого не происходит, потому что единственный пробел в качестве значения fs представляет специальный случай: он означает разделение полей по умолчанию. если fs имеет значением какой-нибудь другой отдельный символ, такой как ",", то каждое вхождение этого символа разделяет два поля. два последовательных вхождения ограничивают пустое поле. если символ стоит в начале или конце строки, то тоже отделяет пустое поле. символ пробела есть единственный одиночный символ, который не подчиняется этим правилам.

5.5.2 использование регулярных выражений для разделения полей

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

например, присваивание:

fs = ", \t"

делает каждую часть входной строки, состоящую из запятой с последующим пробелом и tab, разделителем полей. (`\t' есть управляющая последовательность, которая обозначает знак tab, см. раздел 4.2 [управляющие последовательности], стр. 24, содержащий полный список управляющих последовательностей.)

а вот менее тривиальный пример регулярного выражения. предположим, вам нужно иметь разделителями отдельные пробелы, как выше для этого использовались отдельные запятые. вы можете присвоить fs "[ ]" (левая квадратная скобка, пробел, правая квадратная скобка). это регулярное выражение соответствует единственному пробелу и ничему другому (см. главу 4 [регулярные выражения], стр. 23).

имеется важная разница между двумя случаями: `fs = " "' (одиночный пробел) и `fs = "[ \t\n]+"' (левая квадратная скобка, пробел, обратный слеш, "t", обратный слеш, "n", правая квадратная скобка, составляющие регулярное, выражение, соответствующее одному или более пробелам, tab или newline). для обоих fs поля разделяются группами пробелов, tab и/или newline. однако, если значение fs есть " ", awk сначала убирает из записи ведущие и завершающие белые пробелы, а затем решает, как расположены записи.

например, такой конвейер напечатает `b':

$ echo ' a b c d ' | awk '{ print $2 }'
a b

однако, следующий конвейер напечатает `a' (заметьте дополнительные пробелы вокруг каждой буквы):

$ echo ' a b c d ' | awk
	'begin { fs = "[ \t]+" }; { print $2 }'
-| a

в этом случае первое поле пусто. удаление ведущих или завершающих белых пробелов происходит каждый раз, когда пере вычисляется $0.

например, рассмотрите такой конвейер:

$ echo ' a b c d' | awk '{ print; $2 = $2; print }'
-| a b c d
-| a b c d

первый оператор печати печатает запись как она прочиталась, с нетронутым ведущим белым пробелом. присваивание $2 перестраивает $0 посредством конкатенации вместе от $1 до $nf, разделенных посредством значения ofs. поскольку ведущие белые пробелы игнорируются при нахождении $1, они не служат частью нового $0. окончательно, последний оператор печати печатает новую $0.

5.5.3 превращение каждого символа в отдельное поле

бывают случаи, когда нужно рассматривать каждый символ записи отдельно. в gawk это сделать легко, нужно просто присвоить fs пустую цепочку (""). тогда каждый отдельный символ в записи станет отдельным полем.

вот пример:


$ echo a b | gawk 'begin { fs = "" }
    {
      for (i = 1; i != nf;
        i = i + 1) ? print "field", i, "is", $i 
    }'
-| field 1 is a
-| field 2 is
-| field 3 is b

традиционно действия при fs равном "" были не определены. в таком случае unix awk будет просто рассматривать всю запись как имеющую только одно поле (d.c.). в режиме эмуляции (см. раздел 14.1 [параметры командной строки], стр. 161), если значением fs служит пустая цепочка, то gawk будет действовать так же.

5.5.4 установка fs из командной строки

fs может быть установлена из командной строки. для этого нужно использовать параметр `-f'.

 например,

awk -f, 'program' input-files

устанавливает в fs символ `,'. заметьте, что параметром служит заглавное `f'. в отличие от этого `-f' указывает, что файл содержит программу awk. регистр имеет значение в параметрах командной строки: параметры `-f' и `-f' не имеют ничего общего. их можно использовать одновременно для установки переменной fs и получения awk-программы из файла.

значение, используемое в качестве аргумента для `-f', обрабатывается точно так же как при присваивании встроенной переменной fs. это значит, что если разделитель поля содержит специальные символы, они должны быть указаны соответствующими управляющими последовательностями.

например, чтобы
использовать  `\' как разделитель полей, нужно напечатать:

# что-нибудь такое как fs = "\\" awk -f\\\\ '...' files ...

поскольку `\' используется в оболочке, awk увидит `-f\\'. тогда awk обработает `\\' как управляющую последовательность (см. раздел 4.2 [управляющие последовательности], стр. 24), и получит в результате одну `\' в качестве разделителя полей.

в специальном случае, в режиме эмуляции (см. раздел 14.1 [параметры командной строки], стр. 161), если аргумент при `-f' есть `t', то fs получит значение символа tab. это произойдет потому, что при печати `-f\t' в оболочке, без всяких кавычек, `\' удаляется, так что awk предположит, что на самом деле вы хотите разделять поля символами tab, а не `t'. употребляйте `-v fs="t"' в командной строке, если вы на самом деле хотите отделять поля буквой `t' (см. раздел 14.1 [параметры командной строки], стр. 161).

например, воспользуемся программным файлом awk с именем `baud.awk', который содержит образец /300/ и действие `print $1'. вот эта программа:

/300/ { print $1 }

установим также в fs символ `-' и исполним программу для входного файла `bbs-list'. следующая команда напечатает список имен досок объявлений, которые работают со скоростью 300 бод, и первые три цифры их телефонных номеров:

$ awk -f- -f baud.awk bbs-list
-| aardvark 555
-| alpo
-| barfly 555...

обратите внимание на вторую строку вывода. в оригинальном входном файле (см. раздел 1.3 [файлы с данными для примеров], стр. 7), вторая строка выглядит так:

alpo-net 555-3412 2400/1200/300 a

символ `-', часть системного имени, использован как разделитель полей вместо `-' в телефонном номере, как было задумано. это показывает, почему надо быть осторожным в выборе полей и разделителей записей. на многих системах unix каждый пользователь имеет отдельный вход в системном файле с паролями, одну строку на пользователя. информация в строке разделена на части двоеточиями. первое поле содержит регистрационное имя пользователя, второе есть его секретный пароль.

строка этого файла может выглядеть подобно следующей:

arnold:xyzzy:2076:10:arnold robbins:/home/arnold:/bin/sh

следующая программа просматривает системный файл с паролями и печатает входы пользователей, не имеющих пароля:

awk -f: '$2 == ""' /etc/passwd

5.5.5 обзор правил разделения на поля

в соответствии со стандартом posix, awk должен вести себя так, как будто каждая запись разделяется на поля во время ее чтения. в частности, это означает, что можно менять значение fs после прочтения записи, и значения полей (т.е., как они были выделены) должны соответствовать старому значению fs, а не новому. однако, многие реализации awk действуют не так. вместо этого они откладывают выделение полей до ссылки на поле. поля выделяются согласно текущему значению fs! (d.c.) такое поведение может быть трудно диагнозируемым. следующий пример иллюстрирует разницу между этими двумя методами. (команда sed печатает первую строку из `/etc/passwd'. утилита sed является "поточным редактором". ее поведение также определяется стандартом posix.)

sed 1q /etc/passwd -- awk '{ fs = ":" ;

print $1 }'


будет обычно печатать

root on an incorrect implementation of awk

в то время как  gawk напечатает что-нибудь вроде

root:nsijplphzzwge:0:0:root:/:

в следующей таблице указывается, как выделяются поля на основании значения переменной fs. (`==' означает "равно следующему.") fs == " " поля разделяются белыми пробелами. ведущие и завершающие белые пробелы игнорируются. это же делается по умолчанию.

fs == любой другой отдельный символ. поля разделяются каждым вхождением этого символа. кратные последовательные вхождения ограничивают пустые поля, так же как ведущее и завершающее запись вхождения. этот символ может также быть метасимволом регулярного выражения; его представление не нуждается в управляющей последовательности.

fs == регулярное выражение. поля разделяются вхождениями символов, которые соответствуют регулярному выражению. ведущее и завершающее вхождения отделяют пустые поля. fs == "" . каждый отдельный символ в записи становится отдельным полем.