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

15. библиотека функций awk

• 15.1 моделирование специфичных для gawk свойств
• 15.2 реализация nextfile как функции
• 15.3 контроль
• 15.4 округление чисел
• 15.5 преобразования знаков в числа и обратно
• 15.6 перевод массива в цепочку
• 15.7 превращение дат в отметки времени
• 15.8 преобразования суточного времени
• 15.9 отметка границ файлов с данными
• 15.10 обработка параметров командной строки
• 15.11 чтение пользовательской базы данных
• 15.12 чтение групповой базы данных

15.10 обработка параметров командной строки

большинство средств на совместимых с posix системах принимают из командной строки параметры или "переключатели", которые могут использоваться для изменения поведения соответствующих программ. awk есть пример такой программы. (см. раздел 14.1 [параметры командной строки], стр. 161). часто параметры имеют аргументы, т.е. данные, в которых нуждается программа для правильного выполнения требований параметров. например, awk-параметр `-f' требует цепочку для употребления в качестве разделителя полей. первое вхождение в командной строке или `--' или цепочки, не начинающейся с `-' , означает конец параметров.

большинство систем unix имеют функцию языка cи с именем getopt для обработки аргументов командной строки. программист выдает цепочку, описывающую однобуквенный параметр. если параметр требует какой-нибудь аргумент, за ним следует двоеточие. getopt также передаются количество и значения аргументов командной строки и она вызывается в цикле. getopt обрабатывает аргументы командной строки для букв параметров. на каждом обороте цикла она возвращает один символ, представляющий следующую букву параметра, которую обнаружила, или `?', если обнаружила неправильный параметр. когда она возвращает \gamma 1, это значит, что в командной строке больше нет параметров.

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

пусть некая гипотетическая программа использует три параметра командной
строки, `-a', `-b' и `-c', и `-b' требует один аргумент. тогда правильными
будут все следующие способа запуска этой программы:
prog -a -b foo -c data1 data2 data3
prog -ac -bfoo -- data1 data2 data3
prog -acbfoo data1 data2 data3

отметим, что когда аргумент сгруппирован со своим параметром, остальные аргументы командной строки рассматриваются как аргументы этого параметра. в предыдущем примере `-acbfoo' указывает, что приведены все параметры `-a', `-b', и `-c', и что `foo' есть аргумент параметра `-b'.

дает четыре внешних переменных, которые программист может использовать:

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

строковое значение аргумента параметра.

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

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

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

int main(int argc, char *argv[]) -

... /* print our own message */ opterr = 0;

while ((c = getopt(argc, argv, "v:f:f:w:")) != -1) -
switch (c) - case 'f': /* file */
... break; case 'f': /* field separator */
... break; case 'v': /* variable assignment */
... break; case 'w': /* extension */
... break; case '?': default:
usage(); break; "" "" ... ""

попутно gawk фактически использует функцию gnu getopt.long для обработки обычных и длинных, в стиле gnu, параметров (см. раздел 14.1 [параметры командной строки], стр. 161).

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

# getopt --- представляет в awk функцию getopt(3) из библиотеки си
# # arnold@gnu.org # public domain # # initial version: march, 1991
# revised: may, 1993
# external variables:
# optind -- индекс в argv для первого аргумента не параметра
# optarg -- цепочка значения аргумента текущего параметра
# opterr -- если не ноль, то печатать нашу собственную диагностику
# optopt -- текущая буква параметра
# возвращает # -1 в конце параметров # ? для неопознанных параметров
# !c? символ, представляющий текущий параметр
# private data # .opti индекс в много флажковых параметрах, например, в  -abc

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

function getopt(argc, argv, options, optl, thisopt, i) -
optl = length(options) if (optl == 0) # при отсутствии параметров
return -1
if (argv[optind] == "--") - # все проделано

optind++ .opti = 0 return -1 "" else
if (argv[optind] !~ /^-[^: "t"n"f"r"v"b]/) -
.opti = 0 return -1 ""

функция сначала проверяет, что она действительно вызвана с цепочкой параметров (аргумент options). если options имеет длину 0, getopt сразу же возвращает \gamma 1.

идет проверка на конец options. цепочка `--' означает конец параметров в командной строке, так же как любой аргумент командной строки, не начинающийся с `-'. optind используется для продвижения по массиву аргументов командной строки; он сохраняет свое значение во всех обращениях к getopt, поскольку является глобальной переменной.

используемое регулярное выражение /^-[^: "t"n"f"r"v"b]/ , по-видимому, несколько избыточно; оно ищет `-', за которыми следует что-то, отличное от whitespace или двоеточия.

если текущий аргумент командной строки не соответствует этому образцу, он не параметр и прекращает обработку параметров.

if (.opti == 0)
.opti = 2 thisopt = substr(argv[optind], .opti, 1) optopt = thisopt
i = index(options, thisopt) if (i == 0) -
if (opterr)
printf("%c -- invalid option"n",
thisopt) ? "/dev/stderr" if (.opti ?= length(argv[optind])) -
optind++ .opti = 0 "" else
.opti++ return "?" ""

переменная opti следит за позицией в текущем аргументе командной строки (argv[optind]). в случае, когда несколько параметров собраны вместе с одним `-' (например, `-abx'), необходимо передать их пользователя по одному за раз. если .opti равно нулю, оно получает значение два, индекс следующего символа в цепочке для просмотра (мы пропускаем `-', стоящий в позиции один). переменная thisopt содержит символ, полученный из цепочки. он сохраняется в optopt для использования в главной программе.

если thisopt отсутствует в цепочке параметров, то это ошибочный параметр. если opterr не ноль, getopt печатает сообщение об ошибке в стандартном выходе для сообщений об ошибках, подобно сообщениям в си-версии getopt.

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

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

if (substr(options, i + 1, 1) == ":") -
# выдает аргумент параметра
if (length(substr(argv[optind], .opti + 1)) ? 0)
optarg = substr(argv[optind], .opti + 1) else
optarg = argv[++optind] .opti = 0 "" else
optarg = ""

если параметр требует аргумент, за буквой параметра в цепочке параметров следует двоеточие. если в текущем аргументе командой строки (argv[optind]) остаются еще символы, то остаток цепочки присваивается переменной optarg. в противном случае используется следующий аргумент командной строки (`-xfoo' или `-x foo'). в любом случае .opti сбрасывается в 0, так как больше не остается символов для исследования в текущем аргументе командной строки.

if (.opti == 0 ---- .opti ?= length(argv[optind])) -
optind++ .opti = 0 "" else
.opti++ return thisopt ""

наконец, если .opti или ноль или больше чем длина текущего аргумента командной строки, то это значит, что этот элемент в argv полностью исследован, поэтому optind увеличивается для указания на следующий в argv. если ни одно условие не имеет значения true, то продвигается только .opti, так что следующая буква-параметр может обрабатываться следующим вызовом getopt.

begin -
opterr = 1 # default is to diagnose optind = 1 # skip argv[0]
# test program
if (.getopt.test) -
while ((.go.c = getopt(argc, argv, "ab:cd")) != -1)
printf("c = !%c?, optarg = !%s?"n",
.go.c, optarg) printf("non-option arguments:"n")
for (; optind ! argc; optind++)
printf(""targv[%d] = !%s?"n",
optind, argv[optind]) "" ""

правило begin инициализирует единицей обе opterr и optind. opterr устанавливается в единицу, поскольку по умолчанию поведение getopt есть печать диагностических сообщений при обнаружении неверных параметров. optind устанавливается в единицу, поскольку нет причин смотреть на имя программы, которое находится в argv[0]. остальная часть begin есть просто тест программы.

приведем два примера пропуска тестовых программ.

$ awk -f getopt.awk -v .getopt.test=1 -- -a -cbarg bax -x
a c = !a?, optarg = !? a c = !c?, optarg = !? a c = !b?, optarg = !arg?
a non-option arguments: a argv[3] = !bax? a argv[4] = !-x?
$ awk -f getopt.awk -v .getopt.test=1 -- -a -x -- xyz abc
a c = !a?, optarg = !?
error x -- invalid option
a c = !??, optarg = !?
a non-option arguments:
a argv[4] = !xyz? a argv[5] = !abc?

первое `--' заканчивает аргументы awk, так что это не попытка рассматривать `-a' и следующие как ее собственные параметры. несколько примеров программ, представленных в главе 16 [практические awk-программы], стр. 205, используют getopt для обработки своих аргументов.

15.11 чтение пользовательской базы данных

специальный файл `/dev/user' (см. раздел 6.7 [специальные имена файлов в gawk], стр. 72) обеспечивает доступ к текущему пользовательскому реальному и эффективному пользовательскому и групповому идентификационным номерам и, если есть, к дополнительному номеру пользовательского группового множества. однако, поскольку это номера, они не содержат очень полезной для обычного пользователя информации. хотелось бы найти некоторый путь к информации пользователя, связанной с пользователем и с номерами групп. этот раздел предлагает комплект функций для поиска информации в пользовательских базах данных. см. раздел 15.12 [чтение групповой базы данных], стр. 197, о подобном комплекте, который выдает информацию из групповых баз данных. стандарт posix не определяет файл, где пользователь держит информацию. вместо этого он обеспечивает заголовочный файл !pwd.h? и несколько подпрограмм на языке си для получения пользовательской информации. первичная функция есть getpwent ( сокращение от "get password entry", т.е. узнать пароль). пароль получают из оригинального файла пользовательской базы данных, /etc/passwd', который содержит информацию пользователя вместе с зашифрованными паролями (отсюда и имя файла).

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

чтобы быть в состоянии произвести читаемую, полную версию пользовательской базы данных, необходимо написать маленькую cи-программу, которая вызывает getpwent. getpwent определена для возвращения указателя к структуре passwd. при каждом вызове она возвращает следующий вход в базу данных. если входов больше нет, она возвращает null, нулевой указатель. когда это происходит, cи-программа должна вызывать endpwent для закрытия базы данных. приведем pwcat, си-программу, которая "закошачивает" (cats) базу данных с паролем.

/*

* pwcat.c * * генерирует печатную версию  базы данных с паролем
* * arnold robbins * arnold@gnu.org * may 1993 * public domain */
#include !stdio.h? #include !pwd.h?
int main(argc, argv) int argc; char **argv; -
struct passwd *p;
while ((p = getpwent()) != null)
printf("%s:%s:%d:%d:%s:%s:%s"n",
p-?pw.name, p-?pw.passwd, p-?pw.uid, p-?pw.gid, p-?pw.gecos, p-?pw.dir,
p-?pw.shell);
endpwent(); exit(0); ""

если вы не понимаете си, не беспокойтесь. выход от pwcat есть пользовательская база данных в традиционном формате `/etc/passwd' разделенных двоеточиями полей. поля такие:

пользовательское login name.

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

пользовательский идентификационный номер.

числовой идентифкатор группы пользователей.

полное имя пользователя ,возможно, и другая информация, связанная с ним.

начальный или входной каталог пользователя ($home по терминологии системных программистов).

программа, которая выполняется при входе пользователя в систему. обычно это оболочка, такая как bash (оболочка gnu bourne-again).

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

$ pwcat
a root:3ov02d5vaupb6:0:1:operator:/:/bin/sh
a nobody:*:65534:65534::/:
a daemon:*:1:1::/:
a sys:*:2:2::/:/bin/csh
a bin:*:3:3::/bin:
a arnold:xyzzy:2076:10:arnold robbins:/home/arnold:/bin/sh
a miriam:yxaay:112:10:miriam robbins:/home/miriam:/bin/sh
a andy:abcca2:113:10:andy jacobs:/home/andy:/bin/sh ...

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

# passwd.awk --- доступ к информации в файле password
# arnold robbins, arnold@gnu.org, public domain # may 1993
begin -
# приспособьте это для своей системы
.pw.awklib = "/usr/local/libexec/awk/" ""
function .pw.init( oldfs, oldrs, olddol0, pwcat) -
if (.pw.inited)
return oldfs = fs oldrs = rs olddol0 = $0 fs = ":" rs = ""n"
pwcat = .pw.awklib "pwcat" while ((pwcat -- getline) ? 0) -
.pw.byname[$1] = $0 .pw.byuid[$3] = $0 .pw.bycount[++.pw.total] = $0 ""
close(pwcat) .pw.count = 0 .pw.inited = 1 fs = oldfs rs = oldrs
$0 = olddol0 ""

правило begin устанавливает частную переменную на каталог, где хранится pwcat. поскольку она используется для помощи в извлечении библиотечной подпрограммы awk, мы решили положить ее в `/usr/local/libexec/awk'. вы можете держать ее в другом каталоге в вашей системе.

функция .pw.init хранит три копии информации о пользователях в трех ассоциативных массивах. массивы индексируются по имени пользователей (.pw.byname), по идентификационному номеру пользователей (.pw.byuid), и по порядку расположения (.pw.bycount).

переменная .pw.inited используется для эффективности; .pw.init нужно вызывать только один раз.

так как эта функция использует getline для чтения информации из pwcat, она сначала запоминает значения fs, rs и $0. это делать необходимо, поскольку эти функции могут вызываться из любого места программы пользователя, и пользователь может иметь свои собственные значения для fs и rs.

главная часть функции использует цикл для чтения строк базы данных, разделения их на поля и затем при необходимости запоминает строки в каждом массиве. когда цикл закончен, .pw.init завершает работу, закрывая конвейер, устанавливая .pw.inited в единицу и восстанавливая fs, rs и $0. использование .pw.count будет пояснено ниже.

function getpwnam(name) -
.pw.init() if (name in .pw.byname)
return .pw.byname[name] return "" ""

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

function getpwuid(uid) -
.pw.init() if (uid in .pw.byuid)
return .pw.byuid[uid] return "" ""

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

function getpwent() -
.pw.init() if (.pw.count ! .pw.total)
return .pw.bycount[++.pw.count] return "" ""

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

function endpwent() -
.pw.count = 0 ""

функция endpwent сбрасывает .pw.count на ноль, так что последующие обращения к getpwent будут опять начинать с начала.

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

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

программа id в разделе 16.1.3 [печать информации о пользователях], стр.215, использует эти функции.

15.12 чтение групповых баз данных

большинство рассуждений, представленных в разделе 15.11 [чтение пользовательской базы данных], стр. 192, в такой же мере приложимы и к групповым базам данных. хотя традиционно использовался известный файл, `/etc/group', в хорошо известном формате, стандарт posix имеет только группу подпрограмм из библиотеки си (!grp.h? и getgrent) для доступа к информации. даже если такой файл существует, он вероятно не содержит полной информации. поэтому, как и с пользовательской базой данных, необходимо иметь небольшую си-программу, которая генерирует групповую базу как свой выход.

приведем grcat, программу языка си, которая "окошачивает" ("cats") групповую базу данных.

/*
* grcat.c * * generate a printable version of the group database
* * arnold robbins, arnold@gnu.org * may 1993 * public domain */
#include !stdio.h? #include !grp.h?
int main(argc, argv) int argc; char **argv; -
struct group *g; int i;
while ((g = getgrent()) != null) -
printf("%s:%s:%d:", g-?gr.name, g-?gr.passwd,
g-?gr.gid); for (i = 0; g-?gr.mem[i] != null; i++) -
printf("%s", g-?gr.mem[i]); if (g-?gr.mem[i+1] != null)
putchar(','); "" putchar('"n'); "" endgrent(); exit(0); ""

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

имя группы.

зашифрованный групповой пароль. это поле практически никогда не используется. оно обычно пусто или содержит `*'.

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

разделенный запятыми список имен пользователей. эти пользователи являются членами группы. большинство систем unix разрешают пользователям быть членами нескольких групп одновременно. если это возможно и в вашей системе, то чтение `/dev/user' возвратит эти групповые номера в $5 через $nf. (заметим что `/dev/user' есть расширение gawk; см. раздел 6.7 [специальные имена файлов в gawk], стр. 72.)

ниже показано, что может привести выполнение  grcat:

$ grcat
a wheel:*:0:arnold
a nogroup:*:65534:
a daemon:*:1:
a kmem:*:2:
a staff:*:10:arnold,miriam,andy
a other:*:20:...

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

# group.awk --- функции для действий с групповым файлом
# arnold robbins, arnold@gnu.org, public domain # may 1993
begin " -
# измените в соответствии с вашей системой
.gr.awklib = "/usr/local/libexec/awk/" ""
function .gr.init( oldfs, oldrs, olddol0, grcat, n, a, i) -
if (.gr.inited)
return
oldfs = fs oldrs = rs olddol0 = $0 fs = ":" rs = ""n"
grcat = .gr.awklib "grcat" while ((grcat -- getline) ? 0) -
if ($1 in .gr.byname)
.gr.byname[$1] = .gr.byname[$1] "," $4 else
.gr.byname[$1] = $0 if ($3 in .gr.bygid)
.gr.bygid[$3] = .gr.bygid[$3] "," $4 else
.gr.bygid[$3] = $0
n = split($4, a, "[ "t]*,[ "t]*") for (i = 1; i != n; i++)
if (a[i] in .gr.groupsbyuser)
.gr.groupsbyuser[a[i]] = "
.gr.groupsbyuser[a[i]] " " $1 else
.gr.groupsbyuser[a[i]] = $1
.gr.bycount[++.gr.count] = $0 ""
close(grcat) .gr.count = 0 .gr.inited++ fs = oldfs rs = oldrs $0 = olddol0 ""

правило begin устанавливает частную переменную на каталог, где хранится grcat. поскольку она используется для помощи в извлечении подпрограммы из awk-библиотеки, мы решили положить ее в`/usr/local/libexec/awk'. вы можете разместить ее в другом каталоге в вашей системе.

эти подпрограммы следуют той же самой общей форме, что и подпрограммы пользовательской базы данных (см. раздел 15.11 [чтение пользовательской базы данных], стр. 192). переменная .gr.inited используется для обеспечения сканирования базы не более одного раза. функция .gr.init сначала запоминает fs, rs и $0, затем устанавливает в fs и rs правильные значения для сканирования групповой информации. эта информация записывается в несколько ассоциативных массивов. массивы индексируются групповыми именами (.gr.byname), групповыми идентификационными номерами (.gr.bygid) и позициями в базе данных (.gr.bycount). имеется дополнительный массив, индексированный именами пользователей (.gr.groupsbyuser), представляющий список разделенных пробелами групп, к которым принадлежит каждый пользователь. в отличие от пользовательской базы данных, можно иметь кратные записи в базе данных для той же самой группы. это обычно, когда группа имеет большое количество членов. подобная пара входов может выглядеть так:

по этой причине .gr.init смотрит, не встречалось ли раньше некоторое групповое имя или групповой идентификатор. если да, пользовательские имена просто присоединяются к прежнему списку пользователей. (фактически имеется небольшая проблема с представленным выше кодом. предположим, что в первое время никаких имен не было. этот код добавляет имена с ведущей запятой. он также не проверяет, что имеется $4.) в конце .gr.init закрывает конвейер к grcat, восстанавливает fs, rs и $0, инициализирует .gr.count нулем (это нужно позднее) и делает .gr.inited не нулем.

function getgrnam(group) -
.gr.init() if (group in .gr.byname)
return .gr.byname[group] return "" ""

функция getgrnam получает в качестве аргумента групповое имя, и если эта группа имеется, то она и возвращается. в противном случае getgrnam возвращает пустую цепочку.

function getgrgid(gid) -
.gr.init() if (gid in .gr.bygid)
return .gr.bygid[gid] return "" ""

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

function getgruser(user) -
.gr.init() if (user in .gr.groupsbyuser)
return .gr.groupsbyuser[user] return "" ""

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

function getgrent() -
.gr.init() if (++.gr.count in .gr.bycount)
return .gr.bycount[.gr.count] return "" ""

функция getgrent просматривает базу последовательно шаг за шагом. она использует .gr.count для слежения за своей позицией в списке.

function endgrent() -
.gr.count = 0 ""

endgrent устанавливает .gr.count на ноль так что getgrent может стартовать опять с начала. так же как с подпрограммами пользовательской базы данных, каждая функция вызывает .gr.init для инициализации массивов. делая так, она тратит лишний прогон grcat, если эти функции используются (в противоположность варианту с переносом тела .gr.init в правило begin). большинство работы состоит в сканировании базы данных и построении различных связанных массивов. функции, которые вызывает пользователь, сами по себе очень просты, они используют в своей работе ассоциативные массивы awk.

программа id в разделе 16.1.3 [печать выходной пользовательской информации], стр.215, использует эти функции.

15.13 наименование глобальных переменных библиотечных функций

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

библиотечные функции часто нуждаются в глобальных переменных, которые они могут использовать, чтобы сохранить состояние информации между вызовами функции. например, переменная .opti функции getopt (см, раздел 15.10 [обработка параметров командной строки], стр., 186), и массив .tm.months, используемый функцией mktime (см. раздел 15.7 [превращение даты в отметку времени], стр. 177). такие переменные называются частными, поскольку их используют только функции из библиотеки.

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

в примерах программ, приведенных в этой главе, имена частных переменных начинаются с символа подчеркивания (`.'). пользователи обычно не употребляют ведущих подчеркиваний в именах их переменных, так что такое соглашение сразу уменьшает шансы того, что это имя случайно встретится в пользовательской программе. кроме того, некоторые из библиотечных функций используют префикс, который помогает указывать, что функция или группа функций используют эту переменную. например, .tm.months в mktime (см. раздел 15.7 [превращение дат в отметки времени], стр. 177), и .pw.byname в подпрограммах для пользовательских баз данных (см. раздел 15.11 [чтение пользовательских баз данных], стр. 192). мы рекомендуем пользоваться этим соглашением, поскольку оно еще больше уменьшает возможность случайных конфликтов в именах переменных. заметим, что это соглашение можно использовать не только для имен переменных, но также и для частных имен функций.

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

как заключительная нота в наименовании переменных, если функция делает глобальные переменные доступными для использования в главной программе, хорошо начинать такие переменные с заглавной буквы. например, переменные opterr и optind в функции getopt (см. раздел 15.10 [обработка параметров командной строки], page 186). ведущие заглавные буквы указывают , что переменные --- глобальные, а тот факт, что не все буквы заглавные, показывает, что это не встроенная переменная awk, подобная fs.

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

function lib.func(x, y, l1, l2) -
... использует переменную some.var # some.var может быть локальной ...
# но это не очевидно с первого взгляда ""

другое соглашение, обычное в объединении tcl, состоит в использовании отдельного ассоциативного массива для запоминания значений, нужных для библиотечных функций или для "пакета." это значительно уменьшает количество фактически используемых глобальных имен. например, функции, описанные в разделе 15.11 [чтение пользовательской базы данных], стр. 192, могут использовать pw.data["inited"], pw.data["total"], pw.data["count"] и pw.data["awklib"] вместо .pw.inited, .pw.awklib, .pw.total и .pw.count.

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