zaLinux.ru

Уроки по Awk


Оглавление

1. Так что такое AWK?

2. Что может делать AWK?

3. Специальные переменные

4. Простые примеры Awk

5. Вызов функций

6. Массивы

7. AWK и оболочки (sh/ksh/bash/csh)

8. Вопросы и ответы по awk

9. Примеры решения задач с помощью awk


Источники:

Часть первая: Так что такое AWK?

Awk, главным образом, это потоковый редактор вроде sed. Вы можете передавать по трубе текст в эту программу, и она может манипулировать им построчно. Программа также может читать из файла. Ещё awk – это язык программирования. Это в основном означает, что awk может делать всё, что может sed, а также ещё многое другое.

В отличие от sed, awk может помнить контекст, делать сравнения и многие другие вещи, которые могут делать другие языки программирования. Например, она не ограничена единичной строкой. При надлежащей сноровке, она может ОБЪЕДИНЯТЬ множество строк.

Самая простая форма awk выглядит так:

awk '{ здесь_какое-то_действие }'

"Здесь_какое-то_действие" может быть просто выражением для печати результата или чем-то намного более сложным. Синтаксис похож на язык программирования 'C'. Простой пример:

awk '{print $1,$3}'

означает напечатать первый и третий столбец, где под столбцами понимаются «вещи, разделённые белым пробелом». Белый пробел = табуляция или пробел.

Живой пример:

echo '1 2 3 4' | awk '{print $1,$3}'

1 3

Часть вторая: Что может делать AWK?

Главная цель в жизни AWK – это манипулировать её вводом на построчной основе. Программа awk обычно работает в стиле

Обработать строку. Двигаться дальше
Обработать строку. Двигаться дальше
Обработать строку…

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

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

awk образец {команда(ы)}

Это означает, что


«Посмотреть на каждую строку ввода, нет ли там ОБРАЗЦА. Если он там есть, запустить то, что между {}»

Можно пропустить или ОБРАЗЕЦ или КОМАНДУ

Если не указать образец, то команда будет применяться к КАЖДОЙ строке.

Если пропущена команда, то это эквивалентно указанию (просто напечатать строку):

{ print }

Конкретные примеры:

awk '/#/ {print "В этой строке есть комментарий"}' /etc/hosts

будет печатать «В этой строке есть комментарий» для каждой строки, которая содержит хотя бы один '#' в любом месте строки в /etc/hosts

Модификация для наглядности

awk '/#/ {print $0 ":\tВ этой строке есть комментарий"}' /etc/hosts

Элемент '//' в образце – это один из способов задать совпадение. Есть также другие способы задать, совпадает ли строка. Например,

awk '$1 == "#" {print "строка начинается с хеша"}' /etc/hosts

будет соответствовать строкам, первый столбец в которых является единичным '#'. Последовательность символов '==' означает ТОЧНОЕ СОВПАДЕНИЕ ВСЕГО первого столбца.

Модификация для наглядности:


awk '$1 == "#" {print $0 "\tстрока начинается с хеша"}' /etc/hosts

С другой стороны, если вы хотите частичное совпадение конкретного столбца, используйте оператор '~'

awk '$1 ~ /#/ {print "ГДЕ-ТО в столбце 1 есть хеш"}' /etc/hosts

ПОМНИТЕ, ЧТО ПЕРВЫЙ СТОЛБЕЦ МОЖЕТ БЫТЬ ПОСЛЕ БЕЛОГО ПРОБЕЛА.

Модификация для наглядности:

awk '$1 ~ /#/ {print $0 "\tГДЕ-ТО в столбце 1 есть хеш"}' /etc/hosts

Ввод "# comment" будет соответствовать

Ввод " # comment" будет ТАКЖЕ соответствовать

Если вам нужно конкретное совпадение «строка, которая начинается точно с # и пробела», вы должны использовать

awk '/^# / {делай что-то}'

Множественное совпадение

Awk обработает ВСЕ ОБРАЗЦЫ, которые соответствуют текущей строке. Поэтому если использовать следующий пример,

  awk '
     /#/ {print "Есть комментарий"}
     $1 == "#" {print "Комментарий в первом столбце"}
     /^# /  {print "Комментарий в самом начале"}
   ' /etc/hosts

ТРИ записи будет выведено для строки вроде следующей:

# This is a comment

ДВЕ записи для

  # This is an indented comment

и только одна для

1.2.3.4 hostname # a final comment

Отслеживание контекста

Не все строки созданы равными, даже если они выглядят одинаково. Иногда вы хотите сделать что-то со строкой в зависимости от строк, которые идут перед ней.

Здесь быстрый пример, который печатает строки "ADDR" если вы не в секции "secret"

   awk '

   /secretstart/  	{ secret=1}
   /ADDR/		{ if(secret==0) print $0 } /* $0 – это полная строка */
   /secretend/		{ secret=0} '

Следующее напечатает содержимое, которое содержит внутри "ADDR" кроме случаев, если была увидена строка "secretstart". ПОРЯДОК ИМЕЕТ ЗНАЧЕНИЕ. Например, если записать так:

   awk '

   /ADDR/		{ if(secret==0) print $0 } /* $0 – это полная строка */
   /secretstart/  	{ secret=1}

   /secretend/		{ secret=0} '

и дать следующий ввод

ADDR a normal addr
secretstart ADDR a secret addr
ADDR another secret addr
a third secret ADDR
secretend
ADDR normal too

то будет напечатан первый "secret" addr. При том, что первоначальный пример скроет оба секрета.

Часть третья: Специальные переменные

Мы уже сказали про обычный синтаксис awk. Сейчас давайте начнём рассматривать модные штуки.

awk имеет «специальные» строки соответствия: "BEGIN" и "END"

Директива BEGIN вызывается однажды перед чтением каких-либо строк из данных, никогда снова.


Директива END вызывается после прочтения всех строк. Если дано несколько файлов, то она вызывается только после завершения самого последнего файла.

Обычно вы будете использовать BEGIN для различной инициализации, а END для подведения итогов или очистки.

Пример:

BEGIN    	{ maxerrors=3 ; logfile=/var/log/something ; tmpfile=/tmp/blah}
  ...		{ blah blah blah }
/^header/	{ headercount += 1 }
END		{ printf("всего подсчитано заголовков=%d\n", headercount);

Этот пример посчитает количество раз, которое встречается "header" в файле ввода и напечатает общее количество только после завершения обработки всего файла.

AWK также имеет множество других специальных величин. Например,

print NF

даст вам общее количество колонок (Number of Fields – Количество полей) в текущей строке. FILENAME будет текущим именем файла, подразумевается, что имя файла было передано в awk, а не использована труба.

Вы НЕ МОЖЕТЕ ИЗМЕНИТЬ NF самостоятельно.

Аналогично с переменной NR, которая говорит, как много строк вы обработали. ("Number of Records" – Количество записей)

Есть и другие специальные переменные, вы даже такие, которые вы МОЖЕТЕ изменить в середине программы.

Часть четвёртая: Простые примеры Awk

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

Для последующих примеров давайте создадим файл field_data.txt со следующим содержимым:

Roses are red,
Violets are blue,
Sugar is sweet,
And so are you.

В командной строке это можно сделать так:

echo -e "Roses are red,\nViolets are blue,\nSugar is sweet,\nAnd so are you." > field_data.txt

Создадим файл letters.txt следующего содержания

a
bb
ccc
dddd
ggg
hh
i

В командной строке это можно сделать так:

echo -e "a\nbb\nccc\ndddd\nggg\nhh\ni" > letters.txt

И, наконец, создадим файл mail-data со следующим содержимым:

Amelia       555-5553     amelia.zodiacusque@gmail.com    F
Anthony      555-3412     anthony.asserturo@hotmail.com   A
Becky        555-7685     becky.algebrarum@gmail.com      A
Bill         555-1675     bill.drowning@hotmail.com       A
Broderick    555-0542     broderick.aliquotiens@yahoo.com R
Camilla      555-2912     camilla.infusarum@skynet.be     R
Fabius       555-1234     fabius.undevicesimus@ucb.edu    F
Julie        555-6699     julie.perscrutabor@skeeve.com   F
Martin       555-6480     martin.codicibus@hotmail.com    A
Samuel       555-3430     samuel.lanceolis@shu.edu        A
Jean-Paul    555-2127     jeanpaul.campanorum@nyu.edu     R

Это можно сделать в командной строке так:

wget https://raw.githubusercontent.com/tdhopper/awk-lessons/master/data/mail-data -O mail-data

Простой паттерн (образец)

Если нам нужны строки длиннее, чем два символа, и мы хотим использовать действие по умолчанию (print), то мы получаем:

awk 'length $0 > 2' letters.txt
bb
ccc
dddd
ggg
hh

$0 – это встроенная переменная, которая содержит строку.

Простая функция

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

awk '{ print }' letters.txt
a
bb
ccc
dddd
ggg
hh
i

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

awk '{ print length }' letters.txt
1
2
3
4
3
2
1

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

awk '{ print length $0 }' letters.txt
1a
2bb
3ccc
4dddd
3ggg
2hh
1i

Awk имеет специальные элементы управления для выполнения некоторого кода перед началом ввода файла и после его завершения.

awk 'BEGIN { print "HI" } { print $0 } END { print "BYE!" }' letters.txt
HI
a
bb
ccc
dddd
ggg
hh
i
BYE!

Мы можем иметь больше элементов управления во время печати используя printf.

awk 'BEGIN { printf "%-10s %s\n", "Name", "Number"; \
              printf "%-10s %s\n", "----", "------" } \
            { printf "%-10s %s\n", $1, $2 }' mail-data
Name       Number
----       ------
Amelia     555-5553
Anthony    555-3412
Becky      555-7685
Bill       555-1675
Broderick  555-0542
Camilla    555-2912
Fabius     555-1234
Julie      555-6699
Martin     555-6480
Samuel     555-3430
Jean-Paul  555-2127

Совмещаем образцы и функции

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

Мы можем напечатать длину всех строк, длиннее 2 символов.

awk 'length($0) > 2 { print length($0) }' letters.txt
3
4
3

На самом деле, мы не обязаны ограничивать Awk только одним паттерном! Мы можем иметь произвольное количество образцов, разграниченных точкой с запятой или новой строкой:

awk 'length($0) > 2 { print "Long:  " length($0) }; length($0) < 2 { print "Short: " length($0) }' letters.txt
Short: 1
Long:  3
Long:  4
Long:  3
Short: 1

Множество полей

Awk предназначена для простой обработки данных с множеством полей в ряду. Разделитель полей может быть указан ключом -F.

Пример файла, где разделителем является пробел:

awk '{ print }' field_data.txt
Roses are red,
Violets are blue,
Sugar is sweet,
And so are you.

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

awk -F " " '{ print $2 }' field_data.txt
are
are
is
so

Мы не получим ошибку, если строка не имеет соответствующего поля; нам просто будет показана пустая строка:

awk -F " " '{ print $4 }' field_data.txt



you.

Поскольку по умолчанию разделителем и так является пробел, то предыдущая команда дала бы точно такой же результат и без использования опции -F. Для более осмысленного примера, создадим ещё один файл rates.txt со следующим содержимым:

Pilcrow,Humphrey,3
Pilcrow,Zora,1
Plinius,Oldone,4
Razniecki,Anton,7
Russell,Bertrand,0

Теперь в качестве разделителя укажем , (запятую) и выведем содержимое второго столбца:

awk -F "," '{ print $2 }' rates.txt
Humphrey
Zora
Oldone
Anton
Bertrand

Выражение разделителя интерпретируется как регулярное выражение.

awk -F "((so )?are|is) " '{print "Field 1: " $1 "\nField 2: " $2}' field_data.txt
Field 1: Roses 
Field 2: red,
Field 1: Violets 
Field 2: blue,
Field 1: Sugar 
Field 2: sweet,
Field 1: And 
Field 2: you.

Регулярные выражения

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

Мы можем использовать регулярные выражения для поиска всех слов в мире Unix с 5 гласными подряд.

awk '/[aeiou]{5}/' /usr/share/dict/words
cadiueio
Chaouia
euouae
Guauaenok

Передача переменных в программу

Опция -v для Awk позволяет нам передать переменные в программу. Например, мы можем использовать это для жёстких констант кода.

awk -v pi=3.1415 'BEGIN { print pi }'
3.1415

Мы также можем использовать -v для передачи переменных Bash как переменных Awk

awk -v user=$USER 'BEGIN { print user }'
mial

Выражения If-else

If-else выражения в Awk имеют вид:

if (условие) тело-тогда [else тело-ещё]

Например:

printf "1\n2\n3\n4" | awk \
     '{ \
         if ($1 % 2 == 0) print $1, "is even"; \
         else print $1, "is odd" \
      }'
1 is odd
2 is even
3 is odd
4 is even

Циклы

Awk включает несколько выражений цикла: while, do while и for.

Они имеют ожидаемый синтаксис C.

awk \
     'BEGIN { \
         i = 0; \
         while (i < 5) { print i; i+=1; } \
      }'
0
1
2
3
4
awk \
     'BEGIN { \
         i = 0; \
         do { print i; i+=1; } while(i < 0) \
      }'
0
awk \
     'BEGIN { \
         i = 0; \
         for(i = 0; i<5; i++) print i \
      }'
0
1
2
3
4

for также может задавать цикл через ключи массива, which будет рассмотрена позже.

Часть пятая: Вызов функций

Следующий компонент AWK – это все его специальные встроенные функции.

AWK имеет функции, которые сделают среднего C программиста весьма счастливым. Здесь такое добро как sin()/cos()/tan(), rand(),index(), sprintf(), tolower(), system()

Функции сгруппированы, их можно рассматривать следующим образом:

Математические

  +, -, /, *, sin(), cos(), tan(), atan(), sqrt(), rand(), srand()

Они сами за себя говорят, по крайней мере, мне хочется так думать.

Пример:

awk -v pi=3.1415 'BEGIN { print exp(1), log(exp(1)), sqrt(2), sin(pi), cos(pi), atan2(pi, 2) }'
2.71828 1 1.41421 9.26536e-05 -1 1.00387

Программа может сгенерировать случайное число в диапазоне (0, 1).

awk 'BEGIN { print rand(); print rand() }'
0.237788
0.291066

По умолчанию Awk начинает с одного и того же начала (сида) для Awk. Запуск этой команды два раза подряд возвратит одинаковый результат:

awk 'BEGIN { print rand(); print rand() }'
0.237788
0.291066

Для установки начала (сида) можно использовать функцию srand:

awk 'BEGIN { srand(10); print rand(); print rand() }'
0.255219
0.898883
awk 'BEGIN { srand(10); print rand(); print rand() }'
0.255219
0.898883

Функция int возвращает "самое близкое целое число к x, расположенное между x и нулём и с отброшенным ведущим нулём".

awk 'BEGIN { print "int(0.9)  =  " int(0.9); print "int(-0.9) = " int(-0.9) }'
int(0.9)  =  0
int(-0.9) = 0

Манипуляция строками

  • index() скажет вам, встречается ли, а если да, то где, строка в подстроке.
  • match() похожая, но работает для регулярных выражений.
  • sprintf() даёт вам способы форматировать вывод и по пути делать преобразования. Это должно быть знакомо всем, кто использовал printf() с C. Например,
   newstring=sprintf("one is a number %d, two is a string %s\n", one,  two);
   print  newstring

"%d" говорит "напечатай значение, соответствующее мне, в виде десятичного числа"
"%s" говорит "напечатай значение, соответствующее мне, в виде строки"

Т.е. если вы хотите объединить две строки без разрывов, ОДИН из способов будет использование 

    newstring=sprintf("%s%s", one,  two)
  • length() просто даёт вам простой способ подсчитать количество символов в строке, если вам это понадобится.

substr

Функция substr(s, m, n) возвратит подстроку в n-символов, начинающуюся с позиции m, отсчитанной от 1.

awk '{ print $1, substr($1, 2, 3) }' field_data.txt
Roses ose
Violets iol
Sugar uga
And nd

index

index(s, t) возвращает "позицию в s в которой встречается строка t, или 0 если она не встречается".

Паттерн для index не является регулярным выражением.

awk '{ print $1, index($1, "s") }' field_data.txt
Roses 3
Violets 7
Sugar 0
And 0

match

match(s, r) возвращает позицию в s в которой встречается регулярное выражение r, или 0 если оно не встречается. Переменные RSTART и RLENGTH устанавливаются в позицию и длину совпадающей строки.

match – это как index кроме того, что паттерн является регулярным выражением.

awk '{ print $1, match($1, "[sS]") }' field_data.txt 
Roses 3
Violets 7
Sugar 1
And 0
# "Поиск трёх или более повторяющихся букв"
awk '{ match($1, "[a-z]{3}"); print $1, "\tpattern start:", RSTART, "\tpattern end:", RLENGTH }' letters.txt
a 	pattern start: 0 	pattern end: -1
bb 	pattern start: 0 	pattern end: -1
ccc 	pattern start: 1 	pattern end: 3
dddd 	pattern start: 1 	pattern end: 3
ggg 	pattern start: 1 	pattern end: 3
hh 	pattern start: 0 	pattern end: -1
i 	pattern start: 0 	pattern end: -1

split

split(s, a, fs) расщепляет строку на массив элементов a[1], a[2], …, a[n], и возвращает n.

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

awk 'BEGIN { print split("It-was_the-best_of-times", output_array, "[-_]"), output_array[2], output_array[4] }'
6 was best

Практический пример команды, которая из выводимых данных выбирает версию Bluetooth и «конвертирует» её в понятную нам версию (в соответствии с официальной документацией):

btmgmt info | 
awk 'BEGIN{
	split("1.0b 1.1 1.2 2.0 2.1 3.0 4.0 4.1 4.2 5.0 5.1 5.2 5.3",i," ")
}
$1=="addr"{print "Bluetooth: V"i[$4+1]}'

Строка split("1.0b 1.1 1.2 2.0 2.1 3.0 4.0 4.1 4.2 5.0 5.1 5.2 5.3",i," ") разбивает массив "1.0b 1.1 1.2 2.0 2.1 3.0 4.0 4.1 4.2 5.0 5.1 5.2 5.3" на подстроки, используя в качестве разделителя пробел и присваивает значение полученного массива переменной i.

Команда $1=="addr"{print "Bluetooth: V"i[$4+1]}' распространяет своё действие только на те строки, в которых первое поле является строкой addr. Для таких строк выводится следующее:

  • строка «Bluetooth: V»
  • одно из значений массива i, индекс выводимого значения вычисляется как значение четвёртого поля к которому прибавлена единица

sub

sub(r, t, s) заменяет на t первое вхождение регулярного выражения r в строке s. Если не дана s, то используется $0

s является строкой, в которой происходит замена. Вместо возврата новой строки с произведённой заменой будет возвращено количество сделанных замен (0 или 1).

awk 'BEGIN { s = "It was the best of times, it was the worst of times"; \
             print "Num. matches replaced:",  sub("times", "gifs", s ); \
             print s  }'
Num. matches replaced: 1
It was the best of gifs, it was the worst of times

gsub

gsub делает то же самое, что и sub за исключением того, что заменяются все вхождения регулярного выражения; sub и gsub возвращают количество замен.

awk 'BEGIN { s = "It was the best of times, it was the worst of times"; \
             print "Num. matches replaced:", gsub("times", "cats", s ); \
             print s  }'

Num. matches replaced: 2
It was the best of cats, it was the worst of cats
sprintf
sprintf(fmt, expr, ... ) returns the string resulting from formatting expr ...  according to the printf(3) format fmt

awk 'BEGIN { x = sprintf("[%8.3f]", 3.141592654); print x }'
[   3.142]

Функции уровня системы

system() позволяет вам вызвать потенциально ЛЮБОЙ исполнимый файл в системе. Целевая программа может как быть в вашей $PATH, или вы можете указать её по абсолютному пути.

Например, страшное

    system("rm -rf $HOME");

или

    system("/bin/kill 1")

Если вы хотите делать более сложные вещи, вы, вероятно, в конечном итоге делает что-то вроде

   sysstring=sprintf("somecommand %s %s", arg1,  arg2);
   system(sysstring)

close() – это важная функция, которую часто упускают из вида. Вероятно, это из-за того, что нет очевидного вызова open(), поэтому народ не думает про вызов close(). И для большинства целей это и не нужно. Но вы ДОЛЖНЫ ДЕЛАТЬ ЭТО, если вы имеете дело с боее чем одним файлом вывода.

Awk даёт вам возможность открыть произвольный файл на лету. Например

  /^file/	{ print $3 >> $2 }

должен взять строку "file output here-is-a-word", открыть файл 'output' и напечатать 'here-is-a-word' в него.

AWK является "умной", в том, что отслеживает, какие файлы вы открывайте и СОХРАНЯЕТ их открытыми. Она предполагает, если вы открыли файл один раз, вы, вероятно, сделать это снова. К сожалению, это означает, что, если вы откроете МНОГО файлов, файловые дескрипторы могут закончиться. Поэтому, когда вы знаете, что закончили с файлом, закройте его. Поэтому для улучшения примера выше, вы должны использовать что-то в духе следующих строк:

  /^file/	{ if ( $2 !=  oldfile ) { close( oldfile) };
  			print $3 >> $2 ;  oldfile = $2; }

Часть шестая: Массивы

Понятие массива

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


Если вам нужно иметь три значения, вы можете сказать:

value1="one"; value2="two"; value3="three";

ИЛИ, вы можете использовать

values[1]="one"; values[2]="two"; values[3]="three";

Первый пример – это три разных переменных со своими именами (которые различаются на один символ). Второй пример – это массив, который состоит из одной переменной, но содержит много значение, каждое из которых имеет свой номер.

При использовании переменной в качестве массива, всегда нужно помещать значение в квадратные скобки []. Вы можете выбрать любое имя для переменной массива, но с этого момента это имя можно использовать ТОЛЬКО для массива. Вы НЕ МОЖЕТЕ осмысленно делать

values[1]="one";
values="newvalue";

Тем не менее, вы МОЖЕТЕ переназначить величины, как для нормальных переменных. Т.е. следующее ЯВЛЯЕТСЯ правильным:

values[1]="1";
print values[1];
values[1]="one";
print values[1];

Интересно то, что в отличие от некоторых других языков, вы не обязаны использовать только номера. В примерах выше [1],[2],[3] на самом деле истолковываются как [«1»], [«2»], [«3»]. Что означает, что вы также можете использовать другие строки в качестве идентификаторов, и рассматривать массив почти как базу данных с одной колонкой. Официальное название для этого «ассоциированный массив».

numbers["one"]=1;
numbers["two"]=2;
print numbers["one"];
value="two";
print numbers[value];
value=$1;
if(numbers[value] = ""){ print "no such number"; }

Когда и как использовать массивы

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

Сохранение информации для дальнейшего использования

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

/special/{ savedwords[lnum]=$2; lnum+=1; }
END	{
		count=0;
		while(savedwords[count] != "")
		{
			print count,savedwords[count];
			count+=1;
		}
	}

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

Если вы хотите присвоить уникальный индекс значениям (для избегания дубликатов), вы вообще можете отсылать к их значения по их собственным строкам. Или, например, сохранить массив с колонкой 3, проиндексированный по соответствующему значению колонки 2.

{ threecol[$2]=$3 }
END	{
		for (v in threecol)
		{
			print v, threecol[v]
		}
	}

Массивы и функция split()

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

  This is a variable:field:type line
  There can be multiple:type:values here

В примере выше четвёртое отделённое пробелом поле имеет подполя, разделённые двоеточиями. Теперь, допустим, вы хотите узнать значение второго подполя в четвёртом большом поле. Один из способов сделать это, вызвать две awk связанные трубой:

awk '{print $4}' | awk -F: '{print $2}'

Другим способом будет на лету изменить значение 'FS', которая содержит разделитель полей (судя по всему, это работает не со всеми реализациями awk):

awk '{ newline=$4; fs=FS; FS=":";  $0=newline; print $2 ; FS=fs; }'

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

awk '{ newline=$4; split(newline,subfields,":"); print subfields[2]} '

В этом случае использование массива это самый обычный и, возможно, самый изящный способ сделать это.

Итак, Awk обеспечивает ограниченное количество структур данных. Кроме скалярных и строковых переменных, в язык встроена структура массивных данных. Хотя официально она называется «массивы», эта структура на самом деле является ассоциированным массивом, аналогичной структуре данных dict в Python.

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

awk 'BEGIN { \
      a[0] = 1.1; \
      a[0.83] = 0; \
      a["DOG"] = "CAT"; \
      print a[0], a[0.83], a["DOG"] \
     }'
1.1 0 CAT

Awk не будет печать переменную без индекса:

awk 'BEGIN { \
      a["DOG"] = "CAT"; \
      print a \
     }'
awk: cmd. line:3: fatal: attempt to use array `a' in a scalar context

Хотя мы можем сделать цикл по ключу используя for:

awk 'BEGIN { \
      a[0] = 1.1; \
      a[0.83] = 0; \
      a["DOG"] = "CAT"; \
      for(k in a) print(a[k]) \
      }'
CAT
0
1.1

Часть седьмая: AWK и оболочки (sh/ksh/bash/csh)

Иногда функционала AWK может быть недостаточно. В этом случае можно интегрировать awk в скрипт оболочки. Далее несколько примеров как это можно сделать.

Простой вывод

Иногда хочется использовать awk просто как программу форматирования, и сбрасывать вывод прямо пользователю Следующий скрипт принимает в качества аргумента имя пользователя и использует awk для дампа информации о нём из /etc/passwd.

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

#!/bin/sh

while [ "$1" != "" ] ; do
	awk -F: '$1 == "'$1'" { print $1,$3} ' /etc/passwd
	shift
done

Присвоение переменным оболочки вывода awk

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

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

#!/bin/sh

user="$1"
if [ "$user" == "" ] ; then echo ERROR: need a username ; exit ; fi

usershell=`awk -F: '$1 == "'$1'" { print $7} ' /etc/passwd`
grep -l $usershell /etc/shells
if [ $? -ne 0 ] ; then
        echo ERROR: shell $usershell for user $user not in /etc/shells
fi

Другие альтернативы:

# Смотрите "man regex"
usershell=`awk -F: '/^'$1':/ { print $7} ' /etc/passwd`
echo $usershell;

# Только современные awk принимают -v. Вам может понадобиться использовать "nawk" или "gawk"
usershell2=`awk -F: -v user=$1 '$1 == user { print $7} ' /etc/passwd`
echo $usershell2;

Объяснение дополнительных вышеприведённых методов остаётся домашним заданием читателю 🙂

Передача данных в awk по конвейеру (трубе)

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

#!/bin/sh

grep -h ' /index.html' $* | awk -F\" '{print $4}' | sort -u

Вопросы и ответы по awk

Как вывести только строку определённого номера в awk

Чтобы вывести строки с определённым номером, используйте if() и переменную NR.

Например, чтобы вывести только вторую строку:

free | awk '{ if (NR == 2) print $7 }'

Чтобы вывести вторую и все последующие строки:

free | awk '{ if (NR >= 2) print $7 }'

Чтобы вывести все строки с 10 по 20:

awk '{ if (NR >= 10 && NR <= 20) print }' /etc/passwd

Как перенаправить вывод в файл в awk

Команду print можно использовать с перенаправлением вывода в файл.

К примеру, следующая команда сохранит строки с 10 по 20 из файла /etc/passwd в файл pswd.txt:

awk '{ if (NR >= 10 && NR <= 20) print>"pswd.txt" }' /etc/passwd

Следующая команда ищет в строке слово «mial» и если оно там встречается, то сохраняет всю строку в файл pswd.txt:

awk '/mial/{ print>"pswd.txt" }' /etc/passwd

Как использовать переменные в awk

Следующая команда посчитает количество строк содержащих слово «bash» в файле /etc/passwd, выведет каждую из этих строк и затем выведет общее количество найденных строк:

awk -v y=0 '/bash/{ y++; print $0 } END { print "Всего найдено строк с bash: " y }' /etc/passwd

При запуске программы инициируется переменная y со значением 0. При каждом совпадении (найдена строка «bash»), значение y увеличивается на единицу и выводится найденная строка. В конце выводится значение y.

Как вывести скобки и другие специальные в awk

Скобки и другие специальные символы необходимо помещать в двойные кавычки.

awk -F ',' '{ print "(" $1, $2 ")" }'

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

Как удалить символы newline из вывода команд

С помощью awk вы можете удалить символы newline (новой строки) используя следующую конструкцию:

awk '{ printf "%s", $0 }'

Например:

echo 'HackWare.ru' | awk '{ printf "%s", $0 }' | md5sum

Ещё один вариант:

awk '{printf $0}'

Например:

echo 'HackWare.ru' | awk '{printf $0}' | md5sum

Как заменить символы newline на пробелы в файле

Следующая команда прочитает файл FILE, заменит в нём newline на пробелы и выведен полученный результат на экран:

awk 1 ORS=' ' FILE

Объяснение:

Программа awk состоит из правил, состоящих из условных кодовых блоков, то есть:

условие { кодовый блок }

Если кодовый блок опущен, используется значение по умолчанию: { print $0 }. Таким образом, 1 всегда интерпретируется как истинное условие, и для каждой строки выполняется print $0.

Когда awk читает ввод, он разбивает его на записи на основе значения RS (Record Separator, разделитель записей), который по умолчанию является newline (новой строкой), поэтому awk по умолчанию будет анализировать ввод построчно. Разделение также включает удаление RS из входной записи.

Теперь при печати записи к ней добавляется ORS (Output Record Separator, разделитель выходных записей), по умолчанию снова newline. Таким образом, поскольку мы заменили значение ORS на пробел, все символы новой строки заменяются пробелами.

Ещё один вариант, чтобы заменить все новые строки пробелами с помощью awk, не считывая весь файл в память:

awk '{printf "%s ", $0}' FILE

Если вы хотите, чтобы присутствовал финальный newline:

awk '{printf "%s ", $0} END {printf "\n"}' FILE

Вы можете использовать не только символ пробела (в данном случае вместо пробела разделителем является символ «|»):

awk '{printf "%s|", $0} END {printf "\n"}' FILE

Ещё одно просто решение на awk:

awk '{printf $0 " "}' FILE

Как вывести с n-го столбца до последнего

Задача:

  • как вывести со второго столбца до последнего
  • как вывести с третьего столбца до последнего
  • как вывести с четвёртого столбца до последнего
  • как вывести с n-го столбца до последнего

Как вывести с n-го столбца до последнего:

В awk вы можете использовать конструкцию вида:

awk '{$1=$2=$3="";print $0}'

Этот пример очистит содержимое первых трёх столбцов и покажет все колонки, начиная с четвёртого столбца.

Но при этом пробелы, который находятся между первым и вторым столбцом, вторым и третьим столбцом, а также третьим и четвёртым столбцом удалены не будут и будут показаны. Чтобы их удалить используйте дополнительно команду sed:

awk '{$1=$2=$3="";print $0}' | sed -r "s/^\s+//g"

Либо вы можете использовать следующую команду awk которая очищает пробелы между удалёнными стобцами:

awk '{$1=$2=$3=""; $0=$0; $1=$1; print}'

Как вывести со второго столбца до последнего:

awk '{$1="";print $0}' | sed -r "s/^\s+//g"
awk '{$1=""; $0=$0; $1=$1; print}'

Примеры:

echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1="";print $0}' | sed -r "s/^\s+//g"
echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1=""; $0=$0; $1=$1; print}'

Как вывести с третьего столбца до последнего:

awk '{$1=$2="";print $0}' | sed -r "s/^\s+//g"
awk '{$1=$2=""; $0=$0; $1=$1; print}'

Примеры:

echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1=$2="";print $0}' | sed -r "s/^\s+//g"
echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1=$2=""; $0=$0; $1=$1; print}'

Как вывести с четвёртого столбца до последнего:

awk '{$1=$2=$3="";print $0}' | sed -r "s/^\s+//g"
awk '{$1=$2=$3=""; $0=$0; $1=$1; print}'

Примеры:

echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1=$2=$3="";print $0}' | sed -r "s/^\s+//g"
echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{$1=$2=$3=""; $0=$0; $1=$1; print}'

Как вывести последний столбец

Для вывода последнего столбца с помощью awk используйте команду:

awk '{print $NF}'

Например:

echo 'vddp vddpi vss cb0 cb1 cb2 cb3 ct0 ct1 ct2 ct3' | awk '{print $NF}'

Почему awk неправильно определяет границы данных, разделённых табуляцией

Следующая команда вместо ожидаемого третьего столбца вернёт пустой результат:

echo '1     2     3     4     5     6' | awk -F'\t' '{ print $3 }'

В команде вместо стандартного FS (Input field separator, разделитесь полей входных данных), которым по умолчанию является пробел, опцией -F'\t' установлен новый разделитесь, в качестве которого указан «\t», что означает символ табуляции.

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

То есть использовании опции -F не нужно в предыдущей команде:

echo '1     2     3     4     5     6' | awk '{ print $3 }'
3

Несмотря на то, что данные разделены несколькими пробелами, указывать это с опцией -F не нужно, поскольку она правильно истолковывает ввод. По умолчанию разделителем полей в awk служит один или больше пробелов (пробельные символы или символ табуляции), что соответствует [ \t]+ или если использовать posix классы [[:blank:]]+

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

echo '1	2	3	4' | awk '{ print $3 }'
3

В этом случае опция -F'\t' работает как и ожидается:

echo '1	2	3	4' | awk -F'\t' '{ print $3 }'
3

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

Чтобы проверить, какие именно непечатные символы присутствуют во вводимых данных, используйте cat -A. Например:

echo '1	2	3    4' | cat -A
1M-bM-^PM-^A^IM-oM-?M-=2^I3    4$

Как сделать так, чтобы awk выводила поля разделяя их табуляцией

Следующая команда выведет третью и четвёртую колонку, разделяя их пробелом:

echo '1	2	3	4	5' | awk '{ print $3,$4 }'
3 4

Если вы хотите, чтобы выводимые данные разделялись табуляцией (или любым другим символом), то его нужно установить в качестве значения OFS (output field separator, разделитесь выходных полей). Например:

echo '1	2	3	4	5' | awk 'BEGIN {OFS="\t"}; { print $2,$3 }'
2	3

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

echo '1	2	3	4	5' | awk 'BEGIN {OFS="\t"}; { print $2 $3 }'
23

Кроме изменения значения OFS (output field separator, разделитесь выходных полей) вы можете указать символ табуляции в шаблоне вывода. Например, следующая команда для разделения второго и третьего поля будет использовать стандартный OFS (то есть пробел), а между третьей и четвёртой колонкой будет вставлен знак табуляции:

echo '1	2	3	4	5' | awk '{ print $2,$3"\t"$4 }'
2 3	4

Примеры решения задач с помощью awk

Задача 1.

Есть файл вот с таким содержимым:

ОРГАНИЗАЦИЯ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
ОРГАНИЗАЦИЯ
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
ОРГАНИЗАЦИЯ
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
ОРГАНИЗАЦИЯ
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
ОРГАНИЗАЦИЯ
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
ОРГАНИЗАЦИЯ
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|
НАЧИСЛЕНИЕ|

Таких строк может быть любое количество, как в меньшую, так и в большую сторону. После слов "ОРГАНИЗАЦИЯ" строка продолжается наименованием и реквизитами организации.

После слов "НАЧИСЛЕНИЕ" строка продолжается суммой начисления и прочими данными.

Разделителем является труба: |

Задача такая — с помощью awk найти слово "ОРГАНИЗАЦИЯ", скопировать содержимое этой строки и привязанные к ней строки "НАЧИСЛЕНИЕ".

Т.е. первую строку "ОРГАНИЗАЦИЯ" и две строки ниже со словом "НАЧИСЛЕНИЕ". Вывести эти 3 строки в отдельный файл. Количество строк может быть любым.

Найти следующие строки по такому же принципу и опять в отдельный файл.

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

Решение 1. Работает в awk под Linux

awk -v y=0 '/ОРГАНИЗАЦИЯ/{if(x) print x>y; x=$0 ;y++} !/ОРГАНИЗАЦИЯ/{x=x"\r\n"$0} END {print x>y}' test.txt

Решение 2. Работает в awk под Windows

awk.exe -v y=0 "/ОРГАНИЗАЦИЯ/{y++; print $0>y\".txt\";} !/ОРГАНИЗАЦИЯ/{print $0>y\".txt\"}" test.txt

Входные данные в файле test.txt. Тестировалась в cmd (а не в PowerShell).

Скриншот:

Содержимое первых четырёх файлов:

Задача 2.

Как добавить в существующий файл строку с нужными мне данными?

Т.е. есть файл, например, с 6 строками и я хочу добавить сроку перед 1 строкой или добавить строку во все .txt файлы в определённой папке.

Решение 1. Работает в awk под Linux

Итак, следующий пример считывает все файлы из текущего каталога (*). Если нужно, чтобы считывал только файлы с определённым разрешением, то вместо звёздочки можно записать, например, так *.txt.

Для каждого обрабатываемого файла в самое начало добавляется строка "СТРОКА" — замените на нужную. Новые файлы сохраняются в эту же папку, с такими же именами, но перед именем добавляется префикс "new_" - при желании, его можно удалить или заменить на другой (в двух местах команды!).

Собственно команда:

awk -v 'OLD_FILENAME=""' '{if(OLD_FILENAME!=FILENAME) print "СТРОКА" > "new_"FILENAME; OLD_FILENAME=FILENAME} {print > "new_"FILENAME;}' *

Логика работы:

  • при запуске awk инициализируется переменная OLD_FILENAME — которой в качестве значения присваивается пустая строка
  • при обработке каждой строки, значение переменной OLD_FILENAME сравнивается со значением встроенной переменной FILENAME в которой (сюрприз!) содержится имя текущего файла. Если эти значения НЕ равны, то в файлы печатается строка "СТРОКА" И переменной OLD_FILENAME присваивается значение, которое содержит FILENAME.
  • следующая часть {print > "new_"FILENAME;} просто печатает очередную строку в новый файл
  • при последующих прохождениях (вторая строка, третья строка и т. д.) значения OLD_FILENAME и FILENAME будут одинаковыми. Вплоть до момента, пока обрабатываемый файл не сменится на новый. В этот момент OLD_FILENAME и FILENAME становятся не равны и в новый файл первой печатается строка "СТРОКА" и переменной OLD_FILENAME присваивается значение FILENAME
  • всё продолжается, пока все строки во всех файлах не кончатся

Решение 2. Работает в awk под Windows

Для Windows (cmd, а не PowerShell):

awk.exe -v OLD_FILENAME="" "{if(OLD_FILENAME!=FILENAME) print \"СТРОКА\" > \"new_\"FILENAME; OLD_FILENAME=FILENAME} {print > \"new_\"FILENAME;}" *.txt

Рекомендуемые статьи:

7 Комментарии

  1. syntx

    Занимательная статья, хочу поблагодарить за труды.

    Нашёл в ней не точность. Если выполнить строку из примера

    awk -F " " '{ print $2 }' field_data.txt

    она выведет тоже самое, что и 

    awk '{ print $2 }' field_data.txt

    Получается пример с -F не удачно описан.

    1. Alexey (Автор записи)

      Спасибо за полезное замечание. Добавил ещё один пример, в котором в качестве разделителя используется запятая.

  2. redking

    несколько мелких ремарок по тексту:

     AWK также имеет множество других специальных величин, которые вы можете использовать в секции { }.

    полагаю что "которые вы можете использовать в секции { }" лишнее, так как наводит на мысль что NF можно использовать только в пределах {}, а это не совсем так, например:
    awk 'NF!=0'
    удалит все пустые строки из вывода

    awk 'BEGIN { printf "%-10s %s\n", "Name", "Number" \
                  printf "%-10s %s\n", "----", "------" } \
                { printf "%-10s %s\n", $1, $2 }' mail-data

    в awk перенос записи команд с помощью слеша(\) как в bash не работает, вернее оно(\) либо просто проигнорируется либо выдаст ошибку, примеры шаблонов:

    {print … \
    print …}

    ОШИБКА (когда используется как разделитель между командами)

    {print …
    print …}

    правильно

    {print …; print …}
    правильно

    {print … ;
    print …}

    правильно но бесмысленно, в данном случае перенос строки срабатывает как разделитель команд ';' даже при if else и др.

    {print … ;\
    print …}

    правильно но вдвойне бесмысленно

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

    awk '/[aeiou]{5}/' /usr/share/dict/words
    cadiueio
    Chaouia
    euouae
    Guauaenok

    данный файл может быть не у всех, по крайней мере в archlinux
    судя по статье Words_(Unix) из wiki, для Debian/Ubuntu нужен пакет wordlist, а для Arch и Fedora нужен пакет words ; и действительно в Arch-e после установки пакета words появляется данный файл, НО даже после установки нужного пакета вышеописанная команда awk не выдаст нужного результата так как не найдёт в файле /usr/share/dict/words таких слов, не знаю как в другиг дистрах но похоже со временем что-то поменялось и данные слова потёрли с этого словаря.

    Как вариант можно установить пакет wordlists из AUR-a там есть куча всяких словарей по адресу /usr/share/wordlists/ и данные слова находятся, но проблема в том что там очень много разных словарей общим объёмом порядка 1,8G

    # "Поиск трёх или более повторяющихся букв"
    awk '{ match($1, "[a-z]{3}"); print $1, "\tpattern start:", RSTART, "\tpattern end:", RLENGTH }' letters.txt

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

    sprintf
    sprintf(fmt, expr, … ) returns the string resulting from formatting expr …  according to the printf(3) format fmt
     
    awk 'BEGIN { x = sprintf("[%8.3f]", 3.141592654); print x }'
    [   3.142]

    думается мне что эта часть кода не совсем "раскрыта" в тексте

     Другим способом будет на лету изменить значение 'FS', которая содержит разделитель полей (судя по всему, это работает не со всеми реализациями awk):
        
    awk '{ newline=$4; fs=FS; FS=":"; $0=newline; print $2 ; FS=fs; }'

    тут, кстати, можно немного упростить и не вводить лишних переменных:
    awk '{$0=$4; FS=":"; $0=$0; print $2; FS=" "}'

    awk '{ newline=$4; split(newline,subfields,":"); print subfields[2]} '
     В этом случае использование массива это самый обычный и, возможно, самый изящный способ сделать это.

    в простых случаях, коих большинство, у нас фиксированная структура поступающих данных, а если мы и так знаем где находится нужная подстрока($4) то проще будет составить подходящий разделитель:
    awk -F' |:' '{print $5}'
    даст тот же результат

    а вот пример боле сложного случая, когда искомые подстроки могут идти после других подстрок с теми же разделителями, и они имеют разное количество елементов
    1 2 a1:b1 a1:b1:c1 3
    1 2 a2:b2:c2 a2:b2:c2 3

    вот здесь уже да, без вышеописанных вами методов трудно обойтись

     Чтобы вывести строки с определённым номером, используйте if() и переменную NR.

    вообщето без if тоже можно обойтись:
    free |awk 'NR==2{print $7}'
    free |awk 'NR>=2{print $7}'
    awk 'NR>=10 && NR<=20' /etc/passwd

     

    От себя хотел бы еще добавить, возможно кому-то будет полезно, что аналогом ключа -i у sed для awk является -i inplace, то есть:
    awk -i inplace '{…}' file.txt
    все обработанные данные из file.txt запишутся в этот же файл

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

     

     

    1. Alexey (Автор записи)

      Приветствую! Спасибо большое за такие подробные и полезные замечания — мне нужно некоторое время, чтобы «переварить» информацию — в любом случае, я учту всё написанное и исправлю данный материал. Надеюсь, это оценят и другие изучающие awk.

      Также планирую добавить примеры из man awk.

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

      К примеру, следующую команду я могу целиком скопировать-вставить, либо набрать посимвольно и она выполнится без ошибок.

      awk \
           'BEGIN { \
               i = 0; \
               while (i < 5) { print i; i+=1; } \
            }'

      А уже без обратных слэшей при копировании-вставке целиком будет ошибка:

      awk 
           'BEGIN { 
               i = 0; 
               while (i < 5) { print i; i+=1; } 
            }'

      Что касается примера

      awk 'BEGIN { printf "%-10s %s\n", "Name", "Number" \
                    printf "%-10s %s\n", "----", "------" } \
                  { printf "%-10s %s\n", $1, $2 }' mail-data

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

  3. redking

    А уже без обратных слэшей при копировании-вставке целиком будет ошибка:

    есть область видимости awk, а есть область видимости bash и слеши у них будут действовать по разному

    правильнее будет так:

    awk \

         'BEGIN {

             i = 0

             while (i < 5) { print i; i+=1 }

          }'

    если упростить:

    awk  \

      -F':' \

       '… а здесь уже действуют законы awk …'

    Что касается примера

    awk 'BEGIN { printf ... \

                  printf ... } \

                { printf ... }' mail-data

    ошибка из за того что слеш между двумя printf в одном блоке{}, то есть, две подряд идущие команды в одном блоке должны быть разделены либо точкой с запятой(;) и/или переносом строки

    awk 'BEGIN { printf ...

                 printf ... }

               { printf ... }' mail-data

    или

    awk 'BEGIN { printf ...  ;

                 printf ... }

               { printf ... }' mail-data

    или

    awk 'BEGIN { printf ...  ; printf ... }

               { printf ... }' mail-data

    слеш не будет вызивать ошибку когда ставиш его в конце/начале блока{} или после ; при переносе , но еще раз, смысла его ставить нету, тупо лишние символы которые при том вносят путаницу ))

     

  4. redking

    кстати, к вышеизложенному, в man awk по поводу <backslash>( \ , обратный слеш, бекслеш, обратная косая черта) и <newline>(перевод строки) кое что написанно:

    One convention that might not be obvious from the formal grammar is where <newline> characters are acceptable. There are several obvious placements such as terminating a statement, and a <backslash> can be used to escape <newline> characters between any lexical tokens. In addition, <newline> characters without <backslash> characters can follow a comma, an open brace, logical AND operator ("&&"), logical OR operator ("||"), the do keyword, the else keyword, and the closing parenthesis of an if, for, or while statement. For example:

    { print  $1,
             $2 }

    и там же, но чуть ниже:

    4. A <backslash> character immediately followed by a <newline> shall have no effect.

     

    п.с.

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

    1. Alexey (Автор записи)

      Спасибо за дополнения и разъяснение про области видимости bash и awk — теперь мне стало действительно понятно.

Добавить комментарий для redking Отменить ответ

Ваш адрес email не будет опубликован. Обязательные поля помечены *