Внутреннее устройство Linux

11. Введение в сценарии оболочки

Если вы можете вводить команды в оболочке, то это означает, что вы можете создавать сценарии оболочки (известные также как сценарии оболочки Bourne shell). Сценарий оболочки — это набор команд, записанных в файл. Оболочка считывает эти команды из файла так, словно вы вводите их в терминале.

11.1. Основы сценариев оболочки

Сценарии оболочки Bourne shell обычно начинаются с приведенной ниже строки, которая указывает на то, что инструкции в файле сценария должна выполнять команда /bin/sh. Убедитесь в том, что в начале файла сценария нет пробелов.

#!/bin/sh

Фрагмент #! (в англоязычных источниках он называется shebang) будет часто встречаться в других сценариях этой книги. Можно перечислить любые команды, исполнение которых вы желаете поручить оболочке, указав их после строки #!/bin/sh. Например, так:

#!/bin/sh

#

# Print something, then run ls

echo About to run the ls command.

ls

примечание

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

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

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

$ chmod +rx script

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

Преодолев основы, рассмотрим некоторые ограничения сценариев оболочки.

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

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

Наконец, следите за размером файлов ваших сценариев оболочки. Старайтесь делать сценарии короткими. Сценарии оболочки Bourne shell не должны быть огромными (хотя вам обязательно повстречаются некоторые монстры).

11.2. Кавычки и литералы

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

$ echo $100

00

Почему в результате появляется строка 00? Потому что оболочка увидела фрагмент $1, который является переменной оболочки (об этом вскоре пойдет речь). Вы могли бы решить, что, если поместить текст в кавычки, оболочка не заметит фрагмент $1. Но это также не срабатывает:

$ echo "$100"

00

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

$ echo '$100'

$100

Почему же сработало это волшебное слово?

11.2.1. Литералы

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

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

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

2. Оболочка передает команде результаты подстановок.

Проблемы, вызванные литералами, могут быть неуловимыми. Допустим, вы ищете все записи в файле /etc/passwd, соответствующие регулярному выражению r.*t (то есть такие строки, которые содержат символ r и чуть далее символ t; это могло бы позволить вам отыскать такие имена пользователей, как root, ruth и robot). Можно запустить такую команду:

$ grep r.*t /etc/passwd

В большинстве случаев она будет срабатывать, но иногда по непонятной причине давать сбой. Почему? Ответ заключен, вероятно, в вашем корневом каталоге. Если этот каталог содержит файлы с такими именами, как r.input и r.output, то тогда оболочка развернет выражение r.*t в r.input r.output и создаст такую команду:

$ grep r.input r.output /etc/passwd

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

11.2.2. Одинарные кавычки

Простейший способ создать литерал и сделать так, чтобы оболочка его не трогала, — поместить всю строку в одинарные кавычки, как в следующем примере с командой grep и символом *:

$ grep 'r.*t' /etc/passwd

Поскольку дело касается оболочки, все символы между двумя одинарными кавычками, включая пробелы, образуют единый параметр. Следовательно, приводимая ниже команда не будет работать, поскольку она просит команду grep выполнить поиск строки r.*t /etc/passwd в стандартном вводе (так как у команды grep здесь лишь один параметр):

$ grep 'r.*t /etc/passwd'

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

11.2.3. Двойные кавычки

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

$ echo "There is no * in my path: $PATH"

При запуске этой команды обратите внимание на то, что оболочка выполняет подстановку для переменной $PATH, но не заменяет символ *.

примечание

Если вы используете двойные кавычки при выводе больших объемов текста, попробуйте использовать синтаксис heredoc, как описано в разделе 11.9.

11.2.4. Передача одинарной кавычки в литерале

Хитрый момент при использовании литералов в оболочке Bourne shell возникает тогда, когда необходимо передать команде одинарную кавычку как литерал. Один из способов это выполнить — поместить символ обратной косой черты перед знаком одинарной кавычки:

$ echo I don\'t like contractions inside shell scripts.

Обратная косая черта и кавычка должны располагаться вне любой другой пары одинарных кавычек, поэтому строка наподобие 'don\'t вызовет синтаксическую ошибку. Как ни странно, но можно помещать одинарную кавычку внутри пары двойных кавычек, как показано в следующем примере (результат работы этой команды такой же, как и в предыдущем примере):

$ echo "I don't like contractions inside shell scripts."

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

1. Замените все экземпляры ' (одинарная кавычка) на '\'' (одинарная кавычка, обратная косая черта, одинарная кавычка, одинарная кавычка).

2. Заключите всю строку в одинарные кавычки.

Следовательно, такую неуклюжую строку, как this isn't a forward slash: \, можно поместить в кавычки следующим образом:

$ echo 'this isn'\''t a forward slash: \'

примечание

Стоит еще раз упомянуть о том, что при помещении строки в кавычки оболочка расценивает все, что находится внутри них, как единый параметр. Следовательно, символы a b c представляют три параметра, а символы a "b c" — только два.

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

Большинство сценариев оболочки понимает параметры командной строки и взаимодействует с запускаемыми командами. Чтобы перевести ваши сценарии с уровня простого перечня команд на уровень более гибких приложений для оболочки, вам необходимо знать о том, как использовать специальные переменные оболочки Bourne shell. Эти специальные переменные подобны любым другим переменным оболочки, как рассказано в разделе 2.8, за исключением того, что значения некоторых из них нельзя изменить.

примечание

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

11.3.1. Индивидуальные аргументы: $1, $2…

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

#!/bin/sh

echo First argument: $1

echo Third argument: $3

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

$ ./pshow one two three

First argument: one

Third argument: three

Встроенная в оболочку команда shift может быть использована с переменными-аргументами, чтобы удалить первый аргумент ($1) и сдвинуть все оставшиеся. Конкретнее, аргумент $2 превратится в $1, $3 — в $2 и т. д. Предположим, что файл следующего сценария называется shiftex:

#!/bin/sh

echo Argument: $1

shift

echo Argument: $1

shift

echo Argument: $1

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

$ ./shiftex one two three

Argument: one

Argument: two

Argument: three

Как видите, сценарий shiftex выводит все три аргумента: начинает с первого, сдвигает оставшиеся и повторяет вывод.

11.3.2. Количество аргументов: $#

Переменная $# хранит количество аргументов, переданных в сценарий, и особенно важна при циклическом запуске команды shift для выбора аргументов. Если значение $# равно 0, аргументов не остается, поэтому переменная $1 пустая (см. раздел 11.6, который содержит описание циклических структур).

11.3.3. Все аргументы: $@

Переменная $@ представляет все аргументы сценария и весьма полезна для передачи их команде внутри сценария. Например, команды Ghostscript (gs) обычно длинные и сложные. Допустим вам необходимо создать шаблон команды для растрирования файла PostScript с разрешением 150 dpi, используя стандартный поток вывода, но оставив при этом также возможность для передачи других параметров в команду gs. Для этих целей можно было бы написать сценарий, подобный приведенному ниже:

#!/bin/sh

gs — q -dBATCH — dNOPAUSE — dSAFER — sOutputFile=- sDEVICE=pnmraw $@

примечание

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

#!/bin/sh

gs — q -dBATCH — dNOPAUSE — dSAFER \

— sOutputFile=- sDEVICE=pnmraw $@

11.3.4. Имя сценария: $0

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

echo $0: bad option $BADPARM

Все диагностические сообщения об ошибках должны следовать в стандартную ошибку. Вспомните из подраздела 2.14.1 о том, что синтаксис 2>&1 перенаправляет стандартную ошибку в стандартный вывод. Для записи в стандартную ошибку можно обратить этот процесс с помощью синтаксиса 1>&2. Чтобы использовать его в предыдущем примере, примените такую строку:

echo $0: bad option $BADPARM 1>&2

11.3.5. Идентификатор процесса: $$

Переменная $$ хранит идентификатор процесса оболочки.

11.3.6. Код выхода: $?

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

11.4. Коды выхода

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

Оболочка хранит код выхода последней команды в специальной переменной $? поэтому его можно узнать из командной строки:

$ ls / > /dev/null

$ echo $?

0

$ ls /asdfasdf > /dev/null

ls: /asdfasdf: No such file or directory

$ echo $?

1

Вы видите, что успешно завершившая работу команда вернула значение 0, а команда с ошибкой вернула значение 1 (при условии того, что в вашей системе нет каталога /asdfasdf).

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

При написании кода для аварийного завершения работы сценария используйте что-нибудь типа exit 1, чтобы передать код выхода 1 родительскому процессу, который запустил этот сценарий. Можно применять разные числа для различных условий.

Следует отметить, что некоторые команды, подобные diff и grep, используют ненулевые коды выхода, чтобы сообщить о нормальных условиях. Например, команда grep возвращает значение 0, если она находит что-либо, совпадающее с шаблоном, и 1, если не находит. Для таких команд код выхода 1 не свидетельствует об ошибке; для настоящих проблем команды grep и diff применяют код выхода 2. Если вы подозреваете, что какая-либо команда использует ненулевой код выхода, чтобы сообщить об успешном завершении, прочитайте страницу руководства по этой команде. Коды выхода обычно разъясняются в разделах EXIT VALUE (Код выхода) или DIAGNOSTICS (Диагностика).

11.5. Условные операторы

В оболочке Bourne shell есть специальные конструкции для условных операторов, таких как if/then/else и case. Например, следующий простой сценарий с условным оператором if проверяет, является ли строка hi значением первого аргумента сценария:

#!/bin/sh

if [$1 = hi]; then

echo 'The first argument was "hi"'

else

echo — n 'The first argument was not "hi" — '

echo It was '"'$1'"'

fi

Слова if, then, else и fi в этом сценарии являются ключевыми словами оболочки; все остальное — команды. Такое разграничение чрезвычайно важно, так как в одной из команд, [$1 = "hi"], используется символ [, который представляет реальную команду Unix, а не специальный синтаксис оболочки. На самом деле это не вполне верно, но пока рассматривайте ее как отдельную команду. Во всех системах Unix есть команда [, которая выполняет проверку условных операторов сценария оболочки. Эта команда известна также как test. При тщательном исследовании команд [и test выясняется, что они совместно используют один и тот же дескриптор inode, то есть одна из них является символической ссылкой на другую.

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

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

2. Если код выхода равен 0, оболочка выполняет команды, которые следуют после ключевого слова then, и останавливается, когда доходит до ключевого слова else или fi.

3. Если код выхода не равен 0 и существует условие else, оболочка выполняет команды, расположенные после ключевого слова else.

4. Условный оператор заканчивается ключевым словом fi.

11.5.1. Немного о пустом списке параметров

Есть небольшая проблема в условном операторе из предыдущего примера, вызванная весьма распространенной ошибкой: переменная $1 может оказаться пустой, так как пользователь может не ввести параметр. При отсутствии параметра команда тестирования прочитает [= hi], и тогда команда [прервет исполнение, выдав ошибку. Этого можно избежать, если заключить параметр в кавычки одним из приведенных ниже способов (оба являются общепринятыми):

if ["$1" = hi]; then

if [x"$1" = x" hi"]; then

11.5.2. Использование других команд для проверки условий

Все, что следует после ключевого слова if, является командой. Следовательно, если вы желаете поместить в этой же строке ключевое слово then, необходимо применить точку с запятой (;) после команды проверки. Если вы опустите точку с запятой, оболочка передаст слово then команде проверки в качестве параметра. Если вам не нравится использование точки с запятой, можно поместить ключевое слово then в отдельной строке.

Существует множество возможностей применять другие команды вместо [. Вот пример, в котором использована команда grep:

#!/bin/sh

if grep — q daemon /etc/passwd; then

echo The daemon user is in the passwd file.

else

echo There is a big problem. daemon is not in the passwd file.

fi

11.5.3. Ключевое слово elif

Ключевое слово elif позволяет вам связать вместе условные операторы if, как показано ниже. Однако не слишком увлекайтесь использованием elif, так как конструкция case, о которой вы узнаете в подразделе 11.5.6, часто оказывается более подходящей.

#!/bin/sh

if ["$1" = "hi"]; then

echo 'The first argument was "hi"'

elif ["$2" = "bye"]; then

echo 'The second argument was "bye"'

else

echo — n 'The first argument was not "hi" and the second was not "bye" — '

echo They were '"'$1'"' and '"'$2'"'

fi

11.5.4. Логические конструкции && и ||

Существуют две простые однострочные конструкции, которые могут вам время от времени встречаться: && («и») и || («или»). Конструкция && устроена следующим образом:

command1 && command2

Здесь оболочка запускает команду command1, и если ее код выхода равен 0, оболочка запускает также и команду command2. Конструкция || подобна первой: если команда, расположенная перед символами ||, возвращает ненулевой код выхода, оболочка запускает вторую команду.

Конструкции && и || часто находят себе применение в проверках if, и в обоих случаях код выхода последней запущенной команды определяет то, как оболочка обработает условный оператор. В случае с конструкцией &&, если первая команда завершается неудачно, оболочка использует ее код выхода для инструкции if, но если первая команда завершена успешно, оболочка применяет для условного оператора код выхода второй команды. В случае с конструкцией || оболочка использует код выхода первой команды при ее успешном выполнении или код выхода второй команды, если первая завершила работу неудачно.

Например:

#!/bin/sh

if ["$1" = hi] || ["$1" = bye]; then

echo 'The first argument was "'$1'"'

fi

Если ваши условные операторы содержат команду проверки ([), как показано здесь, можно использовать символы — a и — o вместо конструкций && и ||, о чем рассказано в следующем разделе.

11.5.5. Проверка условий

Вы увидели, как работает команда [:, код выхода равен 0, если условие проверки истинно, и не равен 0, если проверка завершена неудачно. Вы знаете также, как проверить равенство строк с помощью команды [str1 = str2]. Помните о том, что сценарии оболочки хорошо приспособлены для операций с целыми файлами, поскольку наиболее полезные проверки с помощью команды [затрагивают свойства файлов. Например, следующая строка проверяет, является ли файл file обычным файлом (а не каталогом или специальным файлом):

[-f file]

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

for filename in *; do

if [-f $filename]; then

ls — l $filename

file $filename

else

echo $filename is not a regular file.

fi

done

Можно выполнить инверсию условия, поместив оператор! перед аргументами команды проверки. Например, условие [! —f file] возвращает значение true, если файл file не является обычным файлом. Кроме того, флаги — a и — o являются логическими операторами «и» и «или» (например, [-f file1 —a file2]).

примечание

Поскольку команда test так широко применяется в сценариях, во многих версиях оболочки Bourne shell (включая версию bash) эта команда является встроенной. Это может ускорить выполнение сценариев, так как оболочке не приходится для каждой проверки запускать отдельную команду.

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

Проверка файлов

Большинство проверок файлов, вроде — f, называется унарными операциями, поскольку им необходим только один аргумент: файл, который следует проверить. Вот две важные проверки файлов:

• — e — возвращает значение true, если файл существует;

• — s — возвращает значение true, если файл непyстой.

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

Таблица 11.1. Операторы проверки типа файла

Оператор

Условие проверки

— f

Обычный файл

— d

Каталог

— h

Символическая ссылка

— b

Блочное устройство

— c

Символьное устройство

— p

Именованный канал

— s

Сокет

примечание

Команда test отслеживает символические ссылки (кроме варианта — h), то есть если ссылка link является символической ссылкой на обычный файл, проверка [-f link] возвратит код выхода 0 (true).

Таблица 11.2. Операторы проверки прав доступа к файлу

Оператор

Оператор

— r

Для чтения

— w

Для записи

— x

Исполняемый

— u

Setuid

— g

Setgid

— k

«Закрепленный»

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

[file1 — nt file2]

Результатом будет значение true, если у файла file1 дата изменения более поздняя по сравнению с файлом file2. Оператор — ot («более ранний, чем») выполняет противоположную проверку. Если же вам необходимо установить идентичность жестких ссылок, оператор — ef позволяет сравнить два файла и выдать результат true, если такие файлы совместно используют одинаковые номера дескрипторов inode и устройства.

Проверка строк

Вы уже видели бинарный строковый оператор =, который возвращает значение true, если его операнды равны. Оператор!= возвращает значение true, если его операнды не равны. Вот еще два унарных строковых оператора:

• — z — возвращает значение true, если его аргумент пустой (условие [-z ""] возвратит значение 0);

• — n — возвращает значение true, если его аргумент непустой (условие [-n ""] возвратит значение 1).

Арифметическая проверка

Важно осознавать, что знак равенства (=) проверяет равенство строк, а не чисел. Следовательно, проверка [1 = 1] вернет результат 0 (true), однако проверка [01 = 1] возвратит false. При работе с числами используйте оператор — eq вместо знака равенства: проверка [01 —eq 1] вернет значение true. В табл. 11.3 приведен полный список операторов численного сравнения.

Таблица 11.3. Арифметические операции сравнения

Оператор

Возвращает значение true, если первый аргумент …

— eq

…равен второму

— ne

…не равен второму

— lt

…меньше второго

— gt

…больше второго

— le

…меньше второго или равен ему

— ge

…больше второго или равен ему

11.5.6. Сопоставление строк с помощью конструкции case

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

#!/bin/sh

case $1 in

bye)

echo Fine, bye.

;;

hi|hello)

echo Nice to see you.

;;

what*)

echo Whatever.

;;

*)

echo 'Huh?'

;;

esac

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

1. Сценарий сопоставляет значение переменной $1 с каждым из вариантов, который отделен с помощью символа).

2. Если какое-либо из значений совпадает со значением переменной $1, оболочка выполняет команды, расположенные под этим вариантом, пока не встретит символы;;, после которых она пропускает все остальное до ключевого слова esac.

3. Условный оператор завершается словом esac.

Для каждого варианта значений можно сопоставить единственную строку (подобно строке bye в приведенном примере) или же несколько строк, использовав оператор | (условие hi|hello возвращает значение true, если значение переменной $1 равно hi или hello). Можно также применять шаблоны * или? (what*). Чтобы определить условие по умолчанию, которое охватывает все возможные значения, отличающиеся от указанных, применяйте единственный символ *, как показано в последнем условии приведенного примера.

примечание

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

11.6. Циклы

В оболочке Bourne shell существуют два типа циклов: цикл for и цикл while.

11.6.1. Цикл for

Цикл for (который является циклом «для каждого») самый распространенный. Вот пример:

#!/bin/sh

for str in one two three four; do

echo $str

done

В этом листинге слова for, in, do и done — ключевые слова оболочки. Оболочка выполняет следующее.

1. Присваивает переменной str первое (one) из четырех значений, следующих после слова in и разделенных символами пробела.

2. Запускает команду echo, расположенную между словами do и done.

3. Возвращается к строке for, присваивает переменной str следующее значение (two), выполняет команды между словами do и done, а затем повторяет процесс до тех пор, пока не закончатся значения, следующие после ключевого слова in.

Результат работы этого сценария выглядит так:

one

two

three

four

11.6.2. Цикл while

Цикл while в оболочке Bourne shell использует коды выхода, подобно условному оператору if. Например, такой сценарий выполняет десять итераций:

#!/bin/sh

FILE=/tmp/whiletest.$$;

echo firstline > $FILE

while tail -10 $FILE | grep — q firstline; do

# add lines to $FILE until tail -10 $FILE no longer prints "firstline"

echo — n Number of lines in $FILE:' '

wc — l $FILE | awk '{print $1}'

echo newline >> $FILE

done

rm — f $FILE

Здесь проверяется код выхода команды grep — q firstline. Как только код выхода становится ненулевым (в данном случае, когда строка firstline не будет появляться в десяти последних строках файла $FILE), цикл завершается.

Можно выйти из цикла while с помощью инструкции break. В оболочке Bourne shell есть также цикл until, который действует подобно циклу while, за исключением того, что он завершается, когда встречает нулевой код выхода, а не код, не равный 0. Однако не следует использовать слишком часто циклы while и until. В действительности, если вам необходимо применить цикл while, возможно, лучше воспользоваться языком awk или Python.

11.7. Подстановка команд

Оболочка Bourne shell может перенаправлять стандартный вывод какой-либо команды обратно в командную строку оболочки. То есть можно использовать вывод команды в качестве аргумента для другой команды или же сохранить вывод команды в переменной оболочки, поместив команду внутрь выражения $().

Следующий пример сохраняет команду внутри переменной FLAGS. Жирным шрифтом во второй строке выделена подстановка команды.

#!/bin/sh

FLAGS=$(grep ^flags /proc/cpuinfo | sed 's/.*://' | head -1)

echo Your processor supports:

for f in $FLAGS; do

case $f in

fpu) MSG="floating point unit"

;;

3dnow) MSG="3DNOW graphics extensions"

;;

mtrr) MSG="memory type range register"

;;

*) MSG="unknown"

;;

esac

echo $f: $MSG

done

Данный пример достаточно сложен, поскольку он показывает возможность использования как одинарных кавычек, так и каналов внутри подстановки. Результат команды grep отправляется в команду sed (подробности см. в подразделе 11.10.3), которая удаляет все, что соответствует выражению.*:, а затем результат команды sed передается команде head.

Используя подстановку команд, очень легко сделать лишнее. Например, не применяйте в сценариях выражение $(ls), поскольку оболочка выполняет развертывание символа * быстрее. Кроме того, если вы желаете применить команду к нескольким именам файлов, которые вы получаете в результате работы команды find, попробуйте использовать канал для команды xargs, а не подстановку или же параметр — exec (см. подраздел 11.10.4).

примечание

Традиционный синтаксис для подстановки команды: размещение команды внутри «обратных черточек» (»). Такой вариант вы встретите во многих сценариях. Синтаксис $() является новой формой, которая следует стандарту POSIX, легче записывается и читается.

11.8. Управление временным файлом

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

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

#!/bin/sh

TMPFILE1=$(mktemp /tmp/im1.XXXXXX)

TMPFILE2=$(mktemp /tmp/im2.XXXXXX)

cat /proc/interrupts > $TMPFILE1

sleep 2

cat /proc/interrupts > $TMPFILE2

diff $TMPFILE1 $TMPFILE2

rm — f $TMPFILE1 $TMPFILE2

Аргумент команды mktemp является шаблоном. Команда mktemp превращает XXXXXX в уникальный набор символов и создает пустой файл с таким именем. Обратите внимание на то, что этот сценарий использует имена переменных для хранения имен файлов, поэтому, чтобы изменить имя файла, необходимо изменить всего одну строку.

примечание

Не все варианты Unux содержат команду mktemp. Если у вас возникнут проблемы с переносимостью, лучше установить GNU-пакет coreutils для вашей операционной системы.

Еще одна проблема сценариев, которые используют временные файлы, такова: если выполнение сценария будет прервано, временные файлы могут остаться в системе. В предыдущем примере, если нажать сочетание клавиш Ctrl+C до начала второй команды, то в каталоге /tmp останется временный файл. Избегайте этого по возможности. Старайтесь использовать команду trap для создания обработчика сигнала, который будет перехватывать сигнал от нажатия клавиш Ctrl+C и удалять временные файлы, как в этом примере:

#!/bin/sh

TMPFILE1=$(mktemp /tmp/im1.XXXXXX)

TMPFILE2=$(mktemp /tmp/im2.XXXXXX)

trap "rm — f $TMPFILE1 $TMPFILE2; exit 1" INT

— snip—

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

примечание

Не обязательно передавать аргументы команде mktemp. Если их нет, то шаблон будет начинаться с префикса /tmp/tmp.

11.9. Синтаксис heredoc

Допустим, вам необходимо вывести большой фрагмент текста или передать его другой команде. Чтобы не использовать несколько команд echo, можно применить синтаксис heredoc, как показано в следующем сценарии:

#!/bin/sh

DATE=$(date)

cat <