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

7. выражения

• 7.1 постоянные выражения
  • 7.1.1 численные константы и константы-цепочки
  • 7.1.2 постоянные регулярные выражения
• 7.2 использование постоянных регулярных выражений
• 7.3 переменные
  • 7.3.1 использование переменных в программе
  • 7.3.2 присваивание переменным в командной строке
• 7.4 конверсии цепочек и чисел
• 7.5 арифметические операторы
• 7.6 конкатенация цепочек
• 7.7 выражения присваивания
• 7.8 операторы увеличения и уменьшения
• 7.9 true и false в awk
• 7.10 типы переменных и сравнительные выражения
• 7.11 булевские выражения
• 7.12 условные выражения
• 7.13 вызовы функций

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

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

7.1 постоянные выражения

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

7.1.1 численные и строковые константы

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

105        1.05e+2             1050e-1

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

"попугай" представляет цепочку, значение которой есть `попугай'. цепочки в gawk могут иметь любую длину и могут содержать любые восьмибитовые символы ascii, включая ascii nul (нулевой символьный код). другие реализации awk могут иметь трудности с некоторыми символьными кодами.

7.1.2 константы регулярных выражений

такая константа (константа regexp) есть описание регулярного выражения, заключенное в слеши, такое как /^beginning and end$/. большинство regexp, используемых в awk-программах, есть константы, но операторы соответствия `~' и `!~' могут также определять соответствие вычислимым или "динамическим" regexps (которые являются обычными цепочками или переменными, содержащими некоторую regexp).

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

7.2 использование констант регулярных выражений

когда такая константа стоит в правой части оператора `~' или `!~' , то она означает только regexp для соответствия.

константы regexp (такие как /foo/) могут использоваться подобно простым выражениям. когда константа regexp встречается сама по себе, она имеет то же самое значение как если бы появилась в образце, т.е. `($0 ~ /foo/)' (d.c.) (см. раздел 8.1.3 [выражения как образцы], стр. 98). это значит, что два следующих отрезка кодов:

if ($0 ~ /barfly/ ---- $0 ~ /camelot/)
print "found"

и

if (/barfly/ ---- /camelot/)
print "found"

в точности эквивалентны.

одно довольно странное следствие этого правила состоит в том, что следующее булевское выражение имеет значение 'да', но делает не то, что, вероятно, думает пользователь:

# note that /foo/ is on the left of the ~ if (/foo/ ~ $1)

print "found foo"

этот код, "очевидно", проверяет $1 на соответствие regexp /foo/. но выражение `/foo/ ~ $1' фактически означает `($0 ~ /foo/) ~ $1'. другими словами, сначала проверяется соответствие входной записи и regexp /foo/. результат будет ноль или один в зависимости от успеха или неудачи соответствия. затем этот результат сопоставляется первому полю записи. поскольку мало вероятно, что кто-то на самом деле хочет выполнить такой тест, gawk выдает предостережение, если видит в программе такую конструкцию.

другое следствие этого правила состоит в том, что оператор присваивания matches = /foo/ присвоит значение ноль или единица переменной matches, в зависимости от содержания текущей входной записи. это свойство языка никогда не было хорошо документировано до спецификаций posix.

постоянные регулярные выражения также используются в качестве первого аргумента функций gensub, sub и gsub, и как второй аргумент функций соответствия (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137). современные реализации awk, включая gawk, допускают в качестве третьего аргумента split константу regexp, в то время как некоторые прежние реализации не допускают (d.c.). это может привести к недоразумению, при попытках использовать константы regexp в качестве аргумента функций, определенных пользователем (см. главу 13 [функции пользователя, стр. 153).

например:

function mysub(pat, repl, str, global)
     {
         if (global)
             gsub(pat, repl, str)
         else
             sub(pat, repl, str)
         return str
     }
     
     {
         ...
         text = "hi! hi yourself!"
         mysub(/hi/, "howdy", text, 1)
         ...
     }

в этом примере программист хочет передать константу regexp в пользовательскую функцию mysub, которая в свою очередь передаст ее или в sub или в gsub. однако, на самом деле произойдет следующее: параметр pat будет единицей или нулем в зависимости от того, соответствуют или нет $0 и /hi/. поскольку маловероятно, что вы на самом деле хотите передать таким путем булевское значение, gawk выдает предостережение, когда видит константу regexp в позиции аргумента в определенной пользователем функции.

7.3 переменные

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

7.3.1 использование переменных в программе

переменные позволяют давать имена значениям для позднейшей ссылки на них. мы уже видели переменные во многих примерах. имя переменной должно быть цепочкой букв, цифр и подчеркиваний, но не может начинаться с буквы. регистр имеет значение в именах переменных; a и a означают разные переменные. имя переменной само по себе является правильным выражением; оно представляет текущее значение переменной. новые значения переменные получают посредством операторов присваивания, приращения и уменьшения. см. раздел 7.7 [присваивающие выражения], стр. 84.

некоторые переменные имеют специальные встроенные значения, например, разделитель полей fs или количество полей в текущей входной записи nf. см. главу 10 [встроенные переменные], стр. 115, где содержится их список. эти встроенные переменные могут использоваться или получать присвоенные новые значения подобно другим переменным, но их значения также используются или автоматически меняются интерпретатором awk. все имена встроенных переменных записываются буквами верхнего регистра. переменные в awk могут получать как численные так и строковые значения. по умолчанию переменные инициализируются значениями пустой цепочки, которое в численной форме конвертируется в ноль. поэтому нет нужды явно инициализировать каждую переменную, как это делается в си и большинстве других языков.

7.3.2 присваивание переменным из командной строки

можно установить значение любой переменной awk включением присваивания в аргументы командной строки при запуске awk (см. раздел 14.2 [другие аргументы командной строки], стр. 165). такой аргумент имеет вид variable=text. с его помощью можно установить значение переменной или при запуске awk или между входными файлами. если перед присваиванием стоит параметр `-v', подобно -v variable=text, то переменная устанавливается с самого начала, до выполнения правил begin. параметр `-v' и его присваивания должны предшествовать всем аргументам с именами файлов и тексту программы. (см. раздел 14.1 [параметры командной строки], стр. 161, о подробностях употребления параметра `-v'.) в противном случае присваивания происходят в моменты, определенные их позициями среди аргументов входных файлов, после обработки предшествующих аргументов.

например:

awk '{ print $n }' n=4 inventory-shipped n=2 bbs-list

печатает значение номера поля n для всех входных записей. перед чтением первого файла командная строка присваивает переменной n значение 4. это заставляет печатать четвертое поле в строках из файла `inventory-shipped'. после окончания первого файла но перед началом второго файла n получает значение два, так что второе поле печатается в строках из `bbs-list'.

$ awk '{ print $n }' n=4 inventory-shipped n=2 bbs-list
-| 15 a 24...
-| 555-5553 a 555-3412...

аргументы командной строки становятся доступными для явного анализа из awk-программы в массиве с именем argv (см. раздел 10.3 [использование argc и argv], стр. 120). awk обрабатывает значения присваиваний в командной строке и для управляющих последовательностей (d.c.) (см. раздел 4.2 [управляющие последовательности], стр. 24).

7.4 преобразования цепочек и чисел

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

 рассмотрим следующее:

two = 2; three = 3 print (two three) + 4

это печатает значение (численное) 27. численные значения переменных two и three превращаются в цепочки и сцепляются вместе, а цепочка-результат опять преобразуется в число 23, к которому добавляется 4.

если по какой-то причине нужно принудить число превратиться в цепочку, можно сцепить пустую цепочку "" с этим числом. чтобы превратить цепочку в число нужно прибавить ноль к этой цепочке.

цепочка превращается в число при интерпретации любого численного префикса как записи числа: "2.5" превращается в 2.5, "1e3" превращается в 1000, а "25fix" получает численное значение 25. цепочки, которые нельзя интерпретировать как правильные числа, превращаются в 0. точные правила, по которым числа превращаются в цепочки, определяются встроенной awk-переменной convfmt (см. главу 10 [встроенные переменные], стр. 115).

числа преобразуются с помощью функции sprintf (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137) и с convfmt как указателем формата. convfmt по умолчанию имеет значение "%.6g", которое печатает числа по крайней мере с 6 значащими цифрами. для некоторых приложений требуется изменять ее для получения большей точности. двойная точность на большинстве современных машин соответствует 16 или 17 десятичным цифрам. странные результаты могут получиться, если convfmt получит значение, которое не помогает sprintf форматировать правильно числа с плавающей точкой. например, если вы опустите `%' в формате, все числа будут выдаваться одной и той же постоянной цепочкой. но если число целое, то результат преобразования будет всегда целым, независимо от значения convfmt.

 в таком фрагменте кода:

convfmt = "%2.2f" 
a = 12 
b = a ""

b получит значение  "12", а не "12.00" (d.c.).

до введения стандарта posix, awk предусматривало значение ofmt для преобразования чисел в цепочки. ofmt специфицирует выходной формат для печати чисел оператором print. convfmt было введено для отделения семантики преобразования от семантики печати. и convfmt и ofmt имеют по умолчанию значение "%.6g". в подавляющем большинстве случаев старые awk-программы не изменят своего поведения. однако, такое использование ofmt нужно держать в памяти, если вы переносите вашу программу на другую реализацию awk; мы рекомендуем вместо изменения программы переносить сам gawk! см. раздел 6.1 [оператор print], стр. 61, для полной информации об операторе print.

7.5 арифметические операторы

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

следующая программа читает файл `grades', и печатает средние значения оценок:

$ awk '{ sum = $2 + $3 + $4 ; avg = sum / 3 
>        print $1, avg }' grades
-| pat 85
-| sandy 83
-| chris 84.3333

в следующей таблице перечисляются арифметические операции в awk, в порядке уменьшения приоритетов:

- x отрицание

+ x одноместный плюс. превращают выражение в число.

x ^ y или x ** y возведение в степень: x возводится в степень y.

`2 ^ 3' имеет значение восемь. цепочка `**' эквивалентна `^'. (стандарт posix содержит только `^' для возведения в степень.)

x * y умножение. x / y деление. поскольку все числа в awk вещественные, то результат не округляется до целого: `3 / 4' имеет значение 0.75.

x % y остаток. частное округляется в сторону нуля до целого, умножается на y и результат вычитается из x. эта операция иногда называется "trunc-mod." имеет место следующее тождество:

b * int(a / b) + (a % b) == a один возможный нежелательный эффект такого определения остатка состоит в том, что x % y отрицательно, если x отрицательно. так, -17 % 8 = -1 в других реализациях awk знак остатка может зависеть от конкретной машины.

x + y сложение. x - y вычитание.

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

7.6 конкатенация цепочек

в свое время это казалось хорошей идеей (brian kernighan). имеется только одна операция над цепочками: конкатенация. нет специального оператора для ее указания. конкатенация производится записью выражений непосредственно друг за другом.

например:

$ awk '{ print "field number one: " $1 }' bbs-list
-| field number one: aardvark
-| field number one: alpo-net...

без пробела в строковой постоянной после `:',
строки соединятся вместе.

например:

$ awk '{ print "field number one:" $1 }' bbs-list
-| field number one:aardvark
-| field number one:alpo-net...

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

file = "file" 
name = "name"

print "something meaningful" > file name

необходимо сделать следующее:

print "something meaningful" > (file name)

мы рекомендуем вам использовать скобки вокруг конкатенаций
почти во всех обычных контекстах (таких как правые части в `=').

7.7 выражения присваивания

присваивание есть выражение, которое записывает новое значение в переменную. например, присвоим значение один переменной z:

z = 1 после вычисления этого выражения переменная z получит значение один. старое значение z будет забыто.

присваивание может также передавать значение цепочки. например, присвоим значение "this food is good" переменной message:

thing = "food"
predicate = "good"
message = "this "
thing " is "
predicate

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

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

левый операнд присваивания не обязан быть только переменной (см. раздел 7.3 [переменные], стр. 79); он может быть также полем (см. раздел 5.4 [изменение содержимого поля], стр. 42) или элементом массива (см. главу 11 [массивы в awk], стр. 123). все они называются lvalues, что значит, что они могут стоять в левой части оператора присваивания. правосторонний операнд может быть любым выражением; он выдает новое значение, которое присваивание передает в указанную переменную, поле или элемент массива. (такие значения называются rvalues).

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

foo = 1 print foo foo = "bar" print foo

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

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

присваивание есть выражение, поэтому оно имеет значение, то же самое, которое присваивается. так, `z = 1' как выражение имеет значение один. одно из следствий этого есть то, что можно писать кратные присваивания:

x = y = z = 0 присваивает значение 0 всем трем переменным. оно делает это, так как значение выражения `z = 0', равное нулю, передается в y и затем значение `y = z = 0', которое есть ноль, передается в x.

можно использовать присваивание всюду, где появляется выражение. например, можно написать `x != (y = 1)' чтобы присвоить переменной y единицу, а затем проверить, равен ли х единице. но такой стиль делает программу трудной для чтения; нигде кроме разовых программ, не следует употреблять таких нагромождений присваиваний.

кроме `=', имеется несколько других операторов присваивания, которые выполняют арифметические действия с старым значением переменной. например, оператор `+=' вычисляет новое значение, добавляя правостороннее значение к старому значению переменной. так, следующее присваивание добавляет пять к значению foo:

foo += 5

это эквивалентно следующему:

foo = foo + 5

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

# спасибо  pat rankin за этот пример
begin {
foo[rand()] += 5 for (x in foo)
print x, foo[x]
bar[rand()] = bar[rand()] + 5 for (x in bar)
print x, bar[x] }

индексы при bar будут гарантированно разными , потому что rand будет возвращать разные значения при каждом вызове. (массивы и функция rand еще не рассматривались. см. главу 11 [массивы в awk], стр. 123, и см. раздел 2.2 [встроенные числовые функции], стр. 136). этот пример иллюстрирует важный факт в отношении операторов присваивания: только выражение слева вычисляется один раз.

то, в каком порядке вычисляются выражения, левое и правое, зависит от реализации. рассмотрим пример:

i = 1 a[i += 2] = i + 1

значение a[3] может быть либо 2 либо 4.

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

lvalue += increment
добавляет increment к значению  lvalue для изменения  lvalue.

lvalue -= decrement
вычитает  decrement из значения lvalue.

lvalue *= coefficient
умножает значение lvalue на  coefficient.

lvalue /= divisor
делит значение  lvalue на  divisor.

lvalue %= modulus
присваивает lvalue значение ее остатка по modulus.

lvalue ^= power или  lvalue **= power

возводит lvalue в степень power. (только оператор `^=' указан в posix.) для максимальной переносимости не употребляйте оператор `**='.