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

11. массивы в awk

• 11.1 введение в массивы
• 11.2 ссылка на элемент массива
• 11.3 присваивания элементам массивов
• 11.4 основные примеры массивов
• 11.5 перебор всех элементов массива
• 11.6 оператор delete
• 11.7 использование чисел в индексах массивов
• 11.8 использование неинициализированных переменных в индексах
• 11.9 многомерные массивы
• 11.10 сканирование многомерных массивов

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

11.1 введение в массивы

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

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

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

индекс один указывает второй элемент, который располагается в памяти сразу после первого элемента, и т.д. невозможно добавить больше элементов к массиву, потому что он имеет место только для объявленного количества элементов. (некоторые языки допускают произвольные начальные и конечные индексы, например, `15 .. 27', но размер массива все равно фиксирован при его объявлении.) непрерывный массив с четырьмя элементами: восемь, "foo", "" и 30: может выглядеть так:

8 "foo" "" 30 значения
0  1    2  3 индексы

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

элемент 4 значение 30 элемент 2 значение "foo" элемент 1 значение 8 элемент 3 значение ""

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

этот массив разрежен, так как некоторые индексы пропущены: имеются элементы 1-4 и 10, но нет элементов 5, 6, 7, 8 и 9.

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

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

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

когда awk создает для вас массив, например, с помощью встроенной функции split, индексами этого массива становятся последовательные целые, начиная с единицы. (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137.)

11.2 ссылки на элемент массива

основной путь использования массивов состоит в ссылке на их отдельные элементы. ссылка на массив есть выражение формы:

здесь array означает имя массива. выражение index есть индекс элемента массива, на который вы ссылаетесь. значение ссылки на массив есть текущее значение соответствующего элемента. например, foo[4.3] есть выражение для элемента массива foo с индексом `4.3'. ссылка на элемент массива, значение которому еще не присвоено, имеет пустое значение "". это относится также к элементам, которые были вычеркнуты (см. раздел 11.6 [оператор delete], стр. 128). такая ссылка автоматически создает этот элемент со значением пустой цепочки. (в некоторых случаях это плохо, потому что зря занимается память внутри awk.)

вы можете определить, существует ли элемент массива с некоторым индексом, используя выражение: index in array. это выражение проверяет, существует или нет указанный индекс, без побочного эффекта создания элемента, если его не было. это выражение имеет значение один (true) если array[index] существует, и ноль (false), если он не существует.

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

if (2 in frequencies)
print "subscript 2 is present."

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

if (frequencies[2] != "")
print "subscript 2 is present."

11.3 присваивания элементам массива

элементы массива есть lvalues: им можно присваивать значения так же как переменным awk: array[subscript] = value. здесь array означает имя массива. выражение subscript есть индекс элемента массива, которому вы хотите присвоить значение. выражение value определяет значение, которое присваивается элементу массива.

11.4 примеры основных массивов

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

  {
    if ($1 > max)
      max = $1
      arr[$1] = $0
   }
     
   end {
    for (x = 1; x <= max; x++)
      print arr[x]
    }

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

5 i am the five man
2 who are you? the new number two!
4 . . . and four on the floor
1 who is number one?
3 i three you.

выход будет таким:

1 who is number one?
2 who are you? the new number two!
3 i three you.
4 . . . and four on the floor
5 i am the five man

если номер строки повторяется, то последняя строка с этим номером перекроет остальные. пропуски в номерах будут обрабатываться, если слегка усовершенствовать правило end программы:

end {
       for (x = 1; x <= max; x++)
         if (x in arr)
           print arr[x]
     }

11.5 перебор всех элементов массива

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

for (var in array)
body

этот цикл выполняет body один раз для каждого индекса в массиве, который ваша программа ранее использовала, с переменной var в качестве очередного индекса. приведем программу, пользующуюся этой формой оператора for. первое правило перебирает входные записи и отмечает, какие слова появились во вводе ( по крайней мере один раз), помещая их в массив со словами в качестве индексов. второе правило просматривает все найденные элементы массива used, использованные для нахождения всех отдельных слов во вводе. оно печатает каждое слово длиннее 10 символов и количество таких слов. см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137, для сведений о встроенной функции length.

# записываем 1 для каждого слова, встретившегося хотя бы один раз -
 {
   for (i = 1; i <= nf; i++)
    used[$i] = 1
  }
# находим количество отдельных слов длиннее 10 символов.
end {
         for (x in used)
             if (length(x) > 10) {
                 ++num_long_words
                 print x
             }
         print num_long_words, "слов длиннее 10 символов"
     }

см. раздел 16.2.5 [генерирование счетчиков, использующих слова], page 235, содержащий более подробный пример такого вида.

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

11.6 оператор delete (вычеркивание)

можно удалять отдельные элементы массива, используя оператор delete: delete array[index]. если вы вычеркнули элемент массива, вы не можете больше узнать значение, которое этот элемент имел. дело обстоит так, как будто на него никогда не ссылались и не присваивали никакого значения. вот пример вычеркивания элементов массива:

for (i in frequencies)
delete frequencies[i]

в этом примере удаляются все элементы массива frequencies. если удален какой нибудь элемент, то никакой оператор for просмотра массива не обнаружит этот элемент и выдаст ноль (т.e. false):

delete foo[4] if (4 in foo)
print "это никогда не будет напечатано"

важно заметить, что вычеркнуть элемент есть не то же самое, что присвоить ему пустое значение (пустую цепочку ""):

foo[4] = "" if (4 in foo)
print "это будет напечатано, хотя foo[4] теперь пусто"

вычеркивание несуществующего элемента не считается ошибкой. можно вычеркнуть все элементы массива одним оператором, убрав индекс в операторе delete: delete array . эта возможность есть расширение gawk; она не доступна в режиме совместимости (см. раздел 14.1 [параметры командной строки], стр.161). эта версия оператора delete почти в три раза эффективнее, чем вычеркивание по одному элементу за раз.

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

# спасибо to michael brennan за указание этого способа
split("", array)

функция split (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137) сначала очищает указанный массив. этот вызов просит ее разделить пустую строку. поскольку нет данных для разделения, функция только очищает массив.

внимание: вычеркивание массива не меняет его тип; нельзя вычеркнуть массив и затем использовать его имя как скаляр. например, такое не сработает:

11.7 употребление чисел для индексации массивов

важно помнить, что индексы массивов всегда цепочки. если в качестве индексов используются числовые значения, они превращаются в цепочки перед использованием для индексирования (см. раздел 7.4 [конверсии цепочек и чисел], стр. 81). это значит, что значение встроенной переменной convfmt может потенциально воздействовать на процесс доступа вашей программы к элементам массивов.

например:

xyz = 12.153 data[xyz] = 1 convfmt = "%2.2f" if (xyz in data)
printf "%s is in data\n", xyz else
printf "%s is not in data\n", xyz

будет напечатано `12.15 is not in data'. первый оператор дает xyz численное значение. присваивание data[xyz] индексирует data строковым значением "12.153" (по умолчанию используется для конверсии значение convfmt, "%.6g"), и присваивает единицу элементу data["12.153"]. затем программа меняет значение convfmt. тест `(xyz in data)' генерирует новое строковое значение из xyz, на этот раз "12.15", поскольку значение convfmt допускает только две значащих цифры. тест выдает false, поскольку "12.15" есть цепочка, отличная от "12.153".

в соответствии с правилами конверсии (см. раздел 7.4 [конверсии цепочек и чисел], стр. 81), целые числа всегда конвертируются в цепочки как целые, независимо от значения convfmt.

так, оператор:

for (i = 1; i != maxsub; i++)
do something with array[i]

будет работать независимо от значения  convfmt.

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

11.8 использование неинициализированных переменных в качестве индексов

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

$ echo 'line 1
     > line 2
     > line 3' | awk '{ l[lines] = $0; ++lines }
     > end {
     >     for (i = lines-1; i >= 0; --i)
     >        print l[i]
     > }'
     -| line 3
     -| line 2

к несчастью, самая первая строка ввода не появится на выходе! на первый взгляд программа должна работать. переменная lines не инициализирована, а неинициализированная имеет численное значение ноль. кажется, значение l[0] должно быть напечатано. но индексы в массивах awk всегда строковые значения. и неинициализированные переменные, используемые как цепочки, имеют значения "", не нули. таким образом `line 1' хранится в l[""].

следующая версия программы работает правильно:

{ l[lines++] = $0 }
     end {
         for (i = lines - 1; i >= 0; --i)
            print l[i]
     }

здесь `++' заставляет lines быть числом, делая "старое значение" числом ноль, которое затем конвертируется в "0" как индекс массива.

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

11.9 многомерные массивы

многомерный массив это такой массив, в котором элемент указывается последовательностью индексов, а не одним индексом. например, двумерный массив требует два индекса. обычный способ (в большинстве языков, включая awk) ссылаться на элемент двумерного массива с именем grid есть grid[x,y].

многомерные массивы в awk поддерживаются конкатенацией индексов в одну цепочку. точнее, awk конвертирует индексы в цепочки (см. раздел 7.4 [конверсия цепочек и чисел], стр. 81) и сцепляет их вместе с разделителями между ними. это создает одну цепочку, которая описывает значения всех индексов. комбинированная цепочка используется как один индекс в обычном одномерном массиве. в качестве сепаратора используется значение переменной subsep.

например, предположим, что вычисляем выражение `foo[5,12] = "value"' при значении subsep равном "@". номера пять и 12 конвертируются в строки и соединяются с `@' между ними, что приводит к "5@12"; таким образом, элементу foo["5@12"] присваивается в качестве значения "value".

когда запоминается элемент массива, для awk безразлично, был ли он с одним индексом или с последовательностью индексов. два выражения `foo[5,12]' и `foo[5 subsep 12]' всегда эквивалентны.

по умолчанию значением subsep служит цепочка "\034", которая содержит непечатный символ, появление которого маловероятно в awk-программе или во входных данных. польза выбора маловероятных символов проистекает из факта, что значения индекса, содержащего цепочку, соответствующую subsep, иногда приводят к комбинированным цепочкам не взаимно однозначно. предположим, что subsep была бы "@"; тогда `foo["a@b", "c"]' и `foo["a", "b@c"]' были бы неразличимыми, так как оба запомнятся как `foo["a@b@c"]'.

можно проверить, имеется ли определенная индексная последовательность в "многомерном" массиве с помощью того же самого оператора `in', используемого для одномерных массивов. вместо единственного индекса в позиции левого операнда нужно писать всю последовательность индексов, разделенных запятыми и заключенную в скобки: (subscript1, subscript2, ...) in array.

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

{
          if (max_nf < nf)
               max_nf = nf
          max_nr = nr
          for (x = 1; x <= nf; x++)
               vector[x, nr] = $x
     }
     
     end {
          for (x = 1; x <= max_nf; x++) {
               for (y = max_nr; y >= 1; --y)
                    printf("%s ", vector[x, y])
               printf("\n")
          }
     }

если задан ввод:

1 2 3 4 5 6 2 3 4 5 6 1 3 4 5 6 1 2 4 5 6 1 2 3

то программа выдаст:

4 3 2 1 5 4 3 2 6 5 4 3 1 6 5 4 2 1 6 5 3 2 1 6

11.10 просмотр многомерных массивов

не имеется специального оператора for для просмотра "многомерных" массивов; их и не могло быть, потому что на самом деле многомерных массивов или элементов нет; есть только многомерный путь доступа к элементам массива. однако, если ваша программа имеет массив, доступ к которому всегда многомерный, вы можете достичь эффекта в его сканировании, комбинируя сканирующий оператор for (см. раздел 11.5 [сканирование всех элементов массива], стр. 127) с встроенной функцией split (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137). это выглядит подобно следующему примеру:

for (combined in array) {
         split(combined, separate, subsep)
         ...
     }

здесь combined устанавливается на каждый комбинированный индекс массива и расщепляется на индивидуальные индексы, определяемые вхождениями значений subsep. расщепленные индексы становятся отдельными индексами измерений элемента массива array. так, предположим что присваивали значение элементу массива array[1, "foo"]; тогда в массиве есть элемент с индексом "1\034foo". (вспомним, что значение по умолчанию переменной subsep есть символ с кодом 034.)

раньше или позже, но оператор for найдет этот индекс и выполнит итерацию с combined равным "1\034foo". тогда функция split, вызовется с параметрами: split("1\034foo", separate, "\034"). в результате этого separate[1] получает значение "1", а separate[2] получает значение "foo". тем самым восстанавливается оригинальная последовательность индексов.