В статье я планирую делиться полезными примерами, которые помогают мне решать повседневные задачи и значительно упрощают использование командной строки. Для тех, кто ещё не знаком с AWK, рекомендую обязательно освоить этот скриптовый язык, сложного в нем ничего нет. Каждый пример я планирую сопровождать небольшими комментариями, проливающими свет на нюансы использования тех или иных операторов.
.
Ищем строку с параметром bind-address в конфигурационном файле.
root@debian:~# awk ‘/bind-address/’ /etc/mysql/my.cnf
bind-address = 127.0.0.1
bind-address = 192.168.1.110
Пояснения: AWK имеет следующий синтаксис и опции.
awk
[-f файл_программы | ‘программа’] [-Fразделитель]
[-v переменная=значение] [файл …]
−F
value — определяет разделитель (устанавливает значение встроенной переменно FS);
−f
file — текст программы считывается из файла, вместо командной линии. Поддерживается чтение из множества файлов;
−v
var=value — присвоение переменной необходимого значения;
−−
— обозначает окончания списка опций.
В примере выше поиск осуществляется в файле, но AWK также может принимать вывод другой команды. Попробуем соответствующим образом усложнить наш пример.
root@debian-wordpress:~# cat /etc/mysql/my.cnf | awk ‘/bind-address/’
bind-address = 127.0.0.1
bind-address = 192.168.1.110
Как можно увидеть, результат вывода остался точно таким же, хотя конструкция конечно же усложнилась. Надо сказать в этом примере не совсем целесообразно использовать второй вариант, поскольку он сложнее. Попробуем рассмотреть другие ситуации, где использование подобной конструкции будет оправдано.
Вывести список символьных ссылок и путей к конечным файлам.
root@debian:~# ls -l /bin/ | awk ‘/lrwxrwxrwx/ { print $9, $10, $11}’
bzcmp -> bzdiff
bzegrep -> bzgrep
bzfgrep -> bzgrep
bzless -> bzmore
lessfile -> lesspipe
lsmod -> kmod
mt -> /etc/alternatives/mt
nc -> /etc/alternatives/nc
netcat -> /etc/alternatives/netcat
open -> openvt
pidof -> /sbin/killall5
rbash -> bash
rnano -> nano
sh -> dash
sh.distrib -> dash
Пояснения: программа awk представляет из себя пару шаблона (pattern ) и действия ({ action } ), а также определений пользовательских функций. Шаблон и действие имеют следующий вид: шаблон { действие } Шаблон либо действие может быть опущено. В первом случае действие будет выполняться к каждой строке, во втором будет осуществляться обычный вывод на экран, эквивалентный команде { print } . Эти ключевые слова нельзя сочетать с другими шаблонами .
Входная строка обычно состоит из полей, разделенных пробельными символами. (Эту настройку по умолчанию можно изменить с помощью встроенной переменной FS или опции -F разделитель .) Поля обозначаются $1, $2, …; $0 ссылается на всю строку в целом.
Исходя из информации выше, рассмотрим пример с изменением разделителя по умолчанию — просмотреть список всех пользователей без дополнительной информации.
root@debian:~# awk -F «:» ‘{ print $1 }’ /etc/passwd
root
daemon
bin
sys
sync
games
man
(Вывод команды сокращен)
Пояснения: поскольку в файле /etc/passwd записи хранятся в виде «root:x:0:0:root:/root:/bin/bash «, вполне логично разделителем выбрать двоеточие и вывести самое первое поле ($1 ) каждой строки ($0 ).
Все в том же файле с пользователями можно посчитать их количество.
root@debian:~# awk ‘END { print NR }’ /etc/passwd
25
Пояснения: Специальные шаблоны BEGIN и END можно использовать для получения управления перед чтением первой входной строки и после прочтения последней входной строки, соответственно.
Введение в замечательный язык со странным именем
В этой серии статей я собираюсь сделать из читателя искусного программиста на awk. Я согласен, что у awk не самое приятное и модное имя, а GNU-версия awk, названная gawk, звучит откровенно странно. Незнакомые с этим языком программисты, услышав его название, возможно, представят себе мешанину древнего и устаревшего кода, способного довести до умопомрачения даже самого знающего специалиста по UNIX (заставив его восклицать "kill -9!" и беспрестанно бегать за кофе).
Да, у awk отнюдь не замечательное имя. Но это замечательный язык. Awk создан для обработки текста и создания отчетов, но у него много хорошо проработанных функций, дающих возможность серьезного программирования. При этом, в отличие от некоторых других языков, синтаксис awk привычен и заимствует лучшее из таких языков, как C, python и bash (хотя формально awk был создан до python и bash). Awk - один из тех языков, которые, будучи один раз выучены, становятся ключевой частью стратегического арсенала программиста.
Давайте начнем и попробуем поэкспериментировать с awk, чтобы увидеть, как он работает. В командной строке введем следующую команду:
$ awk "{ print }" /etc/passwdВ результате должно быть показано содержимое файла /etc/passwd. Теперь - объяснение того, что делал awk. Вызывая awk, мы указали /etc/passwd в качестве входного файла. Когда мы запустили awk, он обработал команду print для каждой строки в /etc/passwd по порядку. Весь вывод отправлен в stdout, и мы получили результат, идентичный результату команды cat /etc/passwd. Теперь объясним блок { print } . В awk фигурные скобки используются для группирования блоков текста, как в C. В нашем блоке текста есть лишь одна команда print. В awk команда print без дополнительных параметров печатает все содержимое текущей строки.
Вот еще один пример программы на awk, которая делает то же самое:
$ awk "{ print $0 }" /etc/passwdВ awk переменная $0 представляет всю текущую строку, поэтому print и print $0 делают в точности одно и то же. Если угодно, можно создать программу на awk, которая будет выводить данные, совершенно не связанные с входными данными. Вот пример:
$ awk "{ print "" }" /etc/passwdПри передаче строки "" команде print она всегда печатает пустую строку. Если протестировать этот скрипт, обнаружится, что awk выводит одну пустую строку на каждую строку в файле /etc/passwd. Это опять-таки происходит потому, что awk исполняет скрипт для каждой строки во входном файле. Вот еще один пример:
$ awk "{ print "hiya" }" /etc/passwdЕсли запустить этот скрипт, он заполнит экран словами «ура». :)
Awk хорошо подходит для обработки текста, разбитого на множество логических полей, и дает возможность без усилий обращаться к каждому отдельному полю из awk-скрипта. Следующий скрипт распечатает список всех учетных записей в системе:
$ awk -F":" "{ print $1 }" /etc/passwdВ вызове awk в вышеприведенном примере параметр –F задает ":" в качестве разделителя полей. Обрабатывая команду print $1, awk выводит первое поле, встреченное в каждой строке входного файла. Вот еще один пример:
$ awk -F":" "{ print $1 $3 }" /etc/passwdВот фрагмент из вывода на экран этого скрипта:
halt7 operator11 root0 shutdown6 sync5 bin1 ....etc.Как видим, awk выводит первое и третье поля файла /etc/passwd, которые представляют собой соответственно поля имени пользователя и uid. При этом, хотя скрипт и работает, он не совершенен - нет пробелов между двумя выходными полями! Те, кто привык программировать в bash или python, возможно ожидали, что команда print $1 $3 вставит пробел между этими двумя полями. Однако когда в программе на awk две строки оказываются рядом друг с другом, awk сцепляет их без добавления между ними пробела. Следующая команда вставит пробел между полями:
$ awk -F":" "{ print $1 " " $3 }" /etc/passwdКогда print вызывается таким способом, он последовательно соединяет $1 , " " и $3 , создавая удобочитаемый вывод на экране. Конечно, мы можем также вставить метки полей, если нужно:
$ awk -F":" "{ print "username: " $1 "\t\tuid:" $3" }" /etc/passwdВ результате получаем такой вывод:
username: halt uid:7 username: operator uid:11 username: root uid:0 username: shutdown uid:6 username: sync uid:5 username: bin uid:1 ....etc.Передача скриптов в awk в виде аргументов командной строки может быть удобной для небольших однострочных текстов, но когда дело доходит до сложных многострочных программ, определенно будет лучше составить скрипт в виде внешнего файла. После этого можно указать awk этот скриптовый файл с помощью параметра -f:
$ awk -f myscript.awk myfile.inРазмещение скриптов в отдельных текстовых файлах также позволяет воспользоваться дополнительными преимуществами awk. Например, следующий многострочный скрипт делает то же самое, что и один из наших предыдущих однострочных - распечатывает первое поле каждой строки из /etc/passwd:
BEGIN { FS=":" } { print $1 }Разница между этими двумя методами состоит в том, как мы задаем разделитель полей. В этом скрипте разделитель полей указывается внутри самой программы (установкой переменной FS), тогда как в нашем предыдущем примере FS настраивается путем передачи awk параметра -F":" в командной строке. Обычно лучше всего задавать разделитель полей внутри самого скрипта, просто потому, что тогда не потребуется запоминать ещё один аргумент командной строки. Позже в этой статье мы рассмотрим переменную FS более подробно.
Обычно awk выполняет каждый блок в тексте скрипта один раз для каждой входной строки. Однако в программировании часто встречаются ситуации, когда требуется выполнить код инициализации перед тем, как awk начнет обрабатывать текст из входного файла. Для таких случаев awk дает возможность определять блок BEGIN. Мы использовали блок BEGIN в предыдущем примере. Поскольку блок BEGIN обрабатывается до того, как awk начинает обрабатывать входной файл, это отличное место для инициализации переменной FS (разделитель полей), вывода заголовка или инициализации других глобальных переменных, которые будут позже использоваться в программе.
Awk также предоставляет еще один специальный блок, называемый блоком END. Awk выполняет этот блок после того, как все строки во входном файле были обработаны. Обычно блок END используется для выполнения заключительных вычислений или вывода итогов, которые должны появиться в конце выходного потока.
Awk позволяет использовать регулярные выражения для избирательного выполнения отдельных блоков программы в зависимости от того, совпадает или нет регулярное выражение с текущей строкой. Вот пример скрипта, который выводит только те строки, которые содержат символьную последовательность foo:
/foo/ { print }Конечно, можно использовать более сложные регулярные выражения. Вот скрипт, который будет выводить только строки, содержащие число с плавающей точкой:
/+\.*/ { print }Есть много других способов избирательно выполнять блок программы. Мы можем поместить перед блоком программы любое булево выражение для управления исполнением этого блока. Awk будет выполнять блок программы, только если предыдущее булево выражение равно true. Следующий пример скрипта будет выводить третье поле всех строк, в которых первое поле равно fred . Если первое поле текущей строки не равно fred , awk продолжит обработку файла и не выполнит оператор print для текущей строки: :
$1 == "fred" { print $3 }Awk предлагает полный набор операторов сравнения, в том числе обычные "==", "<", ">", "<=", ">=" и "!=". Кроме того, awk предоставляет операторы "~" и "!~", которые означают "совпадает" и "не совпадает". При их использовании переменная помещается слева от оператора, а регулярное выражение - справа от него. Вот пример, где выводится только третье поле строки, если пятое поле той же строки содержит символьную последовательность root:
$5 ~ /root/ { print $3 }Awk предоставляет также очень приятные C-подобные операторы if. При желании можно переписать предыдущий скрипт с использованием if:
{ if ($5 ~ /root/) { print $3 } }Оба скрипта работают идентично. В первом примере булево выражение находится вне блока, в то время как во втором примере блок выполняется для каждой входной строки, и мы избирательно выполняем команду печати, используя оператор if Оба метода работают, и выбрать можно тот, который наилучшим образом объединяется с другими частями скрипта.
Вот более сложный пример оператора if в awk. Как можно видеть, даже в случае сложных вложенных условных выражений операторы if выглядят идентично их аналогам в C:
{ if ($1 == "foo") { if ($2 == "foo") { print "uno" } else { print "one" } } else if ($1 == "bar") { print "two" } else { print "three" } }Используя операторы if, мы можем преобразовать этот код:
! /matchme/ { print $1 $3 $4 } { if ($0 !~ /matchme/) { print $1 $3 $4 } }Оба скрипта распечатают только те строки, которые не содержат символьную последовательность matchme . И в этом случае тоже можно выбрать метод, который лучше работает в конкретной программе. Они оба делают одно и то же.
Awk также дает возможность использовать булевы операторы "||" ("логическое ИЛИ") и "&&"("логическое И"), что позволяет создавать более сложные булевы выражения:
($1 == "foo") && ($2 == "bar") { print }Этот пример выведет только те строки, в которых первое поле равно foo и второе поле равно bar .
До сих пор мы распечатывали либо строковые переменные, либо целые строки, либо конкретные поля. Однако awk также дает нам возможность выполнять сравнение как целых чисел, так и чисел с плавающей запятой. Используя математические выражения, очень легко написать скрипт, который считает число пустых строк в файле. Вот один такой скрипт:
BEGIN { x=0 } /^$/ { x=x+1 } END { print "Найдено " x " пустых строк. :)" }В блоке BEGIN мы инициализируем нашу целочисленную переменную x значением ноль. Затем каждый раз, когда awk встречает пустую строку, он будет выполнять оператор x=x+1 , увеличивая x на 1. После того как все строки будут обработаны, будет выполнен блок END, и awk выведет конечный итог, указав число найденных пустых строк.
Одной из приятных особенностей переменных awk является то, что они "простые и строчные." Я называю переменные awk "строчными", потому что все переменные awk внутри хранятся как строки. В то же время переменные awk "простые", потому что с переменной можно производить математические операции, и если она содержит правильную числовую строку, awk автоматически позаботится о преобразовании строки в число. Чтобы понять, что я имею в виду, взглянем на этот пример:
x="1.01" # Мы сделали так, что x содержит *строку* "1.01" x=x+1 # Мы только что прибавили 1 к *строке* print x # Это, кстати, комментарий:)Awk выведет:
2.01Любопытно! Хотя мы присвоили переменной x строковое значение 1.01, мы все же смогли прибавить к ней единицу. Нам бы не удалось сделать это в bash или python. Прежде всего, bash не поддерживает арифметику с плавающей запятой. И, хотя в bash есть "строчные" переменные, они не являются "простыми"; для выполнения любых математических операций bash требует, чтобы мы заключили наши вычисления в уродливые конструкции $() . Если бы мы использовали python, нам бы потребовалось явно преобразовать нашу строку 1.01 в значение с плавающей запятой, прежде чем выполнять какие-либо расчеты с ней. Хоть это и не трудно, но это все-таки дополнительный шаг. В случае с awk все это делается автоматически, и это делает наш код красивым и чистым. Если бы нам потребовалось возвести первое поле каждой входной строки в квадрат и прибавить к нему единицу, мы бы воспользовались таким скриптом:
{ print ($1^2)+1 }Если немного поэкспериментировать, то можно обнаружить, что если в какой-то переменной не содержится правильного числа, awk при вычислении математического выражения будет обращаться с этой переменной как с числовым нулем.
Еще одна приятная особенность awk - это полный комплект математических операторов. Кроме стандартных сложения, вычитания, умножения и деления, awk дает нам возможность использовать ранее продемонстрированный оператор показателя степени "^", оператор остатка целочисленного деления "%" и множество других удобных операторов присваивания, заимствованных из C.
К ним относятся пред- и постинкрементные/декрементные операторы присваивания (i++, --foo), операторы присваивания со сложением/вычитанием/умножением/делением (a+=3, b*=2, c/=2.2, d-=6.2). Но это ещё не все - мы имеем также удобные операторы присваивания с вычислением остатка целочисленного деления и возведением в степень (a^=2, b%=4).
В awk есть свой собственный комплект специальных переменных. Некоторые из них дают возможность тонкой настройки работы awk, а другие содержат ценную информацию о вводе. Мы уже затронули одну из этих специальных переменных, FS. Как упоминалось ранее, эта переменная позволяет задать последовательность символов, которую awk будет считать разделителем полей. Когда мы использовали в качестве ввода /etc/passwd, FS была установлена в ":". Это оказалось достаточно, но FS предоставляет нам еще большую гибкость.
Значение переменной FS не обязано быть одним символом; ей может быть присвоено регулярное выражение, задающее символьный шаблон любой длины. Если производится обработка полей, разделенных одним или несколькими символами табуляции, то FS нужно настроить таким образом:
FS="\t+"Выше мы использовали специальный символ регулярных выражений "+", который означает "одно или несколько вхождений предыдущего символа".
Если поля разделены пустой областью (один или несколько пробелов или символов табуляции), возможно, вам захочется установить для FS следующее регулярное выражение:
FS="[[:space:]+]"Хотя такая настройка сработает, в ней нет необходимости. Почему? Потому что по умолчанию значение FS равно одному символу пробела, который awk интерпретирует как "один или несколько пробелов или символов табуляции". В нашем конкретном примере значение FS по умолчанию именно такое, как нам было нужно!
Со сложными регулярными выражениями также не возникает проблем. Даже если записи разделены словом "foo", за которым следуют три цифры, следующее регулярное выражение позволит правильно разобрать данные:
FS="foo"Следующие две переменные, которые мы собираемся рассмотреть, обычно не предназначены для записи в них, а используются для чтения и получения полезной информации о вводе. Первая из них - переменная NF, называемая также "число полей". Awk автоматически устанавливает значение этой переменной равным числу полей в текущей записи. Можно использовать переменную NF для отображения только определенных входных строк:
NF == 3 { print "в этой записи три поля: " $0 }Конечно, переменную NF можно использовать и в условных операторах, например:
{ if (NF > 2) { print $1 " " $2 ":" $3 } }Еще одна удобная переменная - номер записи (NR). Она всегда содержит номер текущей записи (awk считает первую запись записью номер 1). До сих пор мы имели дело с входными файлами, которые содержали одну запись на строку. В таких ситуациях NR также сообщит номер текущей строки. Однако когда мы начнем обрабатывать многострочные записи в следующих статьях этой серии, это уже будет не так, поэтому нужно проявлять осторожность! NR можно использовать подобно переменной NF для вывода только определенных строк ввода:
(NR < 10) || (NR > 100) { print "Мы на записи номер 1-9 или 101 и более" }Еще один пример:
{ #skip header if (NR > 10) { print "вот теперь пошла настоящая информация!" } }Awk предоставляет дополнительные переменные, которые могут быть использованы для различных целей. Мы рассмотрим эти переменные в следующих статьях. Мы подошли к концу нашего начального исследования awk. В следующих статьях серии я покажу более сложную функциональность awk, и мы закончим эту серию awk-приложением из реальной практики. А пока, если хочется узнать больше, можно просмотреть ресурсы, перечисленные ниже.
НАЗВАНИЕ
awk - сопоставление с шаблонами и преобразование текста
СИНТАКСИС
Awk [-Fсимвол] [[-f] программа] [аргумент...] [файл...]
ОПИСАНИЕ
Команда awk сопоставляет строки исходных файлов с шаблонами, определенными в программе. Шаблоны можно задать
либо непосредственно в командной строке, либо поместить
в файл с именем программа и воспользоваться опцией -f.
Если шаблоны указаны в командной строке, их следует
заключить в одинарные кавычки ("), чтобы избежать интерпретации shell"ом.
Команде awk могут быть переданы аргументы в виде x=... y=... и т.д. (см. ПРИМЕРЫ).
Файлы читаются в том порядке, как они заданы. Если не указано ни одного файла или задано имя -, используется стандартный ввод. Ввод для awk делится на записи, разделяемые специальным символом. По умолчанию это перевод строки; в таком случае awk обрабатывает ввод построчно. Разделитель записей можно изменить, переопределив переменную RS. Каждая запись делится на поля, ограниченные разделителями полей (по умолчанию - пробелами). Этот разделитель можно изменить, переопределив переменную FS или указав флаг -Fсимвол. Поля исходных строк доступны по именам $1, $2,...; $0 - вся входная строка.
Для каждого шаблона из программы может быть задано действие, которое будет произведено со всякой строкой, успешно сопоставленной с шаблоном. Оператор шаблон-действие имеет вид:
Шаблон { действие } Каждая исходная строка сопоставляется с каждым из шаблонов; в случае успеха выполняются указанные действия. После сопоставления со всеми шаблонами вводится следующая строка и процесс сопоставления повторяется. Может быть опущен либо шаблон, либо действие, но не оба вместе. Если для данного шаблона не указаны действия, то строка просто копируется на стандартный вывод. Если для действия не определен шаблон, то оно будет выполняться для каждой входной строки. Строки, которые не удалось сопоставить ни одному шаблону, игнорируются.
Действие есть последовательность операторов. Так как шаблоны и действия могут быть опущены, то, чтобы различать их в программе, последние надо брать в фигурные скобки. Оператор есть одна из конструкций:
If (условие) оператор [ else оператор ] while (условие) оператор for (выражение; условие; выражение) оператор break continue { [ оператор ] ... } переменная = выражение print [ список_выражений ] [> выражение ] printf формат [, список_выражений ] [> выражение ] next # пропустить оставшиеся шаблоны и перейти к следующей строке exit # пропустить оставшиеся строки
Операторы завершаются точкой с запятой, переводом строки или правой скобкой. Пустой список_выражений означает всю строку. Выражения строятся из цепочек символов и чисел с помощью операций +, -, *, /, % и конкатенации (обозначается пробелом). В выражениях также можно использовать операции из языка C: ++, --, +=, -=, *=, /=, %=. Переменные инициализируются пустыми цепочками. Переменные могут быть скалярами, элементами массива (обозначается x[i]) или полями. Индексами массива могут служить любые (не обязательно числовые) цепочки символов, что позволяет реализовать разновидность ассоциативной памяти. Цепочки символов заключаются в двойные кавычки (").
Оператор print выдает свои аргументы на стандартный вывод (или в файл, если присутствует часть >выражение), разделяя их текущим разделителем полей и завершая каждую запись выходным разделителем записей. Оператор printf делает то же самое, но под управлением формата [см. printf(3S) ].
Встроенная функция length возвращает длину своего аргумента, рассматривая его как цепочку символов; если аргумент опущен, то возвращается длина текущей строки. Определены также следующие встроенные функции: exp, log, sqrt и int (int отбрасывает дробную часть своего аргумента). Функция substr(s, m, n) возвращает n-символьную подцепочку цепочки s, начинающуюся с позиции m. Функция sprintf(формат, выражение, выражение,...) преобразует выражения в соответствии с указанным форматом [см. printf(3S) ] и возвращает полученную цепочку символов.
Шаблон - это произвольная логическая комбинация, составленная с помощью операций!, ||, && и скобок из регулярных выражений и выражений сравнения. Регулярные выражения обрамляются символами / [подробнее см. egrep(1) ]. Отдельное регулярное выражение в шаблоне сопоставляется со всей строкой. Регулярные выражения могут входить и в выражения сравнения. Шаблон может состоять из двух шаблонов, разделенных запятой; при этом указанные действия выполняются для всех строк между строкой, удовлетворяющей первому шаблону, и строкой, удовлетворяющей второму шаблону.
Выражение сравнения - это одна из следующих конструкций:
Выражение опер_сопост регулярное_выражение выражение опер_сравн выражение
где опер_сравн - любая из шести операций сравнения языка C, опер_сопост это ~ (содержится) или!~ (не содержится).
Условие - это арифметическое выражение, выражение сравнения или их логическая комбинация.
Для выполнения каких-либо действий перед первой или после последней строки определены специальные шаблоны BEGIN и END. BEGIN должен быть первым шаблоном, END - последним. Например, для использования символа c в качестве разделителя полей можно либо запустить программу с опцией -Fc, либо указать
BEGIN { FS = c } Остальные специальные переменные: NF Количество полей в текущей записи. NR Порядковый номер текущей записи. FILENAME Имя файла, из которого в данный момент производится ввод. OFS Разделитель полей при выводе, по умолчанию пробел. ORS Разделитель записей при выводе, по умолчанию перевод строки. OFMT Формат вывода чисел, по умолчанию %.6g.
ПРИМЕРЫ
СМ. ТАКЖЕ
egrep(1) , lex(1) , sed(1) .
printf(3S) в Справочнике программиста.
СЮРПРИЗЫ
Входные пробелы не сохраняются при выводе, если поля
этой записи подвергались изменениям.
В языке команды awk отсутствуют явные преобразования между цепочками символов и числами. Чтобы выражение трактовалось как число, прибавьте к нему 0; чтобы трактовалось как цепочка - сконкатенируйте его с пустой цепочкой ""
04.10.2015
16:55
Утилита awk является примером классического приложения Linux для обработки текста. Она весьма универсальна и эффективна, хоть и не предоставляет полноценный язык программирования. Однако будьте уверены, что ее возможностей вполне хватит для решения многих задач автоматизированной обработки текста (особенно при комбинировании с другими консольными утилитами).
Если awk -программа достаточно простая и короткая, то ее код можно набрать прямо в консоли:
Awk "< код awk-программы >" < имя_файла_для_обработки >
В качестве входных данных для awk можно использовать не только текстовые файлы, но и вывод в стандартный поток других приложений:
< некое_приложение > | awk "< код awk-программы >"
В случае, когда код awk -программы достаточно объемный или должен быть сохранен для повторного использования, его можно вызывать из файла с ключом -f:
Awk -f < имя_файла_с_кодом_awk_программы > < имя_файла_для_обработки >
Для проведения экспериментов используем файл test.cpp , на котором будем проверять результаты работы awk - программ:
#include
В первую очередь awk позволяет отбирать строки из текста на основе регулярных выражений и некоторых числовых условий.
Например, чтобы получить все строки файла test.cpp , содержащие директиву препроцессора #include , воспользуемся следующей командой:
Awk "/^#\s*include/" test.cpp
Регулярное выражение записывается между двумя символами / . В результате получим:
#include
Чтобы оставить все строки, которые не соответствуют регулярному выражению, воспользуйтесь командой из предыдущего подраздела и поставьте в начало awk -кода восклицательный знак. Например, так мы исключим все закомментированные строки:
Awk "! /^[/]{2}.*/" test.cpp
Вот что осталось:
#include
Определить диапазон строк для вывода на экран можно с помощью двух регулярных выражений, записанных через запятую. В качестве примера найдем определение всех функций, возвращающих int:
Awk "/^int .*(.*) {/, /^}/" test.cpp
Соответствующий результат:
Int main(int argc, char** argv) { std::cout << "Hello, world!" << std::endl; for(int i = 0; i < 10; ++i) { std::cout << i << std::endl; } return 0; } int test2() { std::cout << "Hello, test2!" << std::endl; }
Для проверки строк сразу по нескольким условиям используйте операторы && (И) и || (ИЛИ) .
Следующая команда выводит все комментарии, которые не содержат main:
Awk "/[/]{2}.*/ && ! /main/" test.cpp
В итоге имеем:
// Комментарий в стиле С для функции test1() // Комментарий в стиле С для функции test2()
Ранее мы искали диапазон строк по двум регулярным выражениям, но если номера строк, которые нужно вывести, известные заранее, то все упрощается:
Awk "4 < NR && NR < 7" test.cpp
NR - переменная awk , которая определяет номер строки. Таким образом, представленный код выводит 5-ую и 6-ую строки:
Void test1(); int test2();
Awk может фильтровать текст не только по строкам, но и по отдельным словам. На i -ое слово в строке можно сослаться с помощью $i . Нумерация начинается с единицы, а $0 определяет содержимое всей строки. Количество слов в строке определяется с помощью переменной NF , поэтому $NF указывает на последнее слово. Например, найдем строки, первым словом которых является int или void:
Awk "$1 == "int" || $1 == "void"" test.cpp
Соответствующий вывод на консоль:
Void test1(); int test2(); int main(int argc, char** argv) { void test1() { int test2() {
Однако проще использовать проверку по регулярному выражению для слова. Для этого в awk предусмотрен специальный оператор ~ , который нужно поставить между переменной, указывающей на слово, и регулярным выражением. В качестве примера перепишем предыдущую команду в более компактном виде:
Awk "$1 ~ /int|void/" test.cpp
В awk доступны арифметические операторы языка C, что открывает свободу действий. Пример ниже выводит все четные строки (NR - номер строки):
Awk "NR % 2 == 0" test.cpp
Соответствующий вывод:
#include
Следующая awk -программа выводит все строки, у которых длина 1-ого слова равна трем:
Awk "length($1) == 3" test.cpp
В результате получаем:
Int test2(); int main(int argc, char** argv) { int test2() {
Awk "NF == 2" test.cpp
И соответствующий вывод:
#include
Как вы могли убедиться, awk обладает неплохим набором функций для фильтрации строк текста. Однако для этих строк еще можно выполнять различные преобразования. Команды для работы со строками должны быть обернуты в фигурные скобки { ... } . Код в скобках последовательно вызывается для каждой строки обрабатываемого текста.
В awk имеется прямой аналог функции printf() языка C . В качестве примера выведем в начале каждой строки ее номер:
Awk "{ printf "%-2d %s\n", NR, $0 }" test.cpp
Вот что получили:
1 #include
Кроме printf() есть в awk и другие функции. Например, print() и toupper() :
Awk "{ print toupper($0) }" test.cpp
Соответствующий результат:
#INCLUDE
В awk -программах доступны операторы if-else . Например, следующий код выводит без изменения строки, у которых на 1-ой позиции стоит int , а на последней - { , иначе на консоль отправляется --- :
Awk " { if($1 == "int" && $NF == "{") print; else print "---" }" test.cpp
Выполнение кода приводит к выводу следующего:
Int main(int argc, char** argv) { --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- int test2() { --- ---
Доступны в awk -программах и переменные, которые не требуется предварительно объявлять. Следующий код для подсчета количества строк и слов в тексте поместим в файл stat.awk:
{ lineCount++; wordCount += NF } END { printf "line count: %d, word count: %d\n", lineCount, wordCount }
Тогда его вызов осуществляется следующим образом:
Awk -f stat.awk test.cpp
Результат выполнения:
Line count: 27, word count: 88
Фильтр END указывает, что код в скобках после него должен выполняться только после прохода всех строк. Доступен в awk и фильтр BEGIN , поэтому в более общем случае программа принимает вид:
BEGIN { Вызывается до начала прохода по строкам } { Вызывается для каждой строки после секции BEGIN, но до секции END } END { Вызывается после завершения прохода по строкам }
Wc -lw test.cpp
В awk -программах вам также доступны циклы for и while в стиле C . Для примера выведем все строки в обратном порядке. Создадим файл reverse.awk следующего содержимого:
{ for(i = NF; i > 0; --i) printf "%s ", $i; printf "\n" }
Вызовем программу следующий образом:
Awk -f reverse.awk test.cpp
В результате слова в каждой строке будут выведены в обратном порядке:
По умолчанию awk в качестве разделителя слов использует пробельные символы, однако такое поведение можно изменить. Для этого воспользуйтесь ключом -F , после которого укажите строку, определяющую разделитель. Например, следующая программа выводит название группы и ее пользователей (если в группе есть пользователи) из файла /etc/group , применяя в качестве разделителя символ двоеточия:
Awk -F":" "{ if($4) printf "%15s: %s\n", $1, $4 }" /etc/group
Все рассмотренные ранее фильтры можно использовать совместно с командами обработки строк. Достаточно записать ограничения перед фигурными скобками. Ниже представлен пример для вывода первых 9 строк вывода команды ps , содержащей информацию о пользователе, идентификаторе процесса и имени команды:
Ps axu | awk "NR < 10 { print $1, $2, $NF }"
После запуска увидим:
USER PID COMMAND root 1 /sbin/init root 2 root 3 root 5 root 7 root 8 root 9 root 10
Текст это сердце Unix. Философия "все есть файл" полностью пронизывает всю систему и разработанные для нее инструменты. Вот почему работа
с текстом является одним из обязательных навыков системного администратора или начинающего пользователя Linux.
AWK - один из самых мощных инструментов для обработки и фильтрации текста, доступный даже для людей никак не связных с программированием.
Простейшая и часто востребованная задача - выборка полей из стандартного вывода. Вы не найдете более подходящего инструмента для решения этой задачи, чем awk. По умолчанию awk разделяет поля пробелами. Если вы хотите напечатать первое поле, вам нужно просто указать awk параметр $1:
echo "one two three four" | awk "{print $1}"
Да, использование фигурных скобок немного непривычно, но это только в первое время. Вы уже догадались как напечатать второе, третье, четвертое, или другие поля? Правильно это $2, $3, $4 соответственно.
echo "one two three four" | awk "{print $3}"
Иногда необходимо представить данные в определенном формате, например, выбрать несколько слов. AWK легко справляется с группировкой нескольких полей и даже позволяет включать статические данные:
echo "one two three four" | awk "{print $3,$1}"
three one
echo "one two three four" | awk "{print "foo:",$3,"| bar:",$1}"
foo: three | bar: one
Если поля разделены не пробелами, а другим разделителем, просто укажите в параметре -F нужный разделитель в ковычках, например ":" :
echo "one mississippi:two mississippi:three mississippi:four mississippi" | awk -F":" "{print $4}"
four mississippi
Но разделитель не обязательно заключать в ковычки. Следующий вывод аналогичен предыдущему:
echo "one mississippi:two mississippi:three mississippi:four mississippi" | awk -F: "{print $4}"
four mississippi
Иногда нужно обработать данные с неизвестным количеством полей. Если вам нужно выбрать последнее поле можно воспользоваться переменной $NF. Вот так вы можете вывести последнее поле:
echo "one two three four" | awk "{print $NF}"
four
Также вы можете использовать переменную $NF для получения предпоследнего поля:
echo "one two three four" | awk "{print $(NF-1)}"
three
Или поля с середины:
echo "one two three four" | awk "{print $((NF/2)+1)}"
three
echo "one two three four five" | awk "{print $((NF/2)+1)}"
three
Все это можно сделать с помощью таких утилит как sed, cut и grep но это будет намного сложнее.
И еще одна возможность awk, поддержка обработчиков для строк:
echo -e "one 1\n two 2" | awk "{print $1}"
one
two
echo -e "one 1\n two 2" | awk "{print $2}"
1
2
echo -e "one 1\n two 2" | awk "{sum+=$2} END {print sum}"
3
Это означает что мы должны выполнять следующий блок кода для каждой строки. Это можно использовать, например, для подсчета количества переданных данных по запросам из журнала веб-сервера.
Представьте себе, у нас есть журнал доступа, который выглядит так:
23 июля 18:57:12 HTTPD : "GET / Foo / бар HTTP / 1.1" 200 344
23 июля 18:57:13 HTTPD : "GET / HTTP / 1.1" 200 9300
23 июля 19:01:27 HTTPD : "GET / HTTP / 1.1" 200 9300
23 июля 19:01:55 HTTPD : "GET / Foo / Baz HTTP / 1.1" 200 6401
23 июля 19:02:31 HTTPD : "? GET / Foo / Baz страница = 2 HTTP / 1.1" 200 6312
Нам известно что последнее поле это число переданных байт, тогда мы можем использовать переменную $NF:
< requests.log awk "{print $NF}"
344
9300
9300
