• Глава 18. Регулярные выражения
  • 18.1. Краткое введение в регулярные выражения
  • 18.2. Globbing -- Подстановка имен файлов
  • Глава 19. Подоболочки, или Subshells
  • Пример 19-1. Область видимости переменных
  • Пример 19-2. Личные настройки пользователей
  • Пример 19-3. Запуск нескольких процессов в подоболочках
  • Глава 20. Ограниченный режим командной оболочки
  • Пример 20-1. Запуск сценария в ограниченном режиме
  • Глава 21. Подстановка процессов
  • Глава 22. Функции
  • Пример 22-1. Простая функция
  • 22.1. Сложные функции и сложности с функциями
  • Пример 22-2. Функция с аргументами
  • Пример 22-3. Наибольшее из двух чисел
  • Пример 22-4. Преобразование чисел в римскую форму записи
  • Пример 22-6. Сравнение двух больших целых чисел
  • Пример 22-7. Настоящее имя пользователя
  • 22.2. Локальные переменные
  • Пример 22-8. Область видимости локальных переменных
  • 22.2.1. Локальные переменные делают возможной рекурсию.
  • Пример 22-9. Использование локальных переменных при рекурсии
  • Глава 23. Псевдонимы
  • Пример 23-1. Псевдонимы в сценарии
  • Пример 23-2. unalias: Объявление и удаление псевдонимов
  • Глава 24. Списки команд
  • Пример 24-1. Проверка аргументов командной строки с помощью "И-списка"
  • Пример 24-2. Еще один пример проверки аргументов с помощью "И-списков"
  • Пример 24-3. Комбинирование "ИЛИ-списков" и "И-списков"
  • Глава 25. Массивы
  • Пример 25-1. Простой массив
  • Пример 25-2. Форматирование стихотворения
  • Пример 25-3. Некоторые специфичные особенности массивов
  • Пример 25-4. Пустые массивы и пустые элементы
  • Пример 25-5. Копирование и конкатенация массивов
  • Пример 25-6. Старая, добрая: "Пузырьковая" сортировка
  • Пример 25-7. Вложенные массивы и косвенные ссылки
  • Пример 25-8. Пример реализации алгоритма Решето Эратосфена
  • Пример 25-9. Эмуляция структуры "СТЕК" ("первый вошел -- последний вышел")
  • Пример 25-10. Исследование математических последовательностей
  • Пример 25-11. Эмуляция массива с двумя измерениями
  • Глава 26. Файлы
  • Глава 27. /dev и /proc
  • 27.1. /dev
  • 27.2. /proc
  • Пример 27-1. Поиск файла программы по идентификатору процесса
  • Пример 27-2. Проверка состояния соединения
  • Глава 28. /dev/zero и /dev/null
  • Пример 28-1. Удаление cookie-файлов
  • Пример 28-2. Создание файла подкачки (swapfile), с помощью /dev/zero
  • Пример 28-3. Создание электронного диска
  • Глава 29. Отладка сценариев
  • Пример 29-1. Сценарий, содержащий ошибку
  • Пример 29-2. Пропущено ключевое слово
  • Пример 29-3. test24
  • Пример 29-4. Проверка условия с помощью функции "assert"
  • Пример 29-5. Ловушка на выходе
  • Пример 29-6. Удаление временного файла при нажатии на Control-C
  • Пример 29-7. Трассировка переменной
  • Глава 30. Необязательные параметры (ключи)
  • Глава 31. Широко распространенные ошибки
  • Пример 31-1. Западня в подоболочке
  • Пример 31-2. Передача вывода от команды echo команде read, по конвейеру
  • Глава 32. Стиль программирования
  • 32.1. Неофициальные рекомендации по оформлению сценариев
  • Глава 33. Разное
  • 33.1. Интерактивный и неинтерактивный режим работы
  • 33.2. Сценарии-обертки
  • Пример 33-1. сценарий-обертка
  • Пример 33-2. Более сложный пример сценария-обертки
  • Пример 33-3. Сценарий-обертка вокруг сценария awk
  • Пример 33-4. Сценарий на языке Perl, встроенный в Bash-скрипт
  • Пример 33-5. Комбинирование сценария Bash и Perl в одном файле
  • 33.3. Операции сравнения: Альтернативные решения
  • 33.4. Рекурсия
  • Пример 33-6. Сценарий (бесполезный), который вызывает себя сам
  • Пример 33-7. Сценарий имеющий практическую ценность), который вызывает себя сам
  • 33.5. "Цветные" сценарии
  • Пример 33-8. "Цветная" адресная книга
  • Пример 33-9. Вывод цветного текста
  • 33.6. Оптимизация
  • 33.7. Разные советы
  • Пример 33-10. Необычный способ передачи возвращаемого значения
  • Пример 33-11. Необычный способ получения нескольких возвращаемых значений
  • Пример 33-12. Передача массива в функцию и возврат массива из функции
  • Пример 33-13. Игры с анаграммами
  • 33.8. Проблемы безопасности
  • 33.9. Проблемы переносимости
  • 33.10. Сценарии командной оболочки под Windows
  • Глава 34. Bash, версия 2
  • Пример 34-1. Расширение строк
  • Пример 34-2. Косвенные ссылки на переменные -- новый метод
  • Пример 34-3. Простая база данных, с применением косвенных ссылок
  • Пример 34-4. Массивы и другие хитрости для раздачи колоды карт в четыре руки
  • Глава 35. Замечания и дополнения
  • 35.1. От автора
  • 35.2. Об авторе
  • 35.3. Инструменты, использовавшиеся при создании книги 35.3.1. Аппаратура
  • 35.3.2. Программное обеспечение
  • 35.4. Благодарности
  • Часть 4. Материал повышенной сложности

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

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

    Для того, чтобы полностью реализовать потенциал командной оболочки, вам придется овладеть Регулярными Выражениями. Многие команды и утилиты, обычно используемые в сценариях, такие как grep, expr, sed и awk, используют Регулярные Выражения.

    18.1. Краткое введение в регулярные выражения

    Выражение -- это строка символов. Символы, которые имеют особое назначение, называются метасимволами. Так, например, кавычки могут выделять прямую речь, т.е. быть метасимволами для строки, заключенной в эти кавычки. Регулярные выражения -- это набор символов и/или метасимволов, которые наделены особыми свойствами[ 46 ].

    Основное назначение регулярных выражений -- это поиск текста по шаблону и работа со строками.

    Звездочка -- * -- означает любое количество символов в строке, предшествующих "звездочке", в том числе и нулевое число символов.

    Выражение "1133*" -- означает 11 + один или более символов "3" + любые другие символы: 113, 1133, 113312, и так далее.

    Точка -- . -- означает не менее одного любого символа, за исключением символа перевода строки (\n)[ 47 ].

    Выражение "13." будет означать 13 + по меньшей мере один любой символ (включая пробел): 1133, 11333, но не 13 (отсутствуют дополнительные символы).

    Символ -- ^ -- означает начало строки, но иногда, в зависимости от контекста, означает отрицание в регулярных выражениях.

    Знак доллара -- $ -- в конце регулярного выражения соответствует концу строки.

    Выражение "^$" соответствует пустой строке.

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

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

    Выражение "[xyz]" -- соответствует одному из символов x, y или z.

    Выражение "[c-n]" соответствует одному из символов в диапазоне от c до n, включительно.

    Выражение "[B-Pk-y]" соответствует одному из символов в диапазоне от B до P или в диапазоне от k до y, включительно.

    Выражение "[a-z0-9]" соответствует одному из символов латиницы в нижнем регистре или цифре.

    Выражение "[^b-d]" соответствует любому символу, кроме символов из диапазона от b до d, включительно. В данном случае, метасимвол ^ означает отрицание.

    Объединяя квадратные скобки в одну последовательность, можно задать шаблон искомого слова. Так, выражение "[Yy][Ee][Ss]" соответствует словам yes, Yes, YES, yEs и так далее. Выражение "[0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9][0-9][0-9]" определяет шаблон для поиска любого номера карточки социального страхования (для США).

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

    Комбинация "\$" указывает на то, что символ "$" трактуется как обычный символ, а не как признак конца строки в регулярных выражениях. Аналогично, комбинация "\\" соответствует простому символу "\".

    Экранированные "угловые скобки" -- \<...\> -- отмечают границы слова.

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

    Выражение "\<the\>" соответствует слову "the", и не соответствует словам "them", "there", "other" и т.п.

    bash$ cat textfile

    This is line 1, of which there is only one instance.

    This is the only instance of line 2.

    This is line 3, another line.

    This is line 4.


    bash$ grep 'the' textfile

    This is line 1, of which there is only one instance.

    This is the only instance of line 2.

    This is line 3, another line.


    bash$ grep '\<the\>' textfile

    This is the only instance of line 2.


    Дополнительные метасимволы. Использующиеся при работе с egrep, awk и Perl

    Знак вопроса -- ? -- означает, что предыдущий символ или регулярное выражение встречается 0 или 1 раз. В основном используется для поиска одиночных символов.

    Знак "плюс" -- + -- указывает на то, что предыдущий символ или выражение встречается 1 или более раз. Играет ту же роль, что и символ "звездочка" (*), за исключением случая нулевого количества вхождений.

    # GNU версии sed и awk допускают использование "+",

    # но его необходимо экранировать.


    echo a111b | sed -ne '/a1\+b/p'

    echo a111b | grep 'a1\+b'

    echo a111b | gawk '/a1+b/'

    # Все три варианта эквивалентны.


    # Спасибо S.C.


    Экранированные "фигурные скобки" -- \{ \} -- задают число вхождений предыдущего выражения.

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

    Выражение "[0-9]\{5\}" -- в точности соответствует подстроке из пяти десятичных цифр (символов из диапазона от 0 до 9, включительно).

    В "классической" (не совместимой с POSIX) версии awk, фигурные скобки не могут быть использованы. Однако, в gawk предусмотрен ключ --re-interval, который позволяет использовать (неэкранированные) фигурные скобки.

    bash$ echo 2222 | gawk --re-interval '/2{3}/'

    2222


    Язык программирования Perl и некоторые версии egrep не требуют экранирования фигурных скобок.

    Круглые скобки -- ( ) -- предназначены для выделения групп регулярных выражений. Они полезны при использовании с оператором "|" и при извлечении подстроки с помощью команды expr.

    Вертикальная черта -- | -- выполняет роль логического оператора "ИЛИ" в регулярных выражениях и служит для задания набора альтернатив.

    bash$ egrep 're(a|e)d' misc.txt

    People who read seem to be better informed than those who do not.

    The clarinet produces sound by the vibration of its reed.


    Некоторые версии sed, ed и ex поддерживают экранированные версии регулярных выражений, описанных выше.

    Классы символов POSIX. [:class:]

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

    Класс [:alnum:] -- соответствует алфавитным символам и цифрам. Эквивалентно выражению [A-Za-z0-9].

    Класс [:alpha:] -- соответствует символам алфавита. Эквивалентно выражению [A-Za-z].

    Класс [:blank:] -- соответствует символу пробела или символу табуляции.

    Класс [:cntrl:] -- соответствует управляющим символам (control characters).

    Класс [:digit:] -- соответствует набору десятичных цифр. Эквивалентно выражению [0-9].

    Класс [:graph:] (печатаемые и псевдографические символы) -- соответствует набору символов из диапазона ASCII 33 - 126. Это то же самое, что и класс [:print:], за исключением символа пробела.

    Класс [:lower:] -- соответствует набору алфавитных символов в нижнем регистре. Эквивалентно выражению [a-z].

    Класс [:print:] (печатаемые символы) -- соответствует набору символов из диапазона ASCII 32 - 126. По своему составу этот класс идентичен классу [:graph:], описанному выше, за исключением того, что в этом классе дополнительно присутствует символ пробела.

    Класс [:space:] -- соответствует пробельным символам (пробел и горизонтальная табуляция).

    Класс [:upper:] -- соответствует набору символов алфавита в верхнем регистре. Эквивалентно выражению [A-Z].

    Класс [:xdigit:] -- соответствует набору шестнадцатиричных цифр. Эквивалентно выражению [0-9A-Fa-f].

    Вообще, символьные классы POSIX требуют заключения в кавычки или двойные квадратные скобки ([[ ]]).

    bash$ grep [[:digit:]] test.file

    abc=723


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

    bash$ ls -l ?[[:digit:]][[:digit:]]?

    -rw-rw-r-- 1 bozo bozo 0 Aug 21 14:47 a33b


    Примеры использования символьных классов в сценариях вы найдете в Пример 12-14 и Пример 12-15.

    Sed, awk и Perl, используемые в сценариях в качестве фильтров, могут принимать регулярные выражения в качестве входных аргументов. См. Пример A-13 и Пример A-19.

    Книга "Sed & Awk" (авторы Dougherty и Robbins) дает полное и ясное представление о регулярных выражениях (см. раздел Литература).


    18.2. Globbing -- Подстановка имен файлов

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

    Фактически, Bash может выполнять подстановку имен файлов, этот процесс называется "globbing", но при этом не используется стандартный набор регулярных выражений. Вместо этого, при выполнении подстановки имен файлов, производится распознавание и интерпретация шаблонных символов. В число интерпретируемых шаблонов входят символы * и ?, списки символов в квадратных скобках и некоторые специальные символы (например ^, используемый для выполнения операции отрицания). Применение шаблонных символов имеет ряд важных ограничений. Например, если имена файлов начинаются с точки (например так: .bashrc), то они не будут соответствовать шаблону, содержащему символ *[ 48 ]. Аналогично, символ ? в операции подстановки имен файлов имеет иной смысл, нежели в регулярных выражениях.

    bash$ ls -l

    total 2

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1

    -rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh

    -rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt


    bash$ ls -l t?.sh

    -rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh


    bash$ ls -l [ab]*

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1


    bash$ ls -l [a-c]*

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1


    bash$ ls -l [^ab]*

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1

    -rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh

    -rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt


    bash$ ls -l {b*,c*,*est*}

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1

    -rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1

    -rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt


    bash$ echo *

    a.1 b.1 c.1 t2.sh test1.txt


    bash$ echo t*

    t2.sh test1.txt


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

    См. также Пример 10-4.


    Глава 19. Подоболочки, или Subshells

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

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

    Список команд в круглых скобках

    ( command1; command2; command3; ... )

    Список команд, в круглых скобках, исполняется в подоболочке.

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

    Пример 19-1. Область видимости переменных

    #!/bin/bash

    # subshell.sh


    echo


    outer_variable=Outer


    (

    inner_variable=Inner

    echo "Дочерний процесс, \"inner_variable\" = $inner_variable"

    echo "Дочерний процесс, \"outer\" = $outer_variable"

    )


    echo


    if [ -z "$inner_variable" ]

    then

    echo "Переменная inner_variable не определена в родительской оболочке"

    else

    echo "Переменная inner_variable определена в родительской оболочке"

    fi


    echo "Родительский процесс, \"inner_variable\" = $inner_variable"

    # Переменная $inner_variable не будет определена

    # потому, что переменные, определенные в дочернем процессе,

    # ведут себя как "локальные переменные".


    echo


    exit 0

    См. также Пример 31-1.

    +

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

    Пример 19-2. Личные настройки пользователей

    #!/bin/bash

    # allprofs.sh: вывод личных настроек (profiles) всех пользователей


    # Автор: Heiner Steven

    # С некоторыми изменениями, внесенными автором документа.


    FILE=.bashrc # Файл настроек пользователя,

    #+ в оригинальном сценарии называется ".profile".


    for home in `awk -F: '{print $6}' /etc/passwd`

    do

    [ -d "$home" ] || continue # Перейти к следующей итерации, если нет домашнего каталога.

    [ -r "$home" ] || continue # Перейти к следующей итерации, если не доступен для чтения.

    (cd $home; [ -e $FILE ] && less $FILE)

    done


    # По завершении сценария -- нет теобходимости выполнять команду 'cd', чтобы вернуться в первоначальный каталог,

    #+ поскольку 'cd $home' выполняется в подоболочке.


    exit 0

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

    COMMAND1

    COMMAND2

    COMMAND3

    (

    IFS=:

    PATH=/bin

    unset TERMINFO

    set -C

    shift 5

    COMMAND4

    COMMAND5

    exit 3 # Выход только из подоболочки.

    )

    # Изменение переменных окружения не коснется родительской оболочки.

    COMMAND6

    COMMAND7

    Как вариант использования подоболочки -- проверка переменных.

    if (set -u; : $variable) 2> /dev/null

    then

    echo "Переменная определена."

    fi


    # Можно сделать то же самое по другому: [[ ${variable-x} != x || ${variable-y} != y ]]

    # или [[ ${variable-x} != x$variable ]]

    # или [[ ${variable+x} = x ]])

    Еще одно применение -- проверка файлов блокировки:

    if (set -C; : > lock_file) 2> /dev/null

    then

    echo "Этот сценарий уже запущен другим пользователем."

    exit 65

    fi


    # Спасибо S.C.


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

    Пример 19-3. Запуск нескольких процессов в подоболочках

    (cat list1 list2 list3 | sort | uniq > list123) &

    (cat list4 list5 list6 | sort | uniq > list456) &

    # Слияние и сортировка двух списков производится одновременно.

    # Запуск в фоне гарантирует параллельное исполнение.

    #

    # Тот же эффект дает

    # cat list1 list2 list3 | sort | uniq > list123 &

    # cat list4 list5 list6 | sort | uniq > list456 &


    wait # Ожидание завершения работы подоболочек.


    diff list123 list456

    Перенаправление ввода/вывода в/из подоболочки производится оператором построения конвейера "|", например, ls -al | (command).

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

    { command1; command2; command3; ... }


    Глава 20. Ограниченный режим командной оболочки

    Команды, запрещенные в ограниченном режиме командной оболочки

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

    В ограниченном режиме запрещена команда cd -- смена текщего каталога.

    Запрещено изменять переменные окружения $PATH, $SHELL, $BASH_ENV и $ENV.

    Заперщен доступ к переменной $SHELLOPTS.

    Запрещено перенаправление вывода.

    Запрещен вызов утилит, в названии которых присутствует хотя бы один символ "слэш" (/).

    Запрещен вызов команды exec для запуска другого процесса.

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

    Запрещен выход из ограниченного режима.

    Пример 20-1. Запуск сценария в ограниченном режиме

    #!/bin/bash

    # Если sha-bang задать в таком виде: "#!/bin/bash -r"

    # то это приведет к включению ограниченного режима с момента запуска скрипта.


    echo


    echo "Смена каталога."

    cd /usr/local

    echo "Текущий каталог: `pwd`"

    echo "Переход в домашний каталог."

    cd

    echo "Текущий каталог: `pwd`"

    echo


    # До сих пор сценарий исполнялся в обычном, неограниченном режиме.


    set -r

    # set --restricted имеет тот же эффект.

    echo "==> Переход в ограниченный режим. <=="


    echo

    echo


    echo "Попытка сменить текущий каталог в ограниченном режиме."

    cd ..

    echo "Текущий каталог остался прежним: `pwd`"


    echo

    echo


    echo "\$SHELL = $SHELL"

    echo "Попытка смены командного интерпретатора в ограниченном режиме."

    SHELL="/bin/ash"

    echo

    echo "\$SHELL= $SHELL"


    echo

    echo


    echo "Попытка перенаправления вывода в ограниченном режиме."

    ls -l /usr/bin > bin.files

    ls -l bin.files # Попробуем найти файл, который пытались создать.


    echo


    exit 0


    Глава 21. Подстановка процессов

    Подстановка процессов -- это аналог подстановки команд. Операция подстановки команд записывает в переменную результат выполнения некоторой команды, например, dir_contents=`ls -al` или xref=$(grep word datafile). Операция подстановки процессов передает вывод одного процесса на ввод другого (другими словами, передает результат выполнения одной команды -- другой).

    Шаблон подстановки команды

    Внутри круглых скобок

    >(command)

    <(command)

    Таким образом инициируется подстановка процессов. Здесь, для передачи результата работы процесса в круглых скобках, используются файлы /dev/fd/<n>.[ 49 ]

    Между круглой скобкой и символом "<" или ">", не должно быть пробелов, в противном случае это вызовет сообщение об ошибке.

    bash$ echo >(true)

    /dev/fd/63


    bash$ echo <(true)

    /dev/fd/63

    Bash создает канал с двумя файловыми дескрипторами, --fIn и fOut--. stdin команды true присоединяется к fOut (dup2(fOut, 0)), затем Bash передает /dev/fd/fIn в качестве аргумента команде echo. В системах, где отсутствуют файлы /dev/fd/<n>, Bash может использовать временные файлы. (Спасибо S.C.)

    cat <(ls -l)

    # То же самое, что и ls -l | cat


    sort -k 9 <(ls -l /bin) <(ls -l /usr/bin) <(ls -l /usr/X11R6/bin)

    # Список файлов в трех основных каталогах 'bin', отсортированный по именам файлов.

    # Обратите внимание: на вход 'sort' поданы три самостоятельные команды.


    diff <(command1) <(command2) # Выдаст различия в выводе команд.


    tar cf >(bzip2 -c > file.tar.bz2) $directory_name

    # Вызовет "tar cf /dev/fd/?? $directory_name" и затем "bzip2 -c > file.tar.bz2".

    #

    # Из-за особенностей, присущих некоторым системам, связанным с /dev/fd/<n>,

    # канал между командами не обязательно должен быть именованным.

    #

    # Это можно сделать и так.

    #

    bzip2 -c < pipe > file.tar.bz2&

    tar cf pipe $directory_name

    rm pipe

    # или

    exec 3>&1

    tar cf /dev/fd/4 $directory_name 4>&1 >&3 3>&- | bzip2 -c > file.tar.bz2 3>&-

    exec 3>&-


    # Спасибо S.C.


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

    # Фрагмент сценария из дистрибутива SuSE:


    while read des what mask iface; do

    # Некоторые команды ...

    done < <(route -n)


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

    while read des what mask iface; do

    echo $des $what $mask $iface

    done < <(route -n)


    # Вывод на экран:

    # Kernel IP routing table

    # Destination Gateway Genmask Flags Metric Ref Use Iface

    # 127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo


    # Как указывает S.C. -- более простой для понимания эквивалент:

    route -n |

    while read des what mask iface; do # Переменные берут значения с устройства вывода конвейера (канала).

    echo $des $what $mask $iface

    done # На экран выводится то же самое, что и выше.

    # Однако, Ulrich Gayer отметил, что ...

    #+ этот вариант запускает цикл while в подоболочке,

    #+ и поэтому переменные не видны за пределами цикла, после закрытия канала.


    Глава 22. Функции

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

    function function_name { command... }

    или

    function_name () { command... }


    Вторая форма записи ближе к сердцу C-программистам (она же более переносимая).

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

    function_name () { command... }


    Вызов функции осуществляется простым указанием ее имени в тексте сценария.

    Пример 22-1. Простая функция

    #!/bin/bash


    funky ()

    {

    echo "Это обычная функция."

    } # Функция должна быть объявлена раньше, чем ее можно будет использовать.


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


    funky


    exit 0

    Функция должна быть объявлена раньше, чем ее можно будет использовать. К сожалению, в Bash нет возможности "опережающего объявления" функции, как например в C.

    f1

    # Эта строка вызовет сообщение об ошибке, поскольку функция "f1" еще не определена.


    declare -f f1 # Это не поможет.

    f1 # По прежнему -- сообщение об ошибке.


    # Однако...


    f1 ()

    {

    echo "Вызов функции \"f2\" из функции \"f1\"."

    f2

    }


    f2 ()

    {

    echo "Функция \"f2\"."

    }


    f1 # Функция "f2", фактически, не вызывается выше этой строки,

    #+ хотя ссылка на нее встречается выше, до ее объявления.

    # Это допускается.


    # Спасибо S.C.


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

    f1 ()

    {


    f2 () # вложенная

    {

    echo "Функция \"f2\", вложенная в \"f1\"."

    }


    }


    f2 # Вызывает сообщение об ошибке.

    # Даже "declare -f f2" не поможет.


    echo


    f1 # Ничего не происходит, простой вызов "f1", не означает автоматический вызов "f2".

    f2 # Теперь все нормально, вызов "f2" не приводит к появлению ошибки,

    #+ поскольку функция "f2" была определена в процессе вызова "f1".


    # Спасибо S.C.


    Объявление функции может размещаться в самых неожиданных местах.

    ls -l | foo() { echo "foo"; } # Допустимо, но бесполезно.


    if [ "$USER" = bozo ]

    then

    bozo_greet () # Объявление функции размещено в условном операторе.

    {

    echo "Привет, Bozo!"

    }

    fi


    bozo_greet # Работает только у пользователя bozo, другие получат сообщение об ошибке.


    # Нечто подобное можно использовать с определеной пользой для себя.

    NO_EXIT=1 # Will enable function definition below.


    [[ $NO_EXIT -eq 1 ]] && exit() { true; } # Определение функции в последовательности "И-список".

    # Если $NO_EXIT равна 1, то объявляется "exit ()".

    # Тем самым, функция "exit" подменяет встроенную команду "exit".


    exit # Вызывается функция "exit ()", а не встроенная команда "exit".


    # Спасибо S.C.


    22.1. Сложные функции и сложности с функциями

    Функции могут принимать входные аргументы и возвращать код завершения.

    function_name $arg1 $arg2

    Доступ к входным аргументам, в функциях, производится посредством позиционных параметров, т.е. $1, $2 и так далее.

    Пример 22-2. Функция с аргументами

    #!/bin/bash

    # Функции и аргументы


    DEFAULT=default # Значение аргумента по-умолчанию.


    func2 () {

    if [ -z "$1" ] # Длина аргумента #1 равна нулю?

    then

    echo "-Аргумент #1 имеет нулевую длину.-" # Или аргумент не был передан функции.

    else

    echo "-Аргумент #1: \"$1\".-"

    fi


    variable=${1-$DEFAULT} # Что делает

    echo "variable = $variable" #+ показанная подстановка параметра?

    # ---------------------------

    # Она различает отсутствующий аргумент

    #+ от "пустого" аргумента.


    if [ "$2" ]

    then

    echo "-Аргумент #2: \"$2\".-"

    fi


    return 0

    }


    echo


    echo "Вызов функции без аргументов."

    func2

    echo


    echo "Вызов функции с \"пустым\" аргументом."

    func2 ""

    echo


    echo "Вызов функции с неинициализированным аргументом."

    func2 "$uninitialized_param"

    echo


    echo "Вызов функции с одним аргументом."

    func2 first

    echo


    echo "Вызов функции с двумя аргументами."

    func2 first second

    echo


    echo "Вызов функции с аргументами \"\" \"second\"."

    func2 "" second # Первый параметр "пустой"

    echo # и второй параметр -- ASCII-строка.


    exit 0

    Команда shift вполне применима и к аргументам функций (см. Пример 33-10).

    В отличие от других языков программирования, в сценариях на языке командной оболочке, в функции передаются аргументы по значению[ 50 ]. Если имена переменных (которые фактически являются указателями) передаются функции в виде аргументов, то они интерпретируются как обычные строки символов и не могут быть разыменованы. Функции интерпретируют свои аргументы буквально.

    Exit и Return

    код завершения

    Функции возвращают значение в виде кода завершения. Код завершения может быть задан явно, с помощью команды return, в противном случае будет возвращен код завершения последней команды в функции (0 -- в случае успеха, иначе -- ненулевой код ошибки). Код завершения в сценарии может быть получен через переменную $?.

    return

    Завершает исполнение функции. Команда return[ 51 ] может иметь необязательный аргумент типа integer, который возвращается в вызывающий сценарий как "код завершения" функции, это значение так же записывается в переменную $?.

    Пример 22-3. Наибольшее из двух чисел

    #!/bin/bash

    # max.sh: Наибольшее из двух целых чисел.


    E_PARAM_ERR=-198 # Если функции передано меньше двух параметров.

    EQUAL=-199 # Возвращаемое значение, если числа равны.


    max2 () # Возвращает наибольшее из двух чисел.

    { # Внимание: сравниваемые числа должны быть меньше 257.

    if [ -z "$2" ]

    then

    return $E_PARAM_ERR

    fi


    if [ "$1" -eq "$2" ]

    then

    return $EQUAL

    else

    if [ "$1" -gt "$2" ]

    then

    return $1

    else

    return $2

    fi

    fi

    }


    max2 33 34

    return_val=$?


    if [ "$return_val" -eq $E_PARAM_ERR ]

    then

    echo "Функции должно быть передано два аргумента."

    elif [ "$return_val" -eq $EQUAL ]

    then

    echo "Числа равны."

    else

    echo "Наибольшее из двух чисел: $return_val."

    fi


    exit 0


    # Упражнение:

    # ---------------

    # Сделайте этот сценарий интерактивным,

    #+ т.е. заставьте сценарий запрашивать числа для сравнения у пользователя (два числа).

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

    count_lines_in_etc_passwd()

    {

    [[ -r /etc/passwd ]] && REPLY=$(echo $(wc -l < /etc/passwd))

    # Если файл /etc/passwd доступен на чтение, то в переменную REPLY заносится число строк.

    # Возвращаются как количество строк, так и код завершения.

    }


    if count_lines_in_etc_passwd

    then

    echo "В файле /etc/passwd найдено $REPLY строк."

    else

    echo "Невозможно подсчитать число строк в файле /etc/passwd."

    fi


    # Спасибо S.C.


    Пример 22-4. Преобразование чисел в римскую форму записи

    #!/bin/bash


    # Преобразование чисел из арабской формы записи в римскую

    # Диапазон: 0 - 200


    # Расширение диапазона представляемых чисел и улучшение сценария

    # оставляю вам, в качестве упражнения.


    # Порядок использования: roman number-to-convert


    LIMIT=200

    E_ARG_ERR=65

    E_OUT_OF_RANGE=66


    if [ -z "$1" ]

    then

    echo "Порядок использования: `basename $0` number-to-convert"

    exit $E_ARG_ERR

    fi


    num=$1

    if [ "$num" -gt $LIMIT ]

    then

    echo "Выход за границы диапазона!"

    exit $E_OUT_OF_RANGE

    fi


    to_roman () # Функция должна быть объявлена до того как она будет вызвана.

    {

    number=$1

    factor=$2

    rchar=$3

    let "remainder = number - factor"

    while [ "$remainder" -ge 0 ]

    do

    echo -n $rchar

    let "number -= factor"

    let "remainder = number - factor"

    done


    return $number

    # Упражнение:

    # --------

    # Объясните -- как работает функция.

    # Подсказка: деление последовательным вычитанием.

    }


    to_roman $num 100 C

    num=$?

    to_roman $num 90 LXXXX

    num=$?

    to_roman $num 50 L

    num=$?

    to_roman $num 40 XL

    num=$?

    to_roman $num 10 X

    num=$?

    to_roman $num 9 IX

    num=$?

    to_roman $num 5 V

    num=$?

    to_roman $num 4 IV

    num=$?

    to_roman $num 1 I


    echo


    exit 0

    См. также Пример 10-28.

    Наибольшее положительное целое число, которое может вернуть функция -- 255. Команда return очень тесно связана с понятием код завершения, что объясняет это специфическое ограничение. К счастью существуют различные способы преодоления этого ограничения.

    Пример 22-5. Проверка возможности возврата функциями больших значений

    #!/bin/bash

    # return-test.sh


    # Наибольшее целое число, которое может вернуть функция, не может превышать 256.


    return_test () # Просто возвращает то, что ей передали.

    {

    return $1

    }


    return_test 27 # o.k.

    echo $? # Возвращено число 27.


    return_test 255 # o.k.

    echo $? # Возвращено число 255.


    return_test 257 # Ошибка!

    echo $? # Возвращено число 1.


    return_test -151896 # Как бы то ни было, но для больших отрицательных чисел проходит!

    echo $? # Возвращено число -151896.


    exit 0

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

    Еще один способ -- использовать глобальные переменные для хранения "возвращаемого значения".

    Return_Val= # Глобальная переменная, которая хранит значение, возвращаемое функцией.


    alt_return_test ()

    {

    fvar=$1

    Return_Val=$fvar

    return # Возвратить 0 (успешное завершение).

    }


    alt_return_test 1

    echo $? # 0

    echo "Функция вернула число $Return_Val" # 1


    alt_return_test 255

    echo "Функция вернула число $Return_Val" # 255


    alt_return_test 257

    echo "Функция вернула число $Return_Val" # 257


    alt_return_test 25701

    echo "Функция вернула число $Return_Val" #25701


    Пример 22-6. Сравнение двух больших целых чисел

    #!/bin/bash

    # max2.sh: Наибольшее из двух БОЛЬШИХ целых чисел.


    # Это модификация предыдущего примера "max.sh",

    # которая позволяет выполнять сравнение больших целых чисел.


    EQUAL=0 # Если числа равны.

    MAXRETVAL=255 # Максимально возможное положительное число, которое может вернуть функция.

    E_PARAM_ERR=-99999 # Код ошибки в параметрах.

    E_NPARAM_ERR=99999 # "Нормализованный" код ошибки в параметрах.


    max2 () # Возвращает наибольшее из двух больших целых чисел.

    {

    if [ -z "$2" ]

    then

    return $E_PARAM_ERR

    fi


    if [ "$1" -eq "$2" ]

    then

    return $EQUAL

    else

    if [ "$1" -gt "$2" ]

    then

    retval=$1

    else

    retval=$2

    fi

    fi


    # -------------------------------------------------------------- #

    # Следующие строки позволяют "обойти" ограничение

    if [ "$retval" -gt "$MAXRETVAL" ] # Если больше предельного значения,

    then # то

    let "retval = (( 0 - $retval ))" # изменение знака числа.

    # (( 0 - $VALUE )) изменяет знак числа.

    fi

    # Функции имеют возможность возвращать большие *отрицательные* числа.

    # -------------------------------------------------------------- #


    return $retval

    }


    max2 33001 33997

    return_val=$?


    # -------------------------------------------------------------------------- #

    if [ "$return_val" -lt 0 ] # Если число отрицательное,

    then # то

    let "return_val = (( 0 - $return_val ))" # опять изменить его знак.

    fi # "Абсолютное значение" переменной $return_val.

    # -------------------------------------------------------------------------- #


    if [ "$return_val" -eq "$E_NPARAM_ERR" ]

    then # Признак ошибки в параметрах, при выходе из функции так же поменял знак.

    echo "Ошибка: Недостаточно аргументов."

    elif [ "$return_val" -eq "$EQUAL" ]

    then

    echo "Числа равны."

    else

    echo "Наиболшее число: $return_val."

    fi


    exit 0

    См. также Пример A-8.

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

    Перенаправление

    Перенаправление ввода для функций

    Функции -- суть есть блок кода, а это означает, что устройство stdin для функций может быть переопределено (перенаправление stdin) (как в Пример 3-1).

    Пример 22-7. Настоящее имя пользователя

    #!/bin/bash


    # По имени пользователя получить его "настоящее имя" из /etc/passwd.


    ARGCOUNT=1 # Ожидается один аргумент.

    E_WRONGARGS=65


    file=/etc/passwd

    pattern=$1


    if [ $# -ne "$ARGCOUNT" ]

    then

    echo "Порядок использования: `basename $0` USERNAME"

    exit $E_WRONGARGS

    fi


    file_excerpt () # Производит поиск в файле по заданному шаблону, выводит требуемую часть строки.

    {

    while read line

    do

    echo "$line" | grep $1 | awk -F":" '{ print $5 }' # Указывет awk использовать ":" как разделитель полей.

    done

    } <$file # Подменить stdin для функции.


    file_excerpt $pattern


    # Да, этот сценарий можно уменьшить до

    # grep PATTERN /etc/passwd | awk -F":" '{ print $5 }'

    # или

    # awk -F: '/PATTERN/ {print $5}'

    # или

    # awk -F: '($1 == "username") { print $5 }'

    # Однако, это было бы не так поучительно.


    exit 0

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

    # Вместо:

    Function ()

    {

    ...

    } < file


    # Попробуйте так:

    Function ()

    {

    {

    ...

    } < file

    }


    # Похожий вариант,


    Function () # Тоже работает.

    {

    {

    echo $*

    } | tr a b

    }


    Function () # Этот вариант не работает.

    {

    echo $*

    } | tr a b # Наличие вложенного блока кода -- обязательное условие.


    # Спасибо S.C.


    22.2. Локальные переменные

    Что такое "локальная" переменная?

    локальные переменные

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

    Пример 22-8. Область видимости локальных переменных

    #!/bin/bash


    func ()

    {

    local loc_var=23 # Объявление локальной переменной.

    echo

    echo "\"loc_var\" в функции = $loc_var"

    global_var=999 # Эта переменная не была объявлена локальной.

    echo "\"global_var\" в функции = $global_var"

    }


    func


    # Проверим, "видна" ли локальная переменная за пределами функции.


    echo

    echo "\"loc_var\" за пределами функции = $loc_var"

    # "loc_var" за пределами функции =

    # Итак, $loc_var не видна в глобальном контексте.

    echo "\"global_var\" за пределами функции = $global_var"

    # "global_var" за пределами функции = 999

    # $global_var имеет глобальную область видимости.

    echo


    exit 0

    Переменные, объявляемые в теле функции, считаются необъявленными до тех пор, пока функция не будет вызвана. Это касается всех переменных.

    #!/bin/bash


    func ()

    {

    global_var=37 # Эта переменная будет считаться необъявленной

    #+ до тех пор, пока функция не будет вызвана.

    } # КОНЕЦ ФУНКЦИИ


    echo "global_var = $global_var" # global_var =

    # Функция "func" еще не была вызвана,

    #+ поэтому $global_var пока еще не "видна" здесь.


    func

    echo "global_var = $global_var" # global_var = 37

    # Переменная была инициализирована в функции.


    22.2.1. Локальные переменные делают возможной рекурсию.

    Хотя локальные переменные и допускают рекурсию[ 52 ], но она сопряжена с большими накладными расходами и не рекомендуется для использования в сценариях[ 53 ].

    Пример 22-9. Использование локальных переменных при рекурсии

    #!/bin/bash


    # факториал

    # ---------


    # Действительно ли bash допускает рекурсию?

    # Да! Но...

    # Нужно быть действительно дубинноголовым, чтобы использовать ее в сценариях

    # на языке командной оболочки.


    MAX_ARG=5

    E_WRONG_ARGS=65

    E_RANGE_ERR=66


    if [ -z "$1" ]

    then

    echo "Порядок использования: `basename $0` число"

    exit $E_WRONG_ARGS

    fi


    if [ "$1" -gt $MAX_ARG ]

    then

    echo "Выход за верхний предел (максимально возможное число -- 5)."

    # Вернитесь к реальности.

    # Если вам захочется поднять верхнюю границу,

    # то перепишите эту программу на настоящем языке программирования.

    exit $E_RANGE_ERR

    fi


    fact ()

    {

    local number=$1

    # Переменная "number" должна быть объявлена как локальная,

    # иначе результат будет неверный.

    if [ "$number" -eq 0 ]

    then

    factorial=1 # Факториал числа 0 = 1.

    else

    let "decrnum = number - 1"

    fact $decrnum # Рекурсивный вызов функции.

    let "factorial = $number * $?"

    fi


    return $factorial

    }


    fact $1

    echo "Факториал числа $1 = $?."


    exit 0

    Еще один пример использования рекурсии вы найдете в Пример A-18. Не забывайте, что рекурсия весьма ресурсоемкое удовольствие, к тому же она выполняется слишком медленно, поэтому не следует использовать ее в сценариях.


    Глава 23. Псевдонимы

    Псевдонимы в Bash -- это ни что иное, как "горячие клавиши", средство, позволяющее избежать набора длинных строк в командной строке. Если, к примеру, в файл ~/.bashrc вставить строку alias lm="ls -l | more", то потом вы сможете экономить свои силы и время, набирая команду lm, вместо более длинной ls -l | more. Установив alias rm="rm -i" (интерактивный режим удаления файлов), вы сможете избежать многих неприятностей, потому что сократится вероятность удаления важных файлов по неосторожности.

    Псевдонимы в сценариях могут иметь весьма ограниченную область применения. Было бы здорово, если бы псевдонимы имели функциональность, присущую макроопределениям в языке C, но, к сожалению, Bash не может "разворачивать" аргументы в теле псевдонима[ 54 ]. Кроме того, попытка обратиться к псевдониму, созданному внутри "составных конструкций", таких как if/then, циклы и функции, будет приводить к появлению ошибок. Практически всегда, действия, возлагаемые на псевдоним, более эффективно могут быть выполнены с помощью функций.

    Пример 23-1. Псевдонимы в сценарии

    #!/bin/bash


    shopt -s expand_aliases

    # Эта опция должна быть включена, иначе сценарий не сможет "разворачивать" псевдонимы.


    alias ll="ls -l"

    # В определении псевдонима можно использовать как одиночные ('), так и двойные (") кавычки.


    echo "Попытка обращения к псевдониму \"ll\":"

    ll /usr/X11R6/bin/mk* #* Работает.


    echo


    directory=/usr/X11R6/bin/

    prefix=mk* # Определить -- не будет ли проблем с шаблонами.

    echo "Переменные \"directory\" + \"prefix\" = $directory$prefix"

    echo


    alias lll="ls -l $directory$prefix"


    echo "Попытка обращения к псевдониму \"lll\":"

    lll # Список всех файлов в /usr/X11R6/bin, чьи имена начинаются с mk.

    # Псевдонимы могут работать с шаблонами.


    TRUE=1


    echo


    if [ TRUE ]

    then

    alias rr="ls -l"

    echo "Попытка обращения к псевдониму \"rr\", созданному внутри if/then:"

    rr /usr/X11R6/bin/mk* #* В результате -- сообщение об ошибке!

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

    echo "Однако, ранее созданный псевдоним остается работоспособным:"

    ll /usr/X11R6/bin/mk*

    fi


    echo


    count=0

    while [ $count -lt 3 ]

    do

    alias rrr="ls -l"

    echo "Попытка обращения к псевдониму \"rrr\", созданному внутри цикла \"while\":"

    rrr /usr/X11R6/bin/mk* #* Так же возникает ошибка.

    # alias.sh: line 57: rrr: command not found

    let count+=1

    done


    echo; echo


    alias xyz='cat $0' # Сценарий печатает себя самого.

    # Обратите внимание на "строгие" кавычки.

    xyz

    # Похоже работает,

    #+ хотя документация Bash утверждает, что такой псевдоним не должен работать.

    #

    # Steve Jacobson отметил, что

    #+ параметр "$0" интерпретируется непосредственно, во время объявления псевдонима.


    exit 0

    Команда unalias удаляет псевдоним, объявленный ранее .

    Пример 23-2. unalias: Объявление и удаление псевдонимов

    #!/bin/bash


    shopt -s expand_aliases # Разрешить "разворачивание" псевдонимов.


    alias llm='ls -al | more'

    llm


    echo


    unalias llm # Удалить псевдоним.

    llm

    # Сообщение об ошибке, т.к. команда 'llm' больше не распознается.


    exit 0

    bash$ ./unalias.sh

    total 6

    drwxrwxr-x 2 bozo bozo 3072 Feb 6 14:04 .

    drwxr-xr-x 40 bozo bozo 2048 Feb 6 14:04 ..

    -rwxr-xr-x 1 bozo bozo 199 Feb 6 14:04 unalias.sh


    ./unalias.sh: llm: command not found


    Глава 24. Списки команд

    Средством обработки последовательности из нескольких команд служат списки: "И-списки" и "ИЛИ-списки". Они эффективно могут заменить сложную последовательность вложенных if/then или даже case.

    Объединение команд в цепочки

    И-список

    command-1 && command-2 && command-3 && ... command-n

    Каждая последующая команда, в таком списке, выполняется только тогда, когда предыдущая команда вернула код завершения true (ноль). Если какая-либо из команд возвращает false (не ноль), то исполнение списка команд в этом месте завершается, т.е. следующие далее команды не выполняются.

    Пример 24-1. Проверка аргументов командной строки с помощью "И-списка"

    #!/bin/bash

    # "И-список"


    if [ ! -z "$1" ] && echo "Аргумент #1 = $1" && [ ! -z "$2" ] && echo "Аргумент #2 = $2"

    then

    echo "Сценарию передано не менее 2 аргументов."

    # Все команды в цепочке возвращают true.

    else

    echo "Сценарию передано менее 2 аргументов."

    # Одна из команд в списке вернула false.

    fi

    # Обратите внимание: "if [ ! -z $1 ]" тоже работает, но, казалось бы эквивалентный вариант

    # if [ -n $1 ] -- нет. Однако, если добавить кавычки

    # if [ -n "$1" ] то все работает. Будьте внимательны!

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


    # То же самое, только без списка команд.

    if [ ! -z "$1" ]

    then

    echo "Аргумент #1 = $1"

    fi

    if [ ! -z "$2" ]

    then

    echo "Аргумент #2 = $2"

    echo "Сценарию передано не менее 2 аргументов."

    else

    echo "Сценарию передано менее 2 аргументов."

    fi

    # Получилось менее элегантно и длиннее, чем с использованием "И-списка".


    exit 0

    Пример 24-2. Еще один пример проверки аргументов с помощью "И-списков"

    #!/bin/bash


    ARGS=1 # Ожидаемое число аргументов.

    E_BADARGS=65 # Код завершения, если число аргументов меньше ожидаемого.


    test $# -ne $ARGS && echo "Порядок использования: `basename $0` $ARGS аргумент(а)(ов)" && exit $E_BADARGS

    # Если проверка первого условия возвращает true (неверное число аргументов),

    # то исполняется остальная часть строки, и сценарий завершается.


    # Строка ниже выполняется только тогда, когда проверка выше не проходит.

    # обратите внимание на условие "-ne" -- "не равно" (прим. перев.)

    echo "Сценарию передано корректное число аргументов."


    exit 0


    # Проверьте код завершения сценария командой "echo $?".

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

    arg1=$@ # В $arg1 записать аргументы командной строки.


    [ -z "$arg1" ] && arg1=DEFAULT

    # Записать DEFAULT, если аргументы командной строки отсутствуют.


    ИЛИ-список

    command-1 || command-2 || command-3 || ... command-n

    Каждая последующая команда, в таком списке, выполняется только тогда, когда предыдущая команда вернула код завершения false (не ноль). Если какая-либо из команд возвращает true (ноль), то исполнение списка команд в этом месте завершается, т.е. следующие далее команды не выполняются. Очевидно, что "ИЛИ-списки" имеют смысл обратный, по отношению к "И-спискам"

    Пример 24-3. Комбинирование "ИЛИ-списков" и "И-списков"

    #!/bin/bash


    # delete.sh, утилита удаления файлов.

    # Порядок использования: delete имя_файла


    E_BADARGS=65


    if [ -z "$1" ]

    then

    echo "Порядок использования: `basename $0` имя_файла"

    exit $E_BADARGS # Если не задано имя файла.

    else

    file=$1 # Запомнить имя файла.

    fi


    [ ! -f "$file" ] && echo "Файл \"$file\" не найден. \

    Робкий отказ удаления несуществующего файла."

    # И-СПИСОК, выдать сообщение об ошибке, если файл не существует.

    # Обратите внимание: выводимое сообщение продолжается во второй строке,

    # благодаря экранированию символа перевода строки.


    [ ! -f "$file" ] || (rm -f $file; echo "Файл \"$file\" удален.")

    # ИЛИ-СПИСОК, удаляет существующий файл.


    # Обратите внимание на логические условия.

    # И-СПИСОК отрабатывает по true, ИЛИ-СПИСОК -- по false.


    exit 0

    Списки возвращают код завершения последней выполненной команды.

    Комбинируя "И" и "ИЛИ" списки, легко "перемудрить" с логическими условиями, поэтому, в таких случаях может потребоваться детальная отладка.

    false && true || echo false # false


    # Тот же результат дает

    ( false && true ) || echo false # false

    # Но не эта комбинация

    false && ( true || echo false ) # (нет вывода на экран)


    # Обратите внимание на группировку и порядок вычисления условий -- слева-направо,

    #+ поскольку логические операции "&&" и "||" имеют равный приоритет.


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


    # Спасибо S.C.


    См. Пример A-8 и Пример 7-4, иллюстрирующие использование И/ИЛИ-списков для проверки переменных.


    Глава 25. Массивы

    Новейшие версии Bash поддерживают одномерные массивы. Инициализация элементов массива может быть произведена в виде: variable[xx]. Можно явно объявить массив в сценарии, с помощью директивы declare: declare -a variable. Обращаться к отдельным элементам массива можно с помощью фигурных скобок, т.е.: ${variable[xx]}.

    Пример 25-1. Простой массив

    #!/bin/bash


    area[11]=23

    area[13]=37

    area[51]=UFOs


    # Массивы не требуют, чтобы последовательность элементов в массиве была непрерывной.


    # Некоторые элементы массива могут оставаться неинициализированными.

    # "Дыркм" в массиве не являются ошибкой.


    echo -n "area[11] = "

    echo ${area[11]} # необходимы {фигурные скобки}


    echo -n "area[13] = "

    echo ${area[13]}


    echo "содержимое area[51] = ${area[51]}."


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

    echo -n "area[43] = "

    echo ${area[43]}

    echo "(элемент area[43] -- неинициализирован)"


    echo


    # Сумма двух элементов массива, записанная в третий элемент

    area[5]=`expr ${area[11]} + ${area[13]}`

    echo "area[5] = area[11] + area[13]"

    echo -n "area[5] = "

    echo ${area[5]}


    area[6]=`expr ${area[11]} + ${area[51]}`

    echo "area[6] = area[11] + area[51]"

    echo -n "area[6] = "

    echo ${area[6]}

    # Эта попытка закончится неудачей, поскольку сложение целого числа со строкой не допускается.


    echo; echo; echo


    # -----------------------------------------------------------------

    # Другой массив, "area2".

    # И другой способ инициализации массива...

    # array_name=( XXX YYY ZZZ ... )


    area2=( ноль один два три четыре )


    echo -n "area2[0] = "

    echo ${area2[0]}

    # Ага, индексация начинается с нуля (первый элемент массива имеет индекс [0], а не [1]).


    echo -n "area2[1] = "

    echo ${area2[1]} # [1] -- второй элемент массива.

    # -----------------------------------------------------------------


    echo; echo; echo


    # -----------------------------------------------

    # Еще один массив, "area3".

    # И еще один способ инициализации...

    # array_name=([xx]=XXX [yy]=YYY ...)


    area3=([17]=семнадцать [21]=двадцать_один)


    echo -n "area3[17] = "

    echo ${area3[17]}


    echo -n "area3[21] = "

    echo ${area3[21]}

    # -----------------------------------------------


    exit 0

    Bash позволяет оперировать переменными, как массивами, даже если они не были явно объявлены таковыми.

    string=abcABC123ABCabc

    echo ${string[@]} # abcABC123ABCabc

    echo ${string[*]} # abcABC123ABCabc

    echo ${string[0]} # abcABC123ABCabc

    echo ${string[1]} # Ничего не выводится!

    # Почему?

    echo ${#string[@]} # 1

    # Количество элементов в массиве.


    # Спасибо Michael Zick за этот пример.

    Эти примеры еще раз подтверждают отсутствие контроля типов в Bash.

    Пример 25-2. Форматирование стихотворения

    #!/bin/bash

    # poem.sh


    # Строки из стихотворения (одна строфа).

    Line[1]="Мой дядя самых честных правил,"

    Line[2]="Когда не в шутку занемог;"

    Line[3]="Он уважать себя заставил,"

    Line[4]="И лучше выдумать не мог."

    Line[5]="Его пример другим наука..."


    # Атрибуты.

    Attrib[1]=" А.С. Пушкин"

    Attrib[2]="\"Евгений Онегин\""


    for index in 1 2 3 4 5 # Пять строк.

    do

    printf " %s\n" "${Line[index]}"

    done


    for index in 1 2 # Две строки дополнительных атрибутов.

    do

    printf " %s\n" "${Attrib[index]}"

    done


    exit 0

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

    array=( ноль один два три четыре пять )


    echo ${array[0]} # ноль

    echo ${array:0} # ноль

    # Подстановка параметра -- первого элемента.

    echo ${array:1} # оль

    # Подстановка параметра -- первого элемента,

    #+ начиная с позиции #1 (со 2-го символа).


    echo ${#array} # 4

    # Длина первого элемента массива.


    array2=( [0]="первый элемент" [1]="второй элемент" [3]="четвертый элемент" )


    echo ${array2[0]} # первый элемент

    echo ${array2[1]} # второй элемент

    echo ${array2[2]} #

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

    echo ${array2[3]} # четвертый элемент


    При работе с массивами, некоторые встроенные команды Bash имеют несколько иной смысл. Например, unset -- удаляет отдельные элементы массива, или даже массив целиком.

    Пример 25-3. Некоторые специфичные особенности массивов

    #!/bin/bash


    declare -a colors

    # Допускается объявление массива без указания его размера.


    echo "Введите ваши любимые цвета (разделяя их пробелами)."


    read -a colors # Введите хотя бы 3 цвета для демонстрации некоторых свойств массивов.

    # Специфический ключ команды 'read',

    #+ позволяющий вводить несколько элементов массива.


    echo


    element_count=${#colors[@]}


    # Получение количества элементов в массиве.

    # element_count=${#colors[*]} -- дает тот же результат.

    #

    # Переменная "@" позволяет "разбивать" строку в кавычках на отдельные слова

    #+ (выделяются слова, разделенные пробелами).


    index=0


    while [ "$index" -lt "$element_count" ]

    do # Список всех элементов в массиве.

    echo ${colors[$index]}

    let "index = $index + 1"

    done

    # Каждый элемент массива выводится в отдельной строке.

    # Если этого не требуется, то используйте echo -n "${colors[$index]} "

    #

    # Эквивалентный цикл "for":

    # for i in "${colors[@]}"

    # do

    # echo "$i"

    # done

    # (Спасибо S.C.)


    echo


    # Еще один, более элегантный, способ вывода списка всех элементов массива.

    echo ${colors[@]} # ${colors[*]} дает тот же результат.


    echo


    # Команда "unset" удаляет элементы из массива, или даже массив целиком.

    unset colors[1] # Удаление 2-го элемента массива.

    # Тот же эффект дает команда colors[1]=

    echo ${colors[@]} # Список всех элементов массива -- 2-й элемент отсутствует.


    unset colors # Удаление всего массива.

    # Тот же эффект имеют команды unset colors[*]

    #+ и unset colors[@].

    echo; echo -n "Массив цветов опустошен."

    echo ${colors[@]} # Список элементов массива пуст.


    exit 0

    Как видно из предыдущего примера, обращение к ${array_name[@]} или ${array_name[*]} относится ко всем элементам массива. Чтобы получить количество элементов массива, можно обратиться к ${#array_name[@]} или к ${#array_name[*]}. ${#array_name} -- это длина (количество символов) первого элемента массива, т.е. ${array_name[0]}.

    Пример 25-4. Пустые массивы и пустые элементы

    #!/bin/bash

    # empty-array.sh


    # Выражаю свою благодарность Stephane Chazelas за этот пример,

    #+ и Michael Zick за его доработку.


    # Пустой массив -- это не то же самое, что массив с пустыми элементами.


    array0=( первый второй третий )

    array1=( '' ) # "array1" имеет один пустой элемент.

    array2=( ) # Массив "array2" не имеет ни одного элемента, т.е. пуст.


    echo

    ListArray()

    {

    echo

    echo "Элементы массива array0: ${array0[@]}"

    echo "Элементы массива array1: ${array1[@]}"

    echo "Элементы массива array2: ${array2[@]}"

    echo

    echo "Длина первого элемента массива array0 = ${#array0}"

    echo "Длина первого элемента массива array1 = ${#array1}"

    echo "Длина первого элемента массива array2 = ${#array2}"

    echo

    echo "Число элементов в массиве array0 = ${#array0[*]}" # 3

    echo "Число элементов в массиве array1 = ${#array1[*]}" # 1 (сюрприз!)

    echo "Число элементов в массиве array2 = ${#array2[*]}" # 0

    }


    # ===================================================================


    ListArray


    # Попробуем добавить новые элементы в массивы


    # Добавление новых элементов в массивы.

    array0=( "${array0[@]}" "новый1" )

    array1=( "${array1[@]}" "новый1" )

    array2=( "${array2[@]}" "новый1" )


    ListArray


    # или

    array0[${#array0[*]}]="новый2"

    array1[${#array1[*]}]="новый2"

    array2[${#array2[*]}]="новый2"


    ListArray


    # Теперь представим каждый массив как 'стек' ('stack')

    # Команды выше, можно считать командами 'push' -- добавление нового значения на вершину стека

    # 'Глубина' стека:

    height=${#array2[@]}

    echo

    echo "Глубина стека array2 = $height"


    # Команда 'pop' -- выталкивание элемента стека, находящегося на вершине:

    unset array2[${#array2[@]}-1] # Индексация массивов начинается с нуля

    height=${#array2[@]}

    echo

    echo "POP"

    echo "Глубина стека array2, после выталкивания = $height"


    ListArray


    # Вывести только 2-й и 3-й элементы массива array0

    from=1 # Индексация массивов начинается с нуля

    to=2 #

    declare -a array3=( ${array0[@]:1:2} )

    echo

    echo "Элементы массива array3: ${array3[@]}"


    # Замена элементов по шаблону

    declare -a array4=( ${array0[@]/второй/2-й} )

    echo

    echo "Элементы массива array4: ${array4[@]}"


    # Замена строк по шаблону

    declare -a array5=( ${array0[@]//новый?/старый} )

    echo

    echo "Элементы массива array5: ${array5[@]}"


    # Надо лишь привыкнуть к такой записи...

    declare -a array6=( ${array0[@]#*новый} )

    echo # Это может вас несколько удивить

    echo "Элементы массива array6: ${array6[@]}"


    declare -a array7=( ${array0[@]#новый1} )

    echo # Теперь это вас уже не должно удивлять

    echo "Элементы массива array7: ${array7[@]}"


    # Выглядить очень похоже на предыдущий вариант...

    declare -a array8=( ${array0[@]/новый1/} )

    echo

    echo "Элементы массива array8: ${array8[@]}"


    # Итак, что вы можете сказать обо всем этом?


    # Строковые операции выполняются последовательно, над каждым элементом

    #+ в массиве var[@].

    # Таким образом, BASH поддерживает векторные операции

    # Если в результате операции получается пустая строка, то

    #+ элемент массива "исчезает".


    # Вопрос: это относится к строкам в "строгих" или "мягких" кавычках?


    zap='новый*'

    declare -a array9=( ${array0[@]/$zap/} )

    echo

    echo "Элементы массива array9: ${array9[@]}"


    # "...А с платформы говорят: "Это город Ленинград!"..."

    declare -a array10=( ${array0[@]#$zap} )

    echo

    echo "Элементы массива array10: ${array10[@]}"


    # Сравните массивы array7 и array10

    # Сравните массивы array8 и array9


    # Ответ: в "мягких" кавычках.


    exit 0

    Разница между ${array_name[@]} и ${array_name[*]} такая же, как между $@ и $*. Эти свойства массивов широко применяются на практике.

    # Копирование массивов.

    array2=( "${array1[@]}" )

    # или

    array2="${array1[@]}"


    # Добавить элемент.

    array=( "${array[@]}" "новый элемент" )

    # или

    array[${#array[*]}]="новый элемент"


    # Спасибо S.C.


    Операция подстановки команд -- array=( element1 element2 ... elementN ), позволяет загружать содержимое текстовых файлов в массивы.

    #!/bin/bash


    filename=sample_file


    # cat sample_file

    #

    # 1 a b c

    # 2 d e fg


    declare -a array1


    array1=( `cat "$filename" | tr '\n' ' '`) # Загрузка содержимого файла

    # $filename в массив array1.

    # Вывод на stdout.

    # с заменой символов перевода строки на пробелы.


    echo ${array1[@]} # список элементов массива.

    # 1 a b c 2 d e fg

    #

    # Каждое "слово", в текстовом файле, отделяемое от других пробелами

    #+ заносится в отдельный элемент массива.


    element_count=${#array1[*]}

    echo $element_count # 8


    Пример 25-5. Копирование и конкатенация массивов

    #! /bin/bash

    # CopyArray.sh

    #

    # Автор: Michael Zick.

    # Используется с его разрешения.


    # "Принять из массива с заданным именем записать в массив с заданным именем"

    #+ или "собственный Оператор Присваивания".


    CpArray_Mac() {


    # Оператор Присваивания


    echo -n 'eval '

    echo -n "$2" # Имя массива-результата

    echo -n '=( ${'

    echo -n "$1" # Имя исходного массива

    echo -n '[@]} )'


    # Все это могло бы быть объединено в одну команду.

    # Это лишь вопрос стиля.

    }


    declare -f CopyArray # "Указатель" на функцию

    CopyArray=CpArray_Mac # Оператор Присваивания


    Hype()

    {


    # Исходный массив с именем в $1.

    # (Слить с массивом, содержащим "-- Настоящий Рок-н-Ролл".)

    # Вернуть результат в массиве с именем $2.


    local -a TMP

    local -a hype=( -- Настоящий Рок-н-Ролл )


    $($CopyArray $1 TMP)

    TMP=( ${TMP[@]} ${hype[@]} )

    $($CopyArray TMP $2)

    }


    declare -a before=( Advanced Bash Scripting )

    declare -a after


    echo "Массив before = ${before[@]}"


    Hype before after


    echo "Массив after = ${after[@]}"


    # Еще?


    echo "Что такое ${after[@]:4:2}?"


    declare -a modest=( ${after[@]:2:1} ${after[@]:3:3} )

    # ---- выделение подстроки ----


    echo "Массив Modest = ${modest[@]}"


    # А что в массиве 'before' ?


    echo "Массив Before = ${before[@]}"


    exit 0

    --

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

    Пример 25-6. Старая, добрая: "Пузырьковая" сортировка

    #!/bin/bash

    # bubble.sh: "Пузырьковая" сортировка.


    # На каждом проходе по сортируемому массиву,

    #+ сравниваются два смежных элемента, и, если необходимо, они меняются местами.

    # В конце первого прохода, самый "тяжелый" элемент "опускается" в конец массива.

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

    # И так далее.

    # Каждый последующий проход требует на одно сравнение меньше предыдущего.

    # Поэтому вы должны заметить ускорение работы сценария на последних проходах.


    exchange()

    {

    # Поменять местами два элемента массива.

    local temp=${Countries[$1]} # Временная переменная

    Countries[$1]=${Countries[$2]}

    Countries[$2]=$temp


    return

    }


    declare -a Countries # Объявление массива,

    #+ необязательно, поскольку он явно инициализируется ниже.


    # Допустимо ли выполнять инициализацию массива в нескольки строках?

    # ДА!


    Countries=(Нидерланды Украина Заир Турция Россия Йемен Сирия \

    Бразилия Аргентина Никарагуа Япония Мексика Венесуэла Греция Англия \

    Израиль Перу Канада Оман Дания Уэльс Франция Кения \

    Занаду Катар Лихтенштейн Венгрия)


    # "Занаду" -- это мифическое государство, где, согласно Coleridge,

    #+ Kubla Khan построил величественный дворец.


    clear # Очистка экрана.


    echo "0: ${Countries[*]}" # Список элементов несортированного массива.


    number_of_elements=${#Countries[@]}

    let "comparisons = $number_of_elements - 1"


    count=1 # Номер прохода.


    while [ "$comparisons" -gt 0 ] # Начало внешнего цикла

    do


    index=0 # Сбросить индекс перед началом каждого прохода.


    while [ "$index" -lt "$comparisons" ] # Начало внутреннего цикла

    do

    if [ ${Countries[$index]} \> ${Countries[`expr $index + 1`]} ]

    # Если элементы стоят не по порядку...

    # Оператор \> выполняет сравнение ASCII-строк

    #+ внутри одиночных квадратных скобок.


    # if [[ ${Countries[$index]} > ${Countries[`expr $index + 1`]} ]]

    #+ дает тот же результат.

    then

    exchange $index `expr $index + 1` # Поменять местами.

    fi

    let "index += 1"

    done # Конец внутреннего цикла


    let "comparisons -= 1" # Поскольку самый "тяжелый" элемент уже "опустился" на дно,

    #+ то на каждом последующем проходе нужно выполнять на одно сравнение меньше.


    echo

    echo "$count: ${Countries[@]}" # Вывести содержимое массива после каждого прохода.

    echo

    let "count += 1" # Увеличить счетчик проходов.


    done # Конец внешнего цикла


    exit 0

    --

    Можно ли вложить один массив в другой?

    #!/bin/bash

    # Вложенный массив.


    # Автор: Michael Zick.


    AnArray=( $(ls --inode --ignore-backups --almost-all \

    --directory --full-time --color=none --time=status \

    --sort=time -l ${PWD} ) ) # Команды и опции.


    # Пробелы важны . . .


    SubArray=( ${AnArray[@]:11:1} ${AnArray[@]:6:5} )

    # Массив имеет два элемента, каждый из которых, в свою очередь, является массивом.


    echo "Текущий каталог и дата последнего изменения:"

    echo "${SubArray[@]}"


    exit 0


    --

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

    Пример 25-7. Вложенные массивы и косвенные ссылки

    #!/bin/bash

    # embedded-arrays.sh

    # Вложенные массивы и косвенные ссылки.


    # Автор: Dennis Leeuw.

    # Используется с его разрешения.

    # Дополнен автором документа.


    ARRAY1=(

    VAR1_1=value11

    VAR1_2=value12

    VAR1_3=value13

    )


    ARRAY2=(

    VARIABLE="test"

    STRING="VAR1=value1 VAR2=value2 VAR3=value3"

    ARRAY21=${ARRAY1[*]}

    ) # Вложение массива ARRAY1 в массив ARRAY2.


    function print () {

    OLD_IFS="$IFS"

    IFS=$'\n' # Вывод каждого элемента массива

    #+ в отдельной строке.

    TEST1="ARRAY2[*]"

    local ${!TEST1} # Посмотрите, что произойдет, если убрать эту строку.

    # Косвенная ссылка.

    # Позволяет получить доступ к компонентам $TEST1

    #+ в этой функции.


    # Посмотрим, что получилось.

    echo

    echo "\$TEST1 = $TEST1" # Просто имя переменной.

    echo; echo

    echo "{\$TEST1} = ${!TEST1}" # Вывод на экран содержимого переменной.

    # Это то, что дает

    #+ косвенная ссылка.

    echo

    echo "-------------------------------------------"; echo

    echo


    # Вывод переменной

    echo "Переменная VARIABLE: $VARIABLE"


    # Вывод элементов строки

    IFS="$OLD_IFS"

    TEST2="STRING[*]"

    local ${!TEST2} # Косвенная ссылка (то же, что и выше).

    echo "Элемент VAR2: $VAR2 из строки STRING"


    # Вывод элемента массива

    TEST2="ARRAY21[*]"

    local ${!TEST2} # Косвенная ссылка.

    echo "Элемент VAR1_1: $VAR1_1 из массива ARRAY21"

    }


    print

    echo


    exit 0

    --

    С помощью массивов, на языке командной оболочки, вполне возможно реализовать алгоритм Решета Эратосфена. Конечно же -- это очень ресурсоемкая задача. В виде сценария она будет работать мучительно долго, так что лучше всего реализовать ее на каком либо другом, компилирующем, языке программирования, таком как C.

    Пример 25-8. Пример реализации алгоритма Решето Эратосфена

    #!/bin/bash

    # sieve.sh


    # Решето Эратосфена

    # Очень старый алгоритм поиска простых чисел.


    # Этот сценарий выполняется во много раз медленнее

    # чем аналогичная программа на C.


    LOWER_LIMIT=1 # Начиная с 1.

    UPPER_LIMIT=1000 # До 1000.

    # (Вы можете установить верхний предел и выше... если вам есть чем себя занять.)


    PRIME=1

    NON_PRIME=0


    declare -a Primes

    # Primes[] -- массив.


    initialize ()

    {

    # Инициализация массива.


    i=$LOWER_LIMIT

    until [ "$i" -gt "$UPPER_LIMIT" ]

    do

    Primes[i]=$PRIME

    let "i += 1"

    done

    # Все числа в заданном диапазоне считать простыми,

    # пока не доказано обратное.

    }


    print_primes ()

    {

    # Вывод индексов элементов массива Primes[], которые признаны простыми.


    i=$LOWER_LIMIT


    until [ "$i" -gt "$UPPER_LIMIT" ]

    do


    if [ "${Primes[i]}" -eq "$PRIME" ]

    then

    printf "%8d" $i

    # 8 пробелов перед числом придают удобочитаемый табличный вывод на экран.

    fi


    let "i += 1"


    done


    }


    sift () # Отсеивание составных чисел.

    {


    let i=$LOWER_LIMIT+1

    # Нам известно, что 1 -- это простое число, поэтому начнем с 2.


    until [ "$i" -gt "$UPPER_LIMIT" ]

    do


    if [ "${Primes[i]}" -eq "$PRIME" ]

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

    then


    t=$i


    while [ "$t" -le "$UPPER_LIMIT" ]

    do

    let "t += $i "

    Primes[t]=$NON_PRIME

    # Все числа, которые делятся на $t без остатка, пометить как составные.

    done


    fi


    let "i += 1"

    done


    }


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

    initialize

    sift

    print_primes

    # Это называется структурным программированием.


    echo


    exit 0


    # ----------------------------------------------- #

    # Код, приведенный ниже, не исполняется из-за команды exit, стоящей выше.


    # Улучшенная версия, предложенная Stephane Chazelas,

    # работает несколько быстрее.


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


    UPPER_LIMIT=$1 # Из командной строки.

    let SPLIT=UPPER_LIMIT/2 # Рассматривать делители только до середины диапазона.


    Primes=( '' $(seq $UPPER_LIMIT) )


    i=1

    until (( ( i += 1 ) > SPLIT )) # Числа из верхней половины диапазона могут не рассматриваться.

    do

    if [[ -n $Primes[i] ]]

    then

    t=$i

    until (( ( t += i ) > UPPER_LIMIT ))

    do

    Primes[t]=

    done

    fi

    done

    echo ${Primes[*]}


    exit 0

    Сравните этот сценарий с генератором простых чисел, не использующим массивов, Пример A-18.

    --

    Массивы позволяют эмулировать некоторые структуры данных, поддержка которых в Bash не предусмотрена.

    Пример 25-9. Эмуляция структуры "СТЕК" ("первый вошел -- последний вышел")

    #!/bin/bash

    # stack.sh: Эмуляция структуры "СТЕК" ("первый вошел -- последний вышел")


    # Подобно стеку процессора, этот "стек" сохраняет и возвращает данные по принципу

    #+ "первый вошел -- последний вышел".


    BP=100 # Базовый указатель на массив-стек.

    # Дно стека -- 100-й элемент.


    SP=$BP # Указатель вершины стека.

    # Изначально -- стек пуст.


    Data= # Содержимое вершины стека.

    # Следует использовать дополнительную переменную,

    #+ из-за ограничений на диапазон возвращаемых функциями значений.


    declare -a stack


    push() # Поместить элемент на вершину стека.

    {

    if [ -z "$1" ] # А вообще, есть что помещать на стек?

    then

    return

    fi


    let "SP -= 1" # Переместить указатель стека.

    stack[$SP]=$1


    return

    }


    pop() # Снять элемент с вершины стека.

    {

    Data= # Очистить переменную.


    if [ "$SP" -eq "$BP" ] # Стек пуст?

    then

    return

    fi # Это предохраняет от выхода SP за границу стека -- 100,


    Data=${stack[$SP]}

    let "SP += 1" # Переместить указатель стека.

    return

    }


    status_report() # Вывод вспомогательной информации.

    {

    echo "-------------------------------------"

    echo "ОТЧЕТ"

    echo "Указатель стека SP = $SP"

    echo "Со стека был снят элемент \""$Data"\""

    echo "-------------------------------------"

    echo

    }


    # =======================================================

    # А теперь позабавимся.


    echo


    # Попробуем вытолкнуть что-нибудь из пустого стека.

    pop

    status_report


    echo


    push garbage

    pop

    status_report # Втолкнуть garbage, вытолкнуть garbage.


    value1=23; push $value1

    value2=skidoo; push $value2

    value3=FINAL; push $value3


    pop # FINAL

    status_report

    pop # skidoo

    status_report

    pop # 23

    status_report # Первый вошел -- последний вышел!


    # Обратите внимание как изменяется указатель стека на каждом вызове функций push и pop.


    echo

    # =======================================================


    # Упражнения:

    # -----------


    # 1) Измените функцию "push()" таким образом,

    # + чтобы она позволяла помещать на стек несколько значений за один вызов.


    # 2) Измените функцию "pop()" таким образом,

    # + чтобы она позволяла снимать со стека несколько значений за один вызов.


    # 3) Попробуйте написать простейший калькулятор, выполняющий 4 арифметических действия?

    # + используя этот пример.


    exit 0

    --

    Иногда, манипуляции с "индексами" массивов могут потребовать введения переменных для хранения промежуточных результатов. В таких случаях вам предоставляется лишний повод подумать о реализации проекта на более мощном языке программирования, например Perl или C.

    Пример 25-10. Исследование математических последовательностей

    #!/bin/bash


    # Пресловутая "Q-последовательность" Дугласа Хольфштадтера *Douglas Hofstadter):


    # Q(1) = Q(2) = 1

    # Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)), для n>2


    # Это "хаотическая" последовательность целых чисел с непредсказуемым поведением.

    # Первые 20 членов последовательности:

    # 1 1 2 3 3 4 5 5 6 6 6 8 8 8 10 9 10 11 11 12


    # См. книгу Дугласа Хольфштадтера, "Goedel, Escher, Bach: An Eternal Golden Braid",

    # p. 137, ff.


    LIMIT=100 # Найти первые 100 членов последовательности

    LINEWIDTH=20 # Число членов последовательности, выводимых на экран в одной строке


    Q[1]=1 # Первые два члена последовательности равны 1.

    Q[2]=1


    echo

    echo "Q-последовательность [первые $LIMIT членов]:"

    echo -n "${Q[1]} " # Вывести первые два члена последовательности.

    echo -n "${Q[2]} "


    for ((n=3; n <= $LIMIT; n++)) # C-подобное оформление цикла.

    do # Q[n] = Q[n - Q[n-1]] + Q[n - Q[n-2]] для n>2

    # Это выражение необходимо разбить на отдельные действия,

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


    let "n1 = $n - 1" # n-1

    let "n2 = $n - 2" # n-2


    t0=`expr $n - ${Q[n1]}` # n - Q[n-1]

    t1=`expr $n - ${Q[n2]}` # n - Q[n-2]


    T0=${Q[t0]} # Q[n - Q[n-1]]

    T1=${Q[t1]} # Q[n - Q[n-2]]


    Q[n]=`expr $T0 + $T1` # Q[n - Q[n-1]] + Q[n - Q[n-2]]

    echo -n "${Q[n]} "


    if [ `expr $n % $LINEWIDTH` -eq 0 ] # Если выведено очередные 20 членов в строке.

    then # то

    echo # перейти на новую строку.

    fi


    done


    echo


    exit 0


    # Этот сценарий реализует итеративный алгоритм поиска членов Q-последовательности.

    # Рекурсивную реализацию, как более интуитивно понятную, оставляю вам, в качестве упражнения.

    # Внимание: рекурсивный поиск членов последовательности будет занимать *очень* продолжительное время.

    --

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

    Пример 25-11. Эмуляция массива с двумя измерениями

    #!/bin/bash

    # Эмуляция двумерного массива.


    # Второе измерение представлено как последовательность строк.


    Rows=5

    Columns=5


    declare -a alpha # char alpha [Rows] [Columns];

    # Необязательное объявление массива.


    load_alpha ()

    {

    local rc=0

    local index


    for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y

    do

    local row=`expr $rc / $Columns`

    local column=`expr $rc % $Rows`

    let "index = $row * $Rows + $column"

    alpha[$index]=$i # alpha[$row][$column]

    let "rc += 1"

    done


    # Более простой вариант

    # declare -a alpha=( A B C D E F G H I J K L M N O P Q R S T U V W X Y )

    # но при таком объявлении второе измерение массива завуалировано.

    }


    print_alpha ()

    {

    local row=0

    local index


    echo


    while [ "$row" -lt "$Rows" ] # Вывод содержимого массива построчно

    do


    local column=0


    while [ "$column" -lt "$Columns" ]

    do

    let "index = $row * $Rows + $column"

    echo -n "${alpha[index]} " # alpha[$row][$column]

    let "column += 1"

    done


    let "row += 1"

    echo


    done


    # Более простой эквивалент:

    # echo ${alpha[*]} | xargs -n $Columns


    echo

    }


    filter () # Отфильтровывание отрицательных индексов.

    {


    echo -n " "


    if [[ "$1" -ge 0 && "$1" -lt "$Rows" && "$2" -ge 0 && "$2" -lt "$Columns" ]]

    then

    let "index = $1 * $Rows + $2"

    echo -n " ${alpha[index]}" # alpha[$row][$column]

    fi


    }


    rotate () # Поворот массива на 45 градусов

    {

    local row

    local column


    for (( row = Rows; row > -Rows; row-- )) # В обратном порядке.

    do


    for (( column = 0; column < Columns; column++ ))

    do


    if [ "$row" -ge 0 ]

    then

    let "t1 = $column - $row"

    let "t2 = $column"

    else

    let "t1 = $column"

    let "t2 = $column + $row"

    fi


    filter $t1 $t2 # Отфильтровать отрицательный индекс.

    done


    echo; echo


    done


    # Поворот массива выполнен на основе примеров (стр. 143-146)

    # из книги "Advanced C Programming on the IBM PC", автор Herbert Mayer

    # (см. библиографию).


    }


    #-----------------------------------------------------#

    load_alpha # Инициализация массива.

    print_alpha # Вывод на экран.

    rotate # Повернуть на 45 градусов против часовой стрелки.

    #-----------------------------------------------------#


    # Упражнения:

    # -----------

    # 1) Сделайте инициализацию и вывод массива на экран

    # + более простым и элегантным способом.

    #

    # 2) Объясните принцип работы функции rotate().


    exit 0

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

    Более сложный пример эмуляции двумерного массива вы найдете в Пример A-11.


    Глава 26. Файлы

    сценарии начальной загрузки

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

    /etc/profile

    Настройки системы по-умолчанию, главным образом настраивается окружение командной оболочки (все Bourne-подобные оболочки, не только Bash[ 55 ])

    /etc/bashrc

    функции и псевдонимы Bash

    $HOME/.bash_profile

    пользовательские настройки окружения Bash, находится в домашнем каталоге у каждого пользователя (локальная копия файла /etc/profile)

    $HOME/.bashrc

    пользовательский файл инициализации Bash, находится в домашнем каталоге у каждого пользователя (локальная копия файла /etc/bashrc). См. Приложение Gпример файла .bashrc.

    Сценарий выхода из системы (logout)

    $HOME/.bash_logout

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


    Глава 27. /dev и /proc

    Как правило, Linux или UNIX система имеет два каталога специального назначения: /dev и /proc.


    27.1. /dev

    Каталог /dev содержит файлы физических устройств, которые могут входить в состав аппаратного обеспечения компьютера[ 56 ]. Каждому из разделов не жестком диске соответствует свой файл-устройство в каталоге /dev, информация о которых может быть получена простой командой df.

    bash$ df

    Filesystem 1k-blocks Used Available Use%

    Mounted on

    /dev/hda6 495876 222748 247527 48% /

    /dev/hda1 50755 3887 44248 9% /boot

    /dev/hda8 367013 13262 334803 4% /home

    /dev/hda5 1714416 1123624 503704 70% /usr


    Кроме того, каталог /dev содержит loopback-устройства ("петлевые" устройства), например /dev/loop0. С помощью такого устройства можно представить обычный файл как блочное устройство ввода/вывода[ 57 ]. Это позволяет монтировать целые файловые системы, находящиеся в отдельных больших файлах. См. Пример 13-6 и Пример 13-5.

    Отдельные псевдоустройства в /dev имеют особое назначение, к таким устройствам можно отнести /dev/null, /dev/zero и /dev/urandom.

    27.2. /proc

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

    bash$ cat /proc/devices

    Character devices:

    1 mem

    2 pty

    3 ttyp

    4 ttyS

    5 cua

    7 vcs

    10 misc

    14 sound

    29 fb

    36 netlink

    128 ptm

    136 pts

    162 raw

    254 pcmcia


    Block devices:

    1 ramdisk

    2 fd

    3 ide0

    9 md


    bash$ cat /proc/interrupts

    CPU0

    0: 84505 XT-PIC timer

    1: 3375 XT-PIC keyboard

    2: 0 XT-PIC cascade

    5: 1 XT-PIC soundblaster

    8: 1 XT-PIC rtc

    12: 4231 XT-PIC PS/2 Mouse

    14: 109373 XT-PIC ide0

    NMI: 0

    ERR: 0


    bash$ cat /proc/partitions

    major minor #blocks name rio rmerge rsect ruse wio wmerge wsect wuse running use aveq


    3 0 3007872 hda 4472 22260 114520 94240 3551 18703 50384 549710 0 111550 644030

    3 1 52416 hda1 27 395 844 960 4 2 14 180 0 800 1140

    3 2 1 hda2 0 0 0 0 0 0 0 0 0 0 0

    3 4 165280 hda4 10 0 20 210 0 0 0 0 0 210 210

    ...


    bash$ cat /proc/loadavg

    0.13 0.42 0.27 2/44 1119


    Сценарии командной оболочки могут извлекать необходимую информацию из соответствующих файлов в каталоге /proc.[ 58 ]

    bash$ cat /proc/filesystems | grep iso9660

    iso9660



    kernel_version=$( awk '{ print $3 }' /proc/version )


    CPU=$( awk '/model name/ {print $4}' < /proc/cpuinfo )


    if [ $CPU = Pentium ]

    then

    выполнить_ряд_специфичных_команд

    ...

    else

    выполнить_ряд_других_специфичных_команд

    ...

    fi


    В каталоге /proc вы наверняка заметите большое количество подкаталогов, с не совсем обычными именами, состоящими только из цифр. Каждый из них соответствует исполняющемуся процессу, а имя каталога -- это ID (идентификатор) процесса. Внутри каждого такого подкаталога находится ряд файлов, в которых содержится полезная информация о соответствующих процессах. Файлы stat и status хранят статистику работы процесса, cmdline -- команда, которой был запущен процесс, exe -- символическая ссылка на исполняемый файл программы. Здесь же вы найдете ряд других файлов, но, с точки зрения написания сценариев, они не так интересны, как эти четыре.

    Пример 27-1. Поиск файла программы по идентификатору процесса

    #!/bin/bash

    # pid-identifier.sh: Возвращает полный путь к исполняемому файлу программы по идентификатору процесса (pid).


    ARGNO=1 # Число, ожидаемых из командной строки, аргументов.

    E_WRONGARGS=65

    E_BADPID=66

    E_NOSUCHPROCESS=67

    E_NOPERMISSION=68

    PROCFILE=exe


    if [ $# -ne $ARGNO ]

    then

    echo "Порядок использования: `basename $0` PID-процесса" >&2 # Сообщение об ошибке на >stderr.

    exit $E_WRONGARGS

    fi


    ps ax


    pidno=$( ps ax | grep $1 | awk '{ print $1 }' | grep $1 )

    # Проверка наличия процесса с заданным pid в списке, выданном командой "ps", поле #1.

    # Затем следует убедиться, что этот процесс не был запущен этим сценарием ('ps').

    # Это делает последний "grep $1".

    if [ -z "$pidno" ] # Если после фильтрации получается пустая строка,

    then # то это означает, что в системе нет процесса с заданым pid.

    echo "Нет такого процесса."

    exit $E_NOSUCHPROCESS

    fi


    # Альтернативный вариант:

    # if ! ps $1 > /dev/null 2>&1

    # then # в системе нет процесса с заданым pid.

    # echo "Нет такого процесса."

    # exit $E_NOSUCHPROCESS

    # fi


    if [ ! -r "/proc/$1/$PROCFILE" ] # Проверить право на чтение.

    then

    echo "Процесс $1 найден, однако..."

    echo "у вас нет права на чтение файла /proc/$1/$PROCFILE."

    exit $E_NOPERMISSION # Обычный пользователь не имеет прав

    # на доступ к некоторым файлам в каталоге /proc.

    fi


    # Последние две проверки могут быть заменены на:

    # if ! kill -0 $1 > /dev/null 2>&1 # '0' -- это не сигнал, но

    # команда все равно проверит наличие

    # процесса-получателя.

    # then echo "Процесс с данным PID не найден, либо вы не являетесь его владельцем" >&2

    # exit $E_BADPID

    # fi


    exe_file=$( ls -l /proc/$1 | grep "exe" | awk '{ print $11 }' )

    # Или exe_file=$( ls -l /proc/$1/exe | awk '{print $11}' )

    #

    # /proc/pid-number/exe -- это символическая ссылка

    # на исполняемый файл работающей программы.


    if [ -e "$exe_file" ] # Если файл /proc/pid-number/exe существует...

    then # то существует и соответствующий процесс.

    echo "Исполняемый файл процесса #$1: $exe_file."

    else

    echo "Нет такого процесса."

    fi


    # В большинстве случаев, этот, довольно сложный сценарий, может быть заменен командой

    # ps ax | grep $1 | awk '{ print $5 }'

    # В большинстве, но не всегда...

    # поскольку пятое поле листинга,выдаваемого командой 'ps', это argv[0] процесса,

    # а не путь к исполняемому файлу.

    #

    # Однако, оба следующих варианта должны работать безотказно.

    # find /proc/$1/exe -printf '%l\n'

    # lsof -aFn -p $1 -d txt | sed -ne 's/^n//p'


    # Автор последнего комментария: Stephane Chazelas.


    exit 0

    Пример 27-2. Проверка состояния соединения

    #!/bin/bash


    PROCNAME=pppd # демон ppp

    PROCFILENAME=status # Что смотреть.

    NOTCONNECTED=65

    INTERVAL=2 # Период проверки -- раз в 2 секунды.


    pidno=$( ps ax | grep -v "ps ax" | grep -v grep | grep $PROCNAME | awk '{ print $1 }' )

    # Найти идентификатор процесса 'pppd', 'ppp daemon'.

    # По пути убрать из листинга записи о процессах, порожденных сценарием.

    #

    # Однако, как отмечает Oleg Philon,

    #+ Эта последовательность команд может быть заменена командой "pidof".

    # pidno=$( pidof $PROCNAME )

    #

    # Мораль:

    #+ Когда последовательность команд становится слишком сложной,

    #+ это повод к тому, чтобы поискать более короткий вариант.


    if [ -z "$pidno" ] # Если получилась пустая строка, значит процесс не запущен.

    then

    echo "Соединение не установлено."

    exit $NOTCONNECTED

    else

    echo "Соединение установлено."; echo

    fi


    while [ true ] # Бесконечный цикл.

    do


    if [ ! -e "/proc/$pidno/$PROCFILENAME" ]

    # Пока работает процесс, файл "status" существует.

    then

    echo "Соединение разорвано."

    exit $NOTCONNECTED

    fi


    netstat -s | grep "packets received" # Получить некоторые сведения о соединении.

    netstat -s | grep "packets delivered"


    sleep $INTERVAL

    echo; echo


    done


    exit 0


    # Как обычно, этот сценарий может быть остановлен комбинацией клавиш Control-C.


    # Упражнение:

    # ----------

    # Добавьте возможность завершения работы сценария, по нажатии на клавишу "q".

    # Это сделает скрипт более жружественным к пользователю.

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


    Глава 28. /dev/zero и /dev/null

    /dev/null

    Псевдоустройство /dev/null -- это, своего рода, "черная дыра" в системе. Это, пожалуй, самый близкий смысловой эквивалент. Все, что записывается в этот файл, "исчезает" навсегда. Попытки записи или чтения из этого файла не дают, ровным счетом, никакого результата. Тем не менее, псевдоустройство /dev/null вполне может пригодиться.

    Подавление вывода на stdout.

    cat $filename >/dev/null

    # Содержимое файла $filename не появится на stdout.


    Подавление вывода на stderr (from Пример 12-2).

    rm $badname 2>/dev/null

    # Сообщение об ошибке "уйдет в никуда".


    Подавление вывода, как на stdout, так и на stderr.

    cat $filename 2>/dev/null >/dev/null

    # Если "$filename" не будет найден, то вы не увидите сообщения об ошибке.

    # Если "$filename" существует, то вы не увидите его содержимое.

    # Таким образом, вышеприведенная команда ничего не выводит на экран.

    #

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

    #+ и нежелательно выводить результат работы команды на экран.

    #

    # cat $filename &>/dev/null

    # дает тот же результат, автор примечания Baris Cicek.


    Удаление содержимого файла, сохраняя, при этом, сам файл, со всеми его правами доступа (очистка файла) (из Пример 2-1 и Пример 2-2):

    cat /dev/null > /var/log/messages

    # : > /var/log/messages дает тот же эффект, но не порождает дочерний процесс.


    cat /dev/null > /var/log/wtmp


    Автоматическая очистка содержимого системного журнала (logfile) (особенно хороша для борьбы с надоедливыми рекламными идентификационными файлами ("cookies")):

    Пример 28-1. Удаление cookie-файлов

    if [ -f ~/.netscape/cookies ] # Удалить, если имеются.

    then

    rm -f ~/.netscape/cookies

    fi


    ln -s /dev/null ~/.netscape/cookies

    # Теперь, все cookie-файлы, вместо того, чтобы сохраняться на диске, будут "вылетать в трубу".

    /dev/zero

    Подобно псевдоустройству /dev/null, /dev/zero так же является псевдоустройством, с той лишь разницей, что содержит нули. Информация, выводимая в этот файл, так же бесследно исчезает. Чтение нулей из этого файла может вызвать некоторые затруднения, однако это можно сделать, к примеру, с помощью команды od или шестнадцатиричного редактора. В основном, /dev/zero используется для создания заготовки файла с заданой длиной.

    Пример 28-2. Создание файла подкачки (swapfile), с помощью /dev/zero

    #!/bin/bash


    # Создание файла подкачки.

    # Этот сценарий должен запускаться с правами root.


    ROOT_UID=0 # Для root -- $UID 0.

    E_WRONG_USER=65 # Не root?


    FILE=/swap

    BLOCKSIZE=1024

    MINBLOCKS=40

    SUCCESS=0


    if [ "$UID" -ne "$ROOT_UID" ]

    then

    echo; echo "Этот сценарий должен запускаться с правами root."; echo

    exit $E_WRONG_USER

    fi


    blocks=${1:-$MINBLOCKS} # По-умолчанию -- 40 блоков,

    #+ если размер не задан из командной строки.

    # Ниже приводится эквивалентный набор команд.

    # --------------------------------------------------

    # if [ -n "$1" ]

    # then

    # blocks=$1

    # else

    # blocks=$MINBLOCKS

    # fi

    # --------------------------------------------------


    if [ "$blocks" -lt $MINBLOCKS ]

    then

    blocks=$MINBLOCKS # Должно быть как минимум 40 блоков.

    fi


    echo "Создание файла подкачки размером $blocks блоков (KB)."

    dd if=/dev/zero of=$FILE bs=$BLOCKSIZE count=$blocks # "Забить" нулями.


    mkswap $FILE $blocks # Назначить как файл подкачки.

    swapon $FILE # Активировать.


    echo "Файл подкачки создан и активирован."


    exit $SUCCESS

    Еще одна область применения /dev/zero -- "очистка" специального файла заданного размера, например файлов, монтируемых как loopback-устройства (см. Пример 13-6) или для безопасного удаления файла (см. Пример 12-42).

    Пример 28-3. Создание электронного диска

    #!/bin/bash

    # ramdisk.sh


    # "электронный диск" -- это область в ОЗУ компьютера

    #+ с которой система взаимодействует как с файловой системой.

    # Основное преимущество -- очень высокая скорость чтения/записи.

    # Недостатки -- энергозависимость, уменьшение объема ОЗУ, доступного системе,

    # относительно небольшой размер.

    #

    # Чем хорош электронный диск?

    # При хранении наборов данных, таких как таблиц баз данных или словарей, на электронном диске

    #+ вы получаете высокую скорость работы с этими наборами, поскольку время доступа к ОЗУ

    # неизмеримо меньше времени доступа к жесткому диску.


    E_NON_ROOT_USER=70 # Сценарий должен запускаться с правами root.

    ROOTUSER_NAME=root


    MOUNTPT=/mnt/ramdisk

    SIZE=2000 # 2K блоков (измените, если это необходимо)

    BLOCKSIZE=1024 # размер блока -- 1K (1024 байт)

    DEVICE=/dev/ram0 # Первое устройство ram


    username=`id -nu`

    if [ "$username" != "$ROOTUSER_NAME" ]

    then

    echo "Сценарий должен запускаться с правами root."

    exit $E_NON_ROOT_USER

    fi


    if [ ! -d "$MOUNTPT" ] # Проверка наличия точки монтирования,

    then #+ благодаря этой проверке, при повторных запусках сценария

    mkdir $MOUNTPT #+ ошибки возникать не будет.

    fi


    dd if=/dev/zero of=$DEVICE count=$SIZE bs=$BLOCKSIZE # Очистить электронный диск.

    mke2fs $DEVICE # Создать файловую систему ext2.

    mount $DEVICE $MOUNTPT # Смонтировать.

    chmod 777 $MOUNTPT # Сделать электронный диск доступным для обычных пользователей.

    # Но при этом, только root сможет его отмонтировать.


    echo "Электронный диск \"$MOUNTPT\" готов к работе."

    # Теперь электронный диск доступен для любого пользователя в системе.


    # Внимание! Электронный диск -- это энергозависимое устройство! Все данные, хранящиеся на нем,

    #+ будут утеряны при остановке или перезагрузке системы.

    # Если эти данные представляют для вас интерес, то сохраняйте их копии в обычном каталоге.


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

    # Простое монтирование /mnt/ramdisk, без выполнения подготовительных действий, не будет работать.


    exit 0

    Глава 29. Отладка сценариев

    Командная оболочка Bash не имеет своего отладчика, и не имеет даже каких либо отладочных команд или конструкций[ 59 ]. Синтаксические ошибки или опечатки часто вызывают сообщения об ошибках, которые которые практически никак не помогают при отладке.

    Пример 29-1. Сценарий, содержащий ошибку

    #!/bin/bash

    # ex74.sh


    # Этот сценарий содержит ошибку.


    a=37


    if [$a -gt 27 ]

    then

    echo $a

    fi


    exit 0

    В результате исполнения этого сценария вы получите такое сообщение:

    ./ex74.sh: [37: command not found

    Что в этом сценарии может быть неправильно (подсказка: после ключевого слова if)?

    Пример 29-2. Пропущено ключевое слово

    #!/bin/bash

    # missing-keyword.sh:

    # Какое сообщение об ошибке будет выведено, при попытке запустить этот сценарий?


    for a in 1 2 3

    do

    echo "$a"

    # done # Необходимое ключевое слово 'done' закомментировано.


    exit 0

    На экране появится сообщение:

    missing-keyword.sh: line 11: syntax error: unexpected end of file

    Обратите внимание, сообщение об ошибке будет содержать номер не той строки, в которой возникла ошибка, а той, в которой Bash точно установил наличие ошибочной ситуации.

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

    А что делать, если сценарий работает, но не так как ожидалось? Вот пример весьма распространенной логической ошибки.

    Пример 29-3. test24

    #!/bin/bash


    # Ожидается, что этот сценарий будет удалять в текущем каталоге

    #+ все файлы, имена которых содержат пробелы.

    # Но он не работает. Почему?


    badname=`ls | grep ' '`


    # echo "$badname"


    rm "$badname"


    exit 0

    Попробуйте найти ошибку, раскомментарив строку echo "$badname". Инструкция echo очень полезна при отладке сценариев, она позволяет узнать -- действительно ли вы получаете то, что ожидали получить.

    В данном конкретном случае, команда rm "$badname" не дает желаемого результата потому, что переменная $badname взята в кавычки. В результате, rm получает единственный аргумент (т.е. команда будет считать, что получила имя одного файла). Частично эта проблема может быть решена за счет удаления кавычек вокруг $badname и установки переменной $IFS так, чтобы она содержала только символ перевода строки, IFS=$'\n'. Однако, существует более простой способ выполнить эту задачу.

    # Правильный способ удаления файлов, в чьих именах содержатся пробелы.

    rm *\ *

    rm *" "*

    rm *' '*

    # Спасибо S.C.


    В общих чертах, ошибочными можно считать такие сценарии, которые

    1. "сыплют" сообщениями о "синтаксических ошибках" или

    2. запускаются, но работают не так как ожидалось (логические ошибки).

    3. запускаются, делают то, что требуется, но имеют побочные эффекты (логическая бомба).


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

    1. команда echo, в критических точках сценария, поможет отследить состояние переменных и отобразить ход исполнения.

    2. команда-фильтр tee, которая поможет проверить процессы и потоки данных в критических местах.

    3. ключи -n -v -x

    sh -n scriptname -- проверит наличие синтаксических ошибок, не запуская сам сценарий. Того же эффекта можно добиться, вставив в сценарий команду set -n или set -o noexec. Обратите внимание, некоторые из синтаксических ошибок не могут быть выявлены таким способом.

    sh -v scriptname -- выводит каждую команду прежде, чем она будет выполнена. Того же эффекта можно добиться, вставив в сценарий команду set -v или set -o verbose.

    Ключи -n и -v могут употребляться совместно: sh -nv scriptname.

    sh -x scriptname -- выводит, в краткой форме, результат исполнения каждой команды. Того же эффекта можно добиться, вставив в сценарий команду set -x или set -o xtrace.

    Вставив в сценарий set -u или set -o nounset, вы будете получать сообщение об ошибке unbound variable всякий раз, когда будет производиться попытка обращения к необъявленной переменной.

    4. Функция "assert", предназначенная для проверки переменных или условий, в критических точках сценария. (Эта идея заимствована из языка программирования C.)

    Пример 29-4. Проверка условия с помощью функции "assert"

    #!/bin/bash

    # assert.sh


    assert () # Если условие ложно,

    { #+ выход из сценария с сообщением об ошибке.

    E_PARAM_ERR=98

    E_ASSERT_FAILED=99


    if [ -z "$2" ] # Недостаточное количество входных параметров.

    then

    return $E_PARAM_ERR

    fi


    lineno=$2


    if [ ! $1 ]

    then

    echo "Утверждение ложно: \"$1\""

    echo "Файл: \"$0\", строка: $lineno"

    exit $E_ASSERT_FAILED

    # else

    # return

    # и продолжить исполнение сценария.

    fi

    }


    a=5

    b=4

    condition="$a -lt $b" # Сообщение об ощибке и завершение сценария.

    # Попробуйте поменять условие "condition"

    #+ на что нибудь другое и

    #+ посмотреть -- что получится.


    assert "$condition" $LINENO

    # Сценарий продолжит работу только в том случае, если утверждение истинно.


    # Прочие команды.

    # ...

    echo "Эта строка появится на экране только если утверждение истинно."

    # ...

    # Прочие команды.

    # ...


    exit 0

    5. Ловушка на выхто в этом сценарии может быть неправильно (подсказка: после ключевого словоде.

    Команда exit, в сценарии, порождает сигнал 0, по которому процесс завершает работу, т.е. -- сам сценарий[ 60 ]. Часто бывает полезным по выходу из сценария выдать "распечатку" переменных.


    Установка ловушек на сигналы

    trap

    Определяет действие при получении сигнала; так же полезна при отладке.

    Сигнал (signal) -- это просто сообщение, передается процессу либо ядром, либо другим процессом, чтобы побудить процесс выполнить какие либо действия (обычно -- завершить работу). Например, нажатие на Control-C, вызывает передачу сигнала SIGINT, исполняющейся программе.

    trap '' 2

    # Игнорировать прерывание 2 (Control-C), действие по сигналу не указано.


    trap 'echo "Control-C disabled."' 2

    # Сообщение при нажатии на Control-C.


    Пример 29-5. Ловушка на выходе

    #!/bin/bash


    trap 'echo Список переменных --- a = $a b = $b' EXIT

    # EXIT -- это название сигнала, генерируемого при выходе из сценария.


    a=39


    b=36


    exit 0

    # Примечательно, что если закомментировать команду 'exit',

    # то это никак не скажется на работе сценария,

    # поскольку "выход" из сценария происходит в любом случае.

    Пример 29-6. Удаление временного файла при нажатии на Control-C

    #!/bin/bash

    # logon.sh: Сценарий, написаный "на скорую руку", контролирует вход в режим on-line.


    TRUE=1

    LOGFILE=/var/log/messages

    # Обратите внимание: $LOGFILE должен быть доступен на чтение (chmod 644 /var/log/messages).

    TEMPFILE=temp.$$

    # "Уникальное" имя для временного файла, где расширение в имени -- это pid процесса-сценария.

    KEYWORD=address

    # При входе, в файл /var/log/messages,

    # добавляется строка "remote IP address xxx.xxx.xxx.xxx"

    ONLINE=22

    USER_INTERRUPT=13

    CHECK_LINES=100

    # Количество проверяемых строк.


    trap 'rm -f $TEMPFILE; exit $USER_INTERRUPT' TERM INT

    # Удалить временный файл, когда сценарий завершает работу по control-c.


    echo


    while [ $TRUE ] #Бесконечный цикл.

    do

    tail -$CHECK_LINES $LOGFILE> $TEMPFILE

    # Последние 100 строк из системного журнала переписать во временный файл.

    # Совершенно необходимо, т.к. новейшие версии ядер генерируют много сообщений при входе.

    search=`grep $KEYWORD $TEMPFILE`

    # Проверить наличие фразы "address",

    # свидетельствующей об успешном входе.


    if [ ! -z "$search" ] # Кавычки необходимы, т.к. переменная может содержать пробелы.

    then

    echo "On-line"

    rm -f $TEMPFILE # Удалить временный файл.

    exit $ONLINE

    else

    echo -n "." # ключ -n подавляет вывод символа перевода строки,

    # так вы получите непрерывную строку точек.

    fi


    sleep 1

    done


    # Обратите внимание: если изменить содержимое переменной KEYWORD

    # на "Exit", то сценарий может использоваться для контроля

    # неожиданного выхода (logoff).


    exit 0


    # Nick Drage предложил альтернативный метод:


    while true

    do ifconfig ppp0 | grep UP 1> /dev/null && echo "соединение установлено" && exit 0

    echo -n "." # Печать последовательности точек (.....), пока соединение не будет установлено.

    sleep 2

    done


    # Проблема: Нажатия Control-C может оказаться недостаточным, чтобы завершить этот процесс.

    # (Точки продолжают выводиться на экран.)

    # Упражнение: Исправьте этот недостаток.


    # Stephane Chazelas предложил еще одну альтернативу:


    CHECK_INTERVAL=1


    while ! tail -1 "$LOGFILE" | grep -q "$KEYWORD"

    do echo -n .

    sleep $CHECK_INTERVAL

    done

    echo "On-line"


    # Упражнение: Найдите сильные и слабые стороны

    # каждого из этих подходов.

    Аргумент DEBUG, команды trap, заставляет сценарий выполнять указанное действие после выполнения каждой команды. Это можно использовать для трассировки переменных.

    Пример 29-7. Трассировка переменной

    #!/bin/bash


    trap 'echo "VARIABLE-TRACE> $LINENO: \$variable = \"$variable\""' DEBUG

    # Выводить значение переменной после исполнения каждой команды.


    variable=29


    echo "Переменная \"\$variable\" инициализирована числом $variable."


    let "variable *= 3"

    echo "Значение переменной \"\$variable\" увеличено в 3 раза."


    # Конструкция "trap 'commands' DEBUG" может оказаться очень полезной

    # при отладке больших и сложных скриптов,

    # когда размещение множества инструкций "echo $variable"

    # может потребовать достаточно большого времени.


    # Спасибо Stephane Chazelas.


    exit 0


    Конструкция trap '' SIGNAL (две одиночных кавычки) -- запрещает SIGNAL для оставшейся части сценария. Конструкция trap SIGNAL -- восстанавливает действие сигнала SIGNAL. Эти конструкции могут использоваться для защиты критических участков сценария от нежелательного прерывания.

    trap '' 2 # Сигнал 2 (Control-C) -- запрещен.

    command

    command

    command

    trap 2 # Разрешение реакции на Control-C



    Глава 30. Необязательные параметры (ключи)

    Необязательные параметры -- это дополнительные ключи (опции), которые оказывают влияние на поведение сценария и/или командной оболочки.

    Команда set позволяет задавать дополнительные опции прямо внутри сценария. В том месте сценария, где необходимо, чтобы та или иная опция вступила в силу, вставьте такую конструкцию set -o option-name, или в более короткой форме -- set -option-abbrev. Эти две формы записи совершенно идентичны по своему действию.

    #!/bin/bash


    set -o verbose

    # Вывод команд перед их исполнением.


    #!/bin/bash


    set -v

    # Имеет тот же эффект, что и выше.


    Для того, чтобы отключить действие той или иной опции, следует вставить конструкцию set +o option-name, или set +option-abbrev.

    #!/bin/bash


    set -o verbose

    # Вывод команд перед их исполнением.

    command

    ...

    command


    set +o verbose

    # Запретить вывод команд перед их исполнением.

    command

    # команда не выводится.


    set -v

    # Вывод команд перед их исполнением.

    command

    ...

    command


    set +v

    # Запретить вывод команд перед их исполнением.

    command


    exit 0


    Как вариант установки опций, можно предложить указывать их в заголовке сценария (в строке sha-bang) -- #!.

    #!/bin/bash -x

    #

    # Далее следует текст сценария.


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

    bash -v script-name

    bash -o verbose script-name

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

    Таблица 30-1. Ключи Bash

    Краткое имяПолное имяОписание
    -CnoclobberПредотвращает перезапись файла в операциях перенаправления вывода (не распространяется на конвейеры (каналы) -- >|)
    -D(нет)Выводит список строк в двойных кавычках, которым предшествует символ $, сам сценарий не исполняется
    -aallexportЭкспорт всех, определенных в сценарии, переменных
    -bnotifyВыводит уведомление по завершении фоновой задачи (job) (довольно редко используется в сценариях)
    -c ...(нет)Читает команды из ...
    -fnoglobПодстановка имен файлов (globbing) запрещена
    -iinteractiveСценарий запускается в интерактивном режиме
    -pprivilegedСценарий запускается как "suid" (осторожно!)
    -rrestrictedСценарий запускается в ограниченном режиме (см. Глава 20).
    -unounsetПри попытке обращения к неопределенным переменным, выдает сообщение об ошибке и прерывает работу сценария
    -vverboseВыводит на stdout каждую команду прежде, чем она будет исполнена
    -xxtraceПодобна -v, но выполняет подстановку команд
    -eerrexitПрерывает работу сценария при появлении первой же ошибки (когда команда возвращает ненулевой код завершения)
    -nnoexecЧитает команды из сценария, но не исполняет их (проверка синтаксиса)
    -sstdinЧитает команды с устройства stdin
    -t(нет)Выход после исполнения первой команды
    -(нет)Конец списка ключей (опций), последующие аргументы будут восприниматься как позиционные параметры.
    --(нет)Эквивалент предыдущей опции (-).

    Глава 31. Широко распространенные ошибки

    Turandot: Gli enigmi sono tre, la morte una!

    Caleph: No, no! Gli enigmi sono tre, una la vita!

    Puccini

    Использование зарезервированных слов и служебных символов в качестве имен переменных.

    case=value0 # Может вызвать проблемы.

    23skidoo=value1 # Тоже самое.

    # Имена переменных, начинающиеся с цифр, зарезервированы командной оболочкой.

    # Если имя переменной начинается с символа подчеркивания: _23skidoo=value1, то это не считается ошибкой.


    # Однако... если имя переменной состоит из единственного символа подчеркивания, то это ошибка.

    _=25

    echo $_ # $_ -- это внутренняя переменная.


    xyz((!*=value2 # Вызывает серьезные проблемы.


    Использование дефиса, и других зарезервированных символов, в именах переменных.

    var-1=23

    # Вместо такой записи используйте 'var_1'.


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

    do_something ()

    {

    echo "Эта функция должна что-нибудь сделать с \"$1\"."

    }


    do_something=do_something


    do_something do_something


    # Все это будет работать правильно, но слишком уж запутанно.


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

    var1 = 23 # Правильный вариант: 'var1=23'.

    # В вышеприведенной строке Bash будет трактовать "var1" как имя команды

    # с аргументами "=" и "23".


    let c = $a - $b # Правильный вариант: 'let c=$a-$b' или 'let "c = $a - $b"'


    if [ $a -le 5] # Правильный вариант: if [ $a -le 5 ]

    # if [ "$a" -le 5 ] еще лучше.

    # [[ $a -le 5 ]] тоже верно.


    Ошибочным является предположение о том, что неинициализированные переменные содержат "ноль". Неинициализированные переменные содержат "пустое" (null) значение, а не ноль.

    #!/bin/bash


    echo "uninitialized_var = $uninitialized_var"

    # uninitialized_var =


    Часто программисты путают операторы сравнения = и -eq. Запомните, оператор = используется для сравнения строковых переменных, а -eq -- для сравнения целых чисел.

    if [ "$a" = 273 ] # Как вы полагаете? $a -- это целое число или строка?

    if [ "$a" -eq 273 ] # Если $a -- целое число.


    # Иногда, такого рода ошибка никак себя не проявляет.

    # Однако...


    a=273.0 # Не целое число.


    if [ "$a" = 273 ]

    then

    echo "Равны."

    else

    echo "Не равны."

    fi # Не равны.


    # тоже самое и для a=" 273" и a="0273".


    # Подобные проблемы возникают при использовании "-eq" со строковыми значениями.


    if [ "$a" -eq 273.0 ]

    then

    echo "a = $a'

    fi # Исполнение сценария прерывается по ошибке.

    # test.sh: [: 273.0: integer expression expected


    Ошибки при сравнении целых чисел и строковых значений.

    #!/bin/bash

    # bad-op.sh


    number=1


    while [ "$number" < 5 ] # Неверно! должно быть while [ "number" -lt 5 ]

    do

    echo -n "$number "

    let "number += 1"

    done


    # Этот сценарий генерирует сообщение об ошибке:

    # bad-op.sh: 5: No such file or directory


    Иногда, в операциях проверки, с использованием квадратных скобок ([ ]), переменные необходимо брать в двойные кавычки. См. Пример 7-6, Пример 16-4 и Пример 9-6.

    Иногда сценарий не в состоянии выполнить команду из-за нехватки прав доступа. Если пользователь не сможет запустить команду из командной строки, то эта команда не сможет быть запущена и из сценария. Попробуйте изменить атрибуты команды, возможно вам придется установить бит suid.

    Использование символа - в качестве оператора перенаправления (каковым он не является) может приводить к неожиданным результатам.

    command1 2> - | command2 # Попытка передать сообщения об ошибках команде command1 через конвейер...

    # ...не будет работать.


    command1 2>& - | command2 # Так же бессмысленно.


    Спасибо S.C.


    Использование функциональных особенностей Bash версии 2 или выше, может привести к аварийному завершению сценария, работающему под управлением Bash версии 1.XX.

    #!/bin/bash


    minimum_version=2

    # Поскольку Chet Ramey постоянно развивает Bash,

    # вам может потребоваться указать другую минимально допустимую версию $minimum_version=2.XX.

    E_BAD_VERSION=80


    if [ "$BASH_VERSION" \< "$minimum_version" ]

    then

    echo "Этот сценарий должен исполняться под управлением Bash, версии $minimum или выше."

    echo "Настоятельно рекомендуется обновиться."

    exit $E_BAD_VERSION

    fi


    ...


    Использование специфических особенностей Bash может приводить к аварийному завершению сценария в Bourne shell (#!/bin/sh). Как правило, в Linux дистрибутивах, sh является псевдонимом bash, но это не всегда верно для UNIX-систем вообще.

    Сценарий, в котором строки отделяются друг от друга в стиле MS-DOS (\r\n), будет завершаться аварийно, поскольку комбинация #!/bin/bash\r\n считается недопустимой. Исправить эту ошибку можно простым удалением символа \r из сценария.

    #!/bin/bash


    echo "Начало"


    unix2dos $0 # Сценарий переводит символы перевода строки в формат DOS.

    chmod 755 $0 # Восстановление прав на запуск.

    # Команда 'unix2dos' удалит право на запуск из атрибутов файла.


    ./$0 # Попытка запустить себя самого.

    # Но это не сработает из-за того, что теперь строки отделяются

    # друг от друга в стиле DOS.


    echo "Конец"


    exit 0


    Сценарий, начинающийся с #!/bin/sh, не может работать в режиме полной совместимости с Bash. Некоторые из специфических функций, присущих Bash, могут оказаться запрещенными к использованию. Сценарий, который требует полного доступа ко всем расширениям, имеющимся в Bash, должен начинаться строкой #!/bin/bash.

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

    WHATEVER=/home/bozo

    export WHATEVER

    exit 0

    bash$ echo $WHATEVER


    bash$

    Будьте уверены -- при выходе в командную строку переменная $WHATEVER останется неинициализированной.

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

    Пример 31-1. Западня в подоболочке

    #!/bin/bash

    # Западня в подоболочке.


    outer_variable=внешняя_переменная

    echo

    echo "outer_variable = $outer_variable"

    echo


    (

    # Запуск в подоболочке


    echo "внутри подоболочки outer_variable = $outer_variable"

    inner_variable=внутренняя_переменная # Инициализировать

    echo "внутри подоболочки inner_variable = $inner_variable"

    outer_variable=внутренняя_переменная # Как думаете? Изменит внешнюю переменную?

    echo "внутри подоболочки outer_variable = $outer_variable"


    # Выход из подоболочки

    )


    echo

    echo "за пределами подоболочки inner_variable = $inner_variable" # Ничего не выводится.

    echo "за пределами подоболочки outer_variable = $outer_variable" # внешняя_переменная.

    echo


    exit 0

    Передача вывода от echo по конвейеру команде read может давать неожиданные результаты. В этом сценарии, команда read действует так, как будто бы она была запущена в подоболочке. Вместо нее лучше использовать команду set (см. Пример 11-14).

    Пример 31-2. Передача вывода от команды echo команде read, по конвейеру

    #!/bin/bash

    # badread.sh:

    # Попытка использования 'echo' и 'read'

    #+ для записи значений в переменные.


    a=aaa

    b=bbb

    c=ccc


    echo "один два три" | read a b c

    # Попытка записать значения в переменные a, b и c.


    echo

    echo "a = $a" # a = aaa

    echo "b = $b" # b = bbb

    echo "c = $c" # c = ccc

    # Присваивания не произошло.


    # ------------------------------


    # Альтернативный вариант.


    var=`echo "один два три"`

    set -- $var

    a=$1; b=$2; c=$3


    echo "-------"

    echo "a = $a" # a = один

    echo "b = $b" # b = два

    echo "c = $c" # c = три

    # На этот раз все в порядке.


    # ------------------------------


    # Обратите внимание: в подоболочке 'read', для первого варианта, переменные присваиваются нормально.

    # Но только в подоболочке.


    a=aaa # Все сначала.

    b=bbb

    c=ccc


    echo; echo

    echo "один два три" | ( read a b c;

    echo "Внутри подоболочки: "; echo "a = $a"; echo "b = $b"; echo "c = $c" )

    # a = один

    # b = два

    # c = три

    echo "-------"

    echo "Снаружи: "

    echo "a = $a" # a = aaa

    echo "b = $b" # b = bbb

    echo "c = $c" # c = ccc

    echo


    exit 0

    Огромный риск, для безопасности системы, представляет использование в скриптах команд, с установленным битом "suid"[ 61 ].

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

    Bash не совсем корректно обрабатывает строки, содержащие двойной слэш (//).

    Сценарии на языке Bash, созданные для Linux или BSD систем, могут потребовать доработки, перед тем как они смогут быть запущены в коммерческой версии UNIX. Такие сценарии, как правило, используют GNU-версии команд и утилит, которые имеют лучшую функциональность, нежели их аналоги в UNIX. Это особенно справедливо для таких утилит обработки текста, как tr.

    Danger is near thee --

    Beware, beware, beware, beware.

    Many brave hearts are asleep in the deep.

    So beware --

    Beware.

    A.J. Lamb and H.W. Petrie


    Глава 32. Стиль программирования

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

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


    32.1. Неофициальные рекомендации по оформлению сценариев

    ? Комментируйте свой код. Это сделает ваши сценарии понятнее для других, и более простыми, в обслуживании, для вас.

    ? PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"

    ? # Эта строка имела некоторый смысл в момент написания,

    ? # но через год-другой будет очень тяжело вспомнить -- что она делает.

    ? # (Из сценария "pw.sh", автор: Antek Sawicki)


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

    #!/bin/bash


    #************************************************#

    # xyz.sh #

    # автор: Bozo Bozeman #

    # Июль 05, 2001 #

    # #

    # Удаление файлов проекта. #

    #************************************************#


    BADDIR=65 # Нет такого каталога.

    projectdir=/home/bozo/projects # Каталог проекта.


    # ------------------------------------------------------- #

    # cleanup_pfiles () #

    # Удаляет все файлы в заданном каталоге. #

    # Параметры: $target_directory #

    # Возвращаемое значение: 0 -- в случае успеха, #

    # $BADDIR -- в случае ошибки. #

    # ------------------------------------------------------- #

    cleanup_pfiles ()

    {

    if [ ! -d "$1" ] # Проверка существования заданного каталога.

    then

    echo "$1 -- не является каталогом."

    return $BADDIR

    fi


    rm -f "$1"/*

    return 0 # Успешное завершение функции.

    }


    cleanup_pfiles $projectdir


    exit 0

    Не забывайте начинать ваш сценарий с sha-bang -- #!/bin/bash.

    ? Заменяйте повторяющиеся значения константами. Это сделает ваш сценарий более простым для понимания и позволит вносить изменения, не опасаясь за его работоспособность.

    ? if [ -f /var/log/messages ]

    ? then

    ? ...

    ? fi

    ? # Представьте себе, что через пару лет

    ? # вы захотите изменить /var/log/messages на /var/log/syslog.

    ? # Тогда вам придется отыскать все строки,

    ? # содержащие /var/log/messages, и заменить их на /var/log/syslog.

    ? # И проверить несколько раз -- не пропустили ли что-нибудь.

    ?

    ? # Использование "констант" дает лучший способ:

    ? LOGFILE=/var/log/messages # Если и придется изменить, то только в этой строке.

    ? if [ -f "$LOGFILE" ]

    ? then

    ? ...

    ? fi


    ? В качестве имен переменных и функций выбирайте осмысленные названия.

    ? fl=`ls -al $dirname` # Не очень удачное имя переменной.

    ? file_listing=`ls -al $dirname` # Уже лучше.

    ?

    ? MAXVAL=10 # Пишите имена констант в верхнем регистре.

    ? while [ "$index" -le "$MAXVAL" ]

    ? ...

    ?

    ? E_NOTFOUND=75 # Имена кодов ошибок -- в верхнем регистре,

    ? # к тому же, их желательно дополнять префиксом "E_".

    ? if [ ! -e "$filename" ]

    ? then

    ? echo "Файл $filename не найден."

    ? exit $E_NOTFOUND

    ? fi

    ?

    ? MAIL_DIRECTORY=/var/spool/mail/bozo # Имена переменных окружения

    ? # так же желательно записывать символами

    ? # в верхнем регистре.

    ? export MAIL_DIRECTORY

    ?

    ? GetAnswer () # Смешивание символов верхнего и нижнего решистров

    ? # удобно использовать для имен функций.

    ? {

    ? prompt=$1

    ? echo -n $prompt

    ? read answer

    ? return $answer

    ? }

    ?

    ? GetAnswer "Ваше любимое число? "

    ? favorite_number=$?

    ? echo $favorite_number

    ?

    ? _uservariable=23 # Допустимо, но не рекомендуется.

    ? # Желательно, чтобы пользовательские переменные не начинались с символа подчеркивания.

    ? # Так обычно начинаются системные переменные.


    ? Используйте смысловые имена для кодов завершения.

    ? E_WRONG_ARGS=65

    ? ...

    ? ...

    ? exit $E_WRONG_ARGS

    См. так же Приложение C.

    ? Разделяйте большие сложные сценарии на серию более коротких и простых модулей. Пользуйтесь функциями. См. Пример 34-4.

    ? Не пользуйтесь сложными конструкциями, если их можно заменить простыми.

    ? COMMAND

    ? if [ $? -eq 0 ]

    ? ...

    ? # Избыточно и неинтуитивно.

    ?

    ? if COMMAND

    ? ...

    ? # Более понятно и коротко.


    ... читая исходные тексты сценариев на Bourne shell (/bin/sh). Я был потрясен тем, насколько непонятно и загадочно могут выглядеть очень простые алгоритмы из-за неправильного оформления кода. Я не раз спрашивал себя: "Неужели кто-то может гордиться таким кодом?"

    Landon Noll


    Глава 33. Разное

    Практически никто не знает грамматики Bourne shell-а. Даже изучение исходных текстов не дает ее полного понимания.

    Tom Duff


    33.1. Интерактивный и неинтерактивный режим работы

    В интеракивном режиме, оболочка читает команды, вводимые пользователем, с устройства tty. Кроме того, такая оболочка считывает конфигурационные файлы на запуске, выводит строку приглашения к вводу (prompt), и, по-умолчанию, разрешает управление заданиями. Пользователь имеет возможность взаимодействия с оболочкой.

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

    #!/bin/bash

    MY_PROMPT='$ '

    while :

    do

    echo -n "$MY_PROMPT"

    read line

    eval "$line"

    done


    exit 0


    # Этот сценарий, как иллюстрация к вышесказанному, предоставлен

    # Stephane Chazelas (спасибо).


    Будем считать интерактивным такой сценарий, который может принимать ввод от пользователя, обычно с помощью команды read (см. Пример 11-2). В "реальной жизни" все намного сложнее. Пока же, будем придерживаться предположения о том, что интерактивный сценарий ограничен рамками tty, с которого сценарий был запущен пользователемa, т.е консоль или окно xterm.

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

    Неинтерактивные сценарии прекрасно могут работать в фоне, в то время, как интерактивные -- подвисают, останавливаясь на операциях, ожидающих ввода пользователя. Сложности, возникающие с запуском интерактивных сценариев в фоновом режиме, могут быть преодолены с помощью expect-сценария или встроенного документа. В простейших случаях, можно организовать перенаправление ввода из файла в команду read (read variable <file). Эти приемы позволят создавать сценарии, которые смогут работать как в интерактивном, так и в неинтерактивном режимах.

    Если внутри сценария необходимо проверить режим работы -- интерактивный или неинтерактивный, это можно сделать проверкой переменной окружения $PS1.

    if [ -z $PS1 ] # интерактивный режим?

    then

    # неинтерактивный

    ...

    else

    # интерактивный

    ...

    fi

    Еще один способ -- проверка установки флага "i" в переменной $-.

    case $- in

    *i*) # интерактивный режим

    ;;

    *) # неинтерактивный режим

    ;;

    # (Из "UNIX F.A.Q.," 1993)


    Сценарий может принудительно запускаться в интерактивном режиме, для этого необходимо указать ключ -i в строке-заголовке #!/bin/bash -i. Однако вы должны помнить о том, что в таких случаях сценарий может выдавать сообщения об ошибках даже тогда, когда ошибок, по сути, нет.


    33.2. Сценарии-обертки

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

    Сценарии sed или awk, как правило вызываются в форме: sed -e 'commands' или awk 'commands'. "Заворачивая" такие вызовы в сценарий на языке командной оболочки, мы делаем их использование более простым для конечного пользователя. Кроме того, этот прием позволяет комбинировать вызовы sed и awk, например в конвейере, позволяя передавать данные с выхода одной утилиты на вход другой.

    Пример 33-1. сценарий-обертка

    #!/bin/bash


    # Этот простой сценарий удаляет пустые строки из текстового файла.

    # Проверка входных аргументов не производится.

    #

    # Однако вы можете дополнить сценарий такой проверкой,

    # добавив нечто подобное:

    # if [ -z "$1" ]

    # then

    # echo "Порядок использования: `basename $0` текстовый_файл"

    # exit 65

    # fi


    # Для выполнения этих же действий,

    # из командной строки можно набрать

    # sed -e '/^$/d' filename


    sed -e /^$/d "$1"

    # '-e' -- означает команду "editing" (правка), за которой следуют необязательные параметры.

    # '^' -- с начала строки, '$' -- до ее конца.

    # Что соответствует строкам, которые не содержат символов между началом и концом строки,

    #+ т.е. -- пустым строкам.

    # 'd' -- команда "delete" (удалить).


    # Использование кавычек дает возможность

    #+ обрабатывать файлы, чьи имена содержат пробелы.


    exit 0

    Пример 33-2. Более сложный пример сценария-обертки

    #!/bin/bash


    # "subst", Сценарий замены по шаблону

    # т.е., "subst Smith Jones letter.txt".


    ARGS=3

    E_BADARGS=65 # Неверное число аргументов.


    if [ $# -ne "$ARGS" ]

    # Проверка числа аргументов.

    then

    echo "Проядок использования: `basename $0` old-pattern new-pattern filename"

    exit $E_BADARGS

    fi


    old_pattern=$1

    new_pattern=$2


    if [ -f "$3" ]

    then

    file_name=$3

    else

    echo "Файл \"$3\" не найден."

    exit $E_BADARGS

    fi


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

    sed -e "s/$old_pattern/$new_pattern/g" $file_name

    # 's' -- команда "substitute" (замены),

    # а /pattern/ -- задает шаблон искомого текста.

    # "g" -- флаг "global" (всеобщий), означает "выполнить подстановку для *каждого*

    # обнаруженного $old_pattern во всех строках, а не только в первой строке.


    exit 0 # При успешном завершении сценария -- вернуть 0.

    Пример 33-3. Сценарий-обертка вокруг сценария awk

    #!/bin/bash


    # Суммирует числа в заданном столбце из заданного файла.


    ARGS=2

    E_WRONGARGS=65


    if [ $# -ne "$ARGS" ] # Проверка числа аргументов.

    then

    echo "Порядок использования: `basename $0` имя_файла номер_столбца"

    exit $E_WRONGARGS

    fi


    filename=$1

    column_number=$2


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

    # из командной оболочки в сценарий awk .


    # Многострочный сценарий awk должен записываться в виде: awk ' ..... '


    # Начало awk-сценария.

    # -----------------------------

    awk '


    { total += $'"${column_number}"'

    }

    END {

    print total

    }


    ' "$filename"

    # -----------------------------

    # Конец awk-сценария.


    # С точки зрения безопасности, передача shell-переменных

    # во встроенный awk-скрипт, потенциально опасна,

    # поэтому, Stephane Chazelas предлагает следующую альтернативу:

    # ---------------------------------------

    # awk -v column_number="$column_number" '

    # { total += $column_number

    # }

    # END {

    # print total

    # }' "$filename"

    # ---------------------------------------


    exit 0

    Для сценариев, которые должны строиться по принципу швейцарского армейского ножа -- "все в одном", можно порекомендовать Perl. Perl совмещает в себе мощь и гибкость sed, awk и языка программирования C. Он поддерживает модульность и объектно-ориентированный стиль программирования. Короткие сценарии Perl могут легко встраиваться в сценарии командной оболочки, и даже полностью заменить из (хотя автор весьма скептически относится к последнему утверждению).

    Пример 33-4. Сценарий на языке Perl, встроенный в Bash-скрипт

    #!/bin/bash


    # Это команды shell, предшествующий сценарию на Perl.

    echo "Эта строка выводится средствами Bash, перед выполнением встроенного Perl-скрипта, в \"$0\"."

    echo "=============================================================================================="


    perl -e 'print "Эта строка выводится средствами Perl.\n";'

    # Подобно sed, Perl тоже использует ключ "-e".


    echo "====================================="


    exit 0

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

    Пример 33-5. Комбинирование сценария Bash и Perl в одном файле

    #!/bin/bash

    # bashandperl.sh


    echo "Вас приветствует часть сценария, написанная на Bash."

    # Далее могут следовать другие команды Bash.


    exit 0

    # Конец сценария на Bash.


    # =======================================================


    #!/usr/bin/perl

    # Эта часть сценария должна вызываться с ключом -x.


    print "Вас приветствует часть сценария, написанная на Perl.\n";

    # Далее могут следовать другие команды Perl.


    # Конец сценария на Perl.

    bash$ bash bashandperl.sh

    Вас приветствует часть сценария, написанная на Bash.


    bash$ perl -x bashandperl.sh

    Вас приветствует часть сценария, написанная на Perl.


    33.3. Операции сравнения: Альтернативные решения

    Операции сравнения, выполняемые с помощью конструкции [[ ]], могут оказаться предпочтительнее, чем [ ]. Аналогично, при сравнении чисел, в более выгодном свете представляется конструкция (( )).

    a=8


    # Все, приведенные ниже, операции сравнения -- эквивалентны.

    test "$a" -lt 16 && echo "да, $a < 16" # "И-список"

    /bin/test "$a" -lt 16 && echo "да, $a < 16"

    [ "$a" -lt 16 ] && echo "да, $a < 16"

    [[ $a -lt 16 ]] && echo "да, $a < 16" # Внутри [[ ]] и (( )) переменные

    (( a < 16 )) && echo "да, $a < 16" # не обязательно брать в кавычки.


    city="New York"

    # Опять же, все, приведенные ниже, операции -- эквивалентны.

    test "$city" \< Paris && echo "Да, Paris больше, чем $city" # В смысле ASCII-строк.

    /bin/test "$city" \< Paris && echo "Да, Paris больше, чем $city"

    [ "$city" \< Paris ] && echo "Да, Paris больше, чем $city"

    [[ $city < Paris ]] && echo "Да, Paris больше, чем $city" # Кавычки вокруг $city не обязательны.


    # Спасибо S.C.


    33.4. Рекурсия

    Может ли сценарий рекурсивно вызывать себя самого? Да, может!

    Пример 33-6. Сценарий (бесполезный), который вызывает себя сам

    #!/bin/bash

    # recurse.sh


    # Может ли сценарий вызвать себя сам?

    # Да, но есть ли в этом смысл?


    RANGE=10

    MAXVAL=9


    i=$RANDOM

    let "i %= $RANGE" # Генерация псевдослучайного числа в диапазоне 0 .. $MAXVAL.


    if [ "$i" -lt "$MAXVAL" ]

    then

    echo "i = $i"

    ./$0 # Сценарий запускает новый экземпляр себя самого.

    fi # если число $i больше или равно $MAXVAL.


    # Если конструкцию "if/then" заменить на цикл "while", то это вызовет определенные проблемы.

    # Объясните -- почему?.


    exit 0

    Пример 33-7. Сценарий имеющий практическую ценность), который вызывает себя сам

    #!/bin/bash

    # pb.sh: телефонная книга


    # Автор: Rick Boivie

    # используется с его разрешения.

    # Дополнен автором документа.


    MINARGS=1 # Сценарию должен быть передан, по меньшей мере, один аргумент.

    DATAFILE=./phonebook

    PROGNAME=$0

    E_NOARGS=70 # Ошибка, нет аргументов.


    if [ $# -lt $MINARGS ]; then

    echo "Порядок использования: "$PROGNAME" data"

    exit $E_NOARGS

    fi


    if [ $# -eq $MINARGS ]; then

    grep $1 "$DATAFILE"

    else

    ( shift; "$PROGNAME" $* ) | grep $1

    # Рекурсивный вызов.

    fi


    exit 0 # Сценарий завершает свою работу здесь.

    # Далее следует пример файла телефонной книги

    #+ в котором не используются символы комментария.


    # ------------------------------------------------------------------------

    # Пример файла телефонной книги


    John Doe 1555 Main St., Baltimore, MD 21228 (410) 222-3333

    Mary Moe 9899 Jones Blvd., Warren, NH 03787 (603) 898-3232

    Richard Roe 856 E. 7th St., New York, NY 10009 (212) 333-4567

    Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678

    Zoe Zenobia 4481 N. Baker St., San Franciso, SF 94338 (415) 501-1631

    # ------------------------------------------------------------------------


    $bash pb.sh Roe

    Richard Roe 856 E. 7th St., New York, NY 10009 (212) 333-4567

    Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678


    $bash pb.sh Roe Sam

    Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678


    # Если сценарию передаются несколько аргументов,

    #+ то выводятся только те строки, которые содержат их все.

    Слишком глубокая рекурсия может привести к исчерпанию пространства, выделенного под стек, и "вываливанию" сценария по "segfault".


    33.5. "Цветные" сценарии

    Для установки атрибутов отображения информации на экране, таких как: жирный текст, цвет символов, цвет фона и т.п., с давних пор используются ANSI[ 62 ] escape-последовательности. Эти последовательности широко используются в пакетных файлах DOS, эти же последовательности используются и в сценариях Bash.

    Пример 33-8. "Цветная" адресная книга

    #!/bin/bash

    # ex30a.sh: Версия сценария ex30.sh, с добавлением цвета .

    # Грубый пример базы данных


    clear # Очистка экрана


    echo -n " "

    echo -e '\E[37;44m'"\033[1mСписок\033[0m"

    # Белый текст на синем фоне

    echo; echo

    echo -e "\033[1mВыберите интересующую Вас персону:\033[0m"

    # Жирный шрифт

    tput sgr0

    echo "(Введите только первую букву имени.)"

    echo

    echo -en '\E[47;34m'"\033[1mE\033[0m" # Синий

    tput sgr0 # сброс цвета

    echo "vans, Roland" # "[E]vans, Roland"

    echo -en '\E[47;35m'"\033[1mJ\033[0m" # Пурпурный

    tput sgr0

    echo "ones, Mildred"

    echo -en '\E[47;32m'"\033[1mS\033[0m" # Зеленый

    tput sgr0

    echo "mith, Julie"

    echo -en '\E[47;31m'"\033[1mZ\033[0m" # Красный

    tput sgr0

    echo "ane, Morris"

    echo


    read person


    case "$person" in

    # Обратите внимание: переменная взята в кавычки.


    "E" | "e" )

    # Пользователь может ввести как заглавную, так и строчную букву.

    echo

    echo "Roland Evans"

    echo "4321 Floppy Dr."

    echo "Hardscrabble, CO 80753"

    echo "(303) 734-9874"

    echo "(303) 734-9892 fax"

    echo "revans@zzy.net"

    echo "Старый друг и партнер по бизнесу"

    ;;


    "J" | "j" )

    echo

    echo "Mildred Jones"

    echo "249 E. 7th St., Apt. 19"

    echo "New York, NY 10009"

    echo "(212) 533-2814"

    echo "(212) 533-9972 fax"

    echo "milliej@loisaida.com"

    echo "Подружка"

    echo "День рождения: 11 февраля"

    ;;


    # Информация о Smith и Zane будет добавлена позднее.


    * )

    # Выбор по-умолчанию.

    # "Пустой" ввод тоже обрабатывается здесь.

    echo

    echo "Нет данных."

    ;;


    esac


    tput sgr0 # Сброс цвета


    echo


    exit 0

    Самая простая и, на мой взгляд, самая полезная escape-последовательность -- это "жирный текст", \033[1m ... \033[0m. Здесь, комбинация \033 представляет escape-символ, кобинация "[1" -- включает вывод жирным текстом, а "[0" -- выключает. Символ "m" -- завершает каждую из escape-последовательностей.

    bash$ echo -e "\033[1mЭто жирный текст.\033[0m"


    Простая escape-последовательность, которая управляет атрибутом подчеркивания (в rxvt и aterm).

    bash$ echo -e "\033[4mЭто подчеркнутый текст.\033[0m"


    Ключ -e, в команде echo, разрешает интерпретацию escape-последовательностей.

    Другие escape-последовательности, изменяющие атрибуты цвета:

    bash$ echo -e '\E[34;47mЭтот текст выводится синим цветом.'; tput sgr0


    bash$ echo -e '\E[33;44m'"желтый текст на синем фоне"; tput sgr0

    Команда tput sgr0 возвращает настройки терминала в первоначальное состояние.

    Вывод цветного текста осуществляется по следующему шаблону:.

    echo -e '\E[COLOR1;COLOR2mКакой либо текст.'

    Где "\E[" -- начало escape-последовательности. Числа "COLOR1" и "COLOR2", разделенные точкой с запятой, задают цвет символов и цвет фона, в соответствии с таблицей цветов, приведенной ниже. (Порядок указания цвета текста и фона не имеет значения, поскольку диапазоны числовых значений цвета для текста и фона не пересекаются). Символ "m" -- должен завершать escape-последовательность.

    Обратите внимание: одиночные кавычки окружают все, что следует за echo -e.

    Числовые значения цвета, приведенные ниже, справедливы для rxvt. Для других эмуляторов они могут несколько отличаться.

    Таблица 33-1. Числовые значения цвета в escape-последовательностях

    ЦветТекстФон
    черный3040
    красный3141
    зеленый3242
    желтый3343
    синий3444
    пурпурный3545
    зеленовато-голубой3646
    белый3747

    Пример 33-9. Вывод цветного текста

    #!/bin/bash

    # color-echo.sh: Вывод цветных сообщений.


    black='\E[30;47m'

    red='\E[31;47m'

    green='\E[32;47m'

    yellow='\E[33;47m'

    blue='\E[34;47m'

    magenta='\E[35;47m'

    cyan='\E[36;47m'

    white='\E[37;47m'


    cecho () # Color-echo.

    # Аргумент $1 = текст сообщения

    # Аргумент $2 = цвет

    {

    local default_msg="Нет сообщений."

    # Не обязательно должна быть локальной.


    message=${1:-$default_msg} # Текст сообщения по-умолчанию.

    color=${2:-$black} # Цвет по-умолчанию черный.


    echo -e "$color"

    echo "$message"

    tput sgr0 # Восстановление первоначальных настроек терминала.

    return

    }


    # Попробум что-нибудь вывести.

    # ----------------------------------------------------

    cecho "Синий текст..." $blue

    cecho "Пурпурный текст." $magenta

    cecho "Позеленевший от зависти." $green

    cecho "Похоже на красный?" $red

    cecho "Циан, более известный как цвет морской волны." $cyan

    cecho "Цвет не задан (по-умолчанию черный)."

    # Аргумент $color отсутствует.

    cecho "\"Пустой\" цвет (по-умолчанию черный)." ""

    # Передан "пустой" аргумент цвета.

    cecho

    # Ни сообщение ни цвет не переданы.

    cecho "" ""

    # Функции переданы "пустые" аргументы $message и $color.

    # ----------------------------------------------------


    echo


    exit 0


    # Упражнения:

    # ---------

    # 1) Добавьте в функцию 'cecho ()' возможность вывода "жирного текста".

    # 2) Добавьте возможность управления цветом фона.

    Однако, как обычно, в бочке меда есть ложка дегтя. Escape-последовательности ANSI совершенно не переносимы. Вывод в одном эмуляторе терминала (или в консоли) может разительно отличаться от вывода в другом эмуляторе. "Расцвеченные" сценарии, дающие изумительно красивый вывод текста на одном терминале, могут давать совершенно нечитаемый текст на другом. Это ставит под сомнение практическую ценность "расцвечивания" вывода в сценариях, низводя ее до уровня никчемной "игрушки".

    Moshe Jacobson разработал утилиту color (http://runslinux.net/projects/color), которая значительно упрощает работу с ANSI escape-последовательностями, заменяя, только что обсуждавшиеся, неуклюжие конструкции, логичным и понятным синтаксисом.

    33.6. Оптимизация

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

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

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

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

    cat "$file" | grep "$word"


    grep "$word" "$file"


    # Эти команды дают один и тот же результат,

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

    Не следует злоупотреблять командой cat.

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

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

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

    Прекрасный пример того, как оптимизация может сократить время работы сценария, вы найдете в Пример 12-32.

    33.7. Разные советы

    Для ведения учета использования сценария пользователями, добавьте следующие строки в сценарий. Они запишут в файл отчета название сценария и время запуска.

    # Добавление (>>) учетной записи, об использовании сценария, в файл отчета.


    date>> $SAVE_FILE # Дата и время.

    echo $0>> $SAVE_FILE # Название сценария.

    echo>> $SAVE_FILE # Пустая строка -- как разделитель записей.


    # Не забудьте определить переменную окружения SAVE_FILE в ~/.bashrc

    # (что нибудь, типа: ~/.scripts-run)


    Оператор >> производит добавление строки в конец файла. А как быть, если надо добавить строку в начало существующего файла?

    file=data.txt

    title="***Это титульная строка в текстовом файле***"


    echo $title | cat - $file >$file.new

    # "cat -" объединяет stdout с содержимым $file.

    # В результате получится

    #+ новый файл $file.new, в начало которого добавлена строка $title.


    Само собой разумеется, то же самое можно сделать с помощью sed.

    Сценарий командной оболочки может использоваться как команда внутри другого сценария командной оболочки, Tcl, или wish сценария или, даже в Makefile. Он может быть вызван как внешняя команда из программы на языке C, с помощью функции system(), т.е. system("script_name");.

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

    # Сценарий-библиотека

    # ------ -------


    # Обратите внимание:

    # Здесь нет sha-bang ("#!").

    # И нет "живого кода".


    # Определения переменных


    ROOT_UID=0 # UID root-а, 0.

    E_NOTROOT=101 # Ошибка -- "обычный пользователь".

    MAXRETVAL=255 # Максимальное значение, которое могут возвращать функции.

    SUCCESS=0

    FAILURE=-1


    # Функции


    Usage () # Сообщение "Порядок использования:".

    {

    if [ -z "$1" ] # Нет аргументов.

    then

    msg=filename

    else

    msg=$@

    fi


    echo "Порядок использования: `basename $0` "$msg""

    }


    Check_if_root () # Проверка прав пользователя.

    { # из примера "ex39.sh".

    if [ "$UID" -ne "$ROOT_UID" ]

    then

    echo "Этот сценарий должен запускаться с привилегиями root."

    exit $E_NOTROOT

    fi

    }


    CreateTempfileName () # Создание "уникального" имени для временного файла.

    { # Из примера "ex51.sh".

    prefix=temp

    suffix=`eval date +%s`

    Tempfilename=$prefix.$suffix

    }


    isalpha2 () # Проверка, состоит ли строка только из алфавитных символов.

    { # Из примера "isalpha.sh".

    [ $# -eq 1 ] || return $FAILURE


    case $1 in

    *[!a-zA-Z]*|"") return $FAILURE;;

    *) return $SUCCESS;;

    esac # Спасибо S.C.

    }


    abs () # Абсолютное значение.

    { # Внимание: Максимально возможное возвращаеиое значение

    # не может превышать 255.

    E_ARGERR=-999999


    if [ -z "$1" ] # Проверка наличия входного аргумента.

    then

    return $E_ARGERR # Код ошибки, обычно возвращаемый в таких случаях.

    fi


    if [ "$1" -ge 0 ] # Если не отрицательное,

    then #

    absval=$1 # оставить как есть.

    else # Иначе,

    let "absval = (( 0 - $1 ))" # изменить знак.

    fi


    return $absval

    }


    tolower () # Преобразование строк символов в нижний регистр

    {


    if [ -z "$1" ] # Если нет входного аргумента,

    then #+ выдать сообщение об ошибке

    echo "(null)"

    return #+ и выйти из функции.

    fi


    echo "$@" | tr A-Z a-z

    # Преобразовать все входные аргументы ($@).


    return


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

    # Например:

    # oldvar="A seT of miXed-caSe LEtTerS"

    # newvar=`tolower "$oldvar"`

    # echo "$newvar" # a set of mixed-case letters

    #

    # Упражнение: Добавьте в эту библиотеку функцию перевода символов в верхний регистр.

    # toupper() [это довольно просто].

    }


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

    ## Внимание!

    rm -rf *.zzy ## Комбинация ключей "-rf", в команде "rm", чрезвычайно опасна,

    ##+ особенно при удалении по шаблону.


    #+ Продолжение комментария на новой строке.

    # Это первая строка комментария

    #+ это вторая строка комментария,

    #+ это последняя строка комментария.


    #* Обратите внимание.


    #o Элемент списка.


    #> Альтернативный вариант.

    while [ "$var1" != "end" ] #> while test "$var1" != "end"


    Для создания блочных комментариев, можно использовать конструкцию if-test.

    #!/bin/bash


    COMMENT_BLOCK=

    # Если попробовать инициализировать эту переменную чем нибудь,

    #+ то вы получите неожиданный результат.


    if [ $COMMENT_BLOCK ]; then


    Блок комментария --

    =================================

    Это строка комментария.

    Это другая строка комментария.

    Это еще одна строка комментария.

    =================================


    echo "Эта строка не выводится."


    Этот блок комментария не вызывает сообщения об ошибке! Круто!


    fi


    echo "Эта строка будет выведена на stdout."


    exit 0


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

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

    #!/bin/bash


    SUCCESS=0

    E_BADINPUT=65


    test "$1" -ne 0 -o "$1" -eq 0 2>/dev/null

    # Проверка: "равно нулю или не равно нулю".

    # 2>/dev/null подавление вывода сообщений об ошибках.


    if [ $? -ne "$SUCCESS" ]

    then

    echo "Порядок использования: `basename $0` целое_число"

    exit $E_BADINPUT

    fi


    let "sum = $1 + 25" # Будет выдавать ошибку, если $1 не является целым числом.

    echo "Sum = $sum"


    # Любая переменная может быть проверена таким образом, а не только входные аргументы.


    exit 0


    Диапазон, возвращаемых функциями значений, 0 - 255 -- серьезное ограничение. Иногда может оказаться весьма проблематичным использование глобальных переменных, для передачи результата из функции. В таких случаях можно порекомендовать передачу результатов работы функции через запись в stdout.

    Пример 33-10. Необычный способ передачи возвращаемого значения

    #!/bin/bash

    # multiplication.sh


    multiply () # Функции выполняет перемножение всех переданых аргументов.

    {

    local product=1


    until [ -z "$1" ] # Пока не дошли до последнего аргумента...

    do

    let "product *= $1"

    shift

    done


    echo $product # Значение не будет выведено на экран,

    } #+ поскольку оно будет записано в переменную.


    mult1=15383; mult2=25211

    val1=`multiply $mult1 $mult2`

    echo "$mult1 X $mult2 = $val1"

    # 387820813


    mult1=25; mult2=5; mult3=20

    val2=`multiply $mult1 $mult2 $mult3`

    echo "$mult1 X $mult2 X $mult3 = $val2"

    # 2500


    mult1=188; mult2=37; mult3=25; mult4=47

    val3=`multiply $mult1 $mult2 $mult3 $mult4`

    echo "$mult1 X $mult2 X $mult3 X mult4 = $val3"

    # 8173300


    exit 0

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

    capitalize_ichar () # Первый символ всех строковых аргументов

    { #+ переводится в верхний регистр.


    string0="$@" # Принять все аргументы.


    firstchar=${string0:0:1} # Первый символ.

    string1=${string0:1} # Остаток строки.


    FirstChar=`echo "$firstchar" | tr a-z A-Z`

    # Преобразовать в верхний регистр.


    echo "$FirstChar$string1" # Выдать на stdout.


    }


    newstring=`capitalize_ichar "each sentence should start with a capital letter."`

    echo "$newstring" # Each sentence should start with a capital letter.


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

    Пример 33-11. Необычный способ получения нескольких возвращаемых значений

    #!/bin/bash

    # sum-product.sh

    # Функция может "возвращать" несколько значений.


    sum_and_product () # Вычисляет сумму и произведение аргументов.

    {

    echo $(( $1 + $2 )) $(( $1 * $2 ))

    # Вывод на stdout двух значений, разделенных пробелом.

    }


    echo

    echo "Первое число: "

    read first


    echo

    echo "Второе число: "

    read second

    echo


    retval=`sum_and_product $first $second` # Получить результат.

    sum=`echo "$retval" | awk '{print $1}'` # Первое значение (поле).

    product=`echo "$retval" | awk '{print $2}'` # Второе значение (поле).


    echo "$first + $second = $sum"

    echo "$first * $second = $product"

    echo


    exit 0

    Следующая хитрость -- передача массива в функцию, и "возврат" массива из функции.

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

    Пример 33-12. Передача массива в функцию и возврат массива из функции

    #!/bin/bash

    # array-function.sh: Передача массива в функцию и...

    # "возврат" массива из функции


    Pass_Array ()

    {

    local passed_array # Локальная переменная.

    passed_array=( `echo "$1"` )

    echo "${passed_array[@]}"

    # Список всех элементов в новом массиве,

    #+ объявленном и инициализированном в функции.

    }


    original_array=( element1 element2 element3 element4 element5 )


    echo

    echo "original_array = ${original_array[@]}"

    # Список всех элементов исходного массива.


    # Так можно отдать массив в функцию.

    # **********************************

    argument=`echo ${original_array[@]}`

    # **********************************

    # Поместив все элементы массива в переменную,

    #+ разделяя их пробелами.

    #

    # Обратите внимание: метод прямой передачи массива в функцию не сработает.


    # Так можно получить массив из функции.

    # *****************************************

    returned_array=( `Pass_Array "$argument"` )

    # *****************************************

    # Записать результат в переменную-массив.


    echo "returned_array = ${returned_array[@]}"


    echo "============================================================="


    # А теперь попробуйте получить доступ к локальному массиву

    #+ за пределами функции.

    Pass_Array "$argument"


    # Функция выведет массив, но...

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

    echo "Результирующий массив (внутри функции) = ${passed_array[@]}"

    # "ПУСТОЕ" ЗНАЧЕНИЕ, поскольку это локальная переменная.


    echo


    exit 0

    Более сложный пример передачи массивов в функции, вы найдете в Пример A-11.

    Использование конструкций с двойными круглыми скобками позволяет применять C-подобный синтаксис операций присвоения и инкремента переменных, а также оформления циклов for и while. См. Пример 10-12 и Пример 10-17.

    Иногда очень удобно "пропускать" данные через один и тот же фильтр, но с разными параметрами, используя конвейерную обработку. Особенно это относится к tr и grep.

    # Из примера "wstrings.sh".


    wlist=`strings "$1" | tr A-Z a-z | tr '[:space:]' Z | \

    tr -cs '[:alpha:]' Z | tr -s '\173-\377' Z | tr Z ' '`


    Пример 33-13. Игры с анаграммами

    #!/bin/bash

    # agram.sh: Игры с анаграммами.


    # Поиск анаграмм...

    LETTERSET=etaoinshrdlu


    anagram "$LETTERSET" | # Найти все анаграммы в наборе символов...

    grep '.......' | # состоящие, как минимум из 7 символов,

    grep '^is' | # начинающиеся с 'is'

    grep -v 's$' | # исключая множественное число

    grep -v 'ed$' # и глаголы в прошедшем времени


    # Здесь используется утилита "anagram"

    #+ которая входит в состав пакета "yawl" , разработанного автором.

    # http://ibiblio.org/pub/Linux/libs/yawl-0.2.tar.gz


    exit 0 # Конец.


    bash$ sh agram.sh

    islander

    isolate

    isolead

    isotheral

    См. также Пример 27-2, Пример 12-18 и Пример A-10.

    Для создания блочных комментариев можно использовать "анонимные встроенные документы". См. Пример 17-10.

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

    CMD=command1 # Основной вариант.

    PlanB=command2 # Запасной вариант.


    command_test=$(whatis "$CMD" | grep 'nothing appropriate')

    # Если 'command1' не найдена в системе, то 'whatis' вернет

    #+ "command1: nothing appropriate."

    #==> От переводчика: Будьте внимательны! Если у вас локализованная версия whatis

    #==> то вывод от нее может отличаться от используемого здесь ('nothing appropriate')


    if [[ -z "$command_test" ]] # Проверка наличия утилиты в системе.

    then

    $CMD option1 option2 # Запуск команды с параметрами.

    else # Иначе,

    $PlanB #+ запустить command2 (запасной вариант).

    fi


    Команда run-parts удобна для запуска нескольких сценариев, особенно в комбинации с cron или at.

    Было бы неплохо снабдить сценарий графическим интерфейстом X-Window. Для этого можно порекомендовать пакеты Xscript, Xmenu и widtools. Правда, первые два, кажется больше не поддерживаются разработчиками. Зато widtools можно получить здесь.

    Пакет widtools (widget tools) требует наличия библиотеки XForms. Кроме того, необходимо слегка подправить Makefile, чтобы этот пакет можно было собрать на типичной Linux-системе. Но хуже всего то, что три из шести виджетов не работают :-(( (segfault).

    Для постороения приложений с графическим интерфейсом, можно попробовать Tk, или wish (надстройка над Tcl), PerlTk (Perl с поддержкой Tk), tksh (ksh с поддержкой Tk), XForms4Perl (Perl с поддержкой XForms), Gtk-Perl (Perl с поддержкой Gtk) или PyQt (Python с поддержкой Qt).


    33.8. Проблемы безопасности

    Уместным будет лишний раз предупредить о соблюдении мер предосторожности при работе с незнакомыми сценариями. Сценарий может содержать червя, трояна или даже вирус. Если вы получили сценарий не из источника, которому доверяете, то никогда не запускайте его с привилегиями root и не позволяйте вставлять его в список сценариев начальной инициализации системы в /etc/rc.d, пока не убедитесь в том, что он безвреден для системы.

    Исследователи из Bell Labs и других организаций, включая M. Douglas McIlroy, Tom Duff, и Fred Cohen исследовали вопрос о возможности создания вирусов на языке сценариев командной оболочки, и пришли к выводу, что это делается очень легко и доступно даже для новичков.[ 63 ]

    Это еще одна из причин, по которым следует изучать язык командной оболочки. Способность читать и понимать сценарии поможет вам предотвратить возможность взлома и/или разрушения вашей системы.


    33.9. Проблемы переносимости

    Эта книга делает упор на создании сценариев для командной оболочки Bash, для операционной системы GNU/Linux. Тем не менее, многие рекомендации, приводимые здесь, могут быть вполне применимы и для других командных оболочек, таких как sh и ksh.

    Многие версии командных оболочек стремятся следовать стандарту POSIX 1003.2. Вызывая Bash с ключом --posix, или вставляя set -o posix в начало сценария, вы можете заставить Bash очень близко следовать этому стандарту. Но, даже без этого ключа, большинство сценариев, написанных для Bash, будут работать под управлением ksh, и наоборот, т.к. Chet Ramey перенес многие особенности, присущие ksh, в последние версии Bash.

    В коммерческих версиях UNIX, сценарии, использующие GNU-версии стандартных утилит и команд, могут оказаться неработоспособными. Однако, с течением времени, таких проблем остается все меньше и меньше, поскольку утилиты GNU, в большинстве своем, заместили свои проприетарные аналоги в UNIX. После того, как Caldera дала разрешение на публикацию исходного кода некоторых версий оригинальных утилит UNIX, этот процесс значительно ускорился.

    Bash имеет некоторые особенности, недоступные в традиционном Bourne shell. Среди них:

    Некоторые дополнительные ключи вызова

    Подстановка команд, с использованием нотации $( )

    Некоторые операции над строками

    Подстановка процессов

    встроенные команды Bash


    Более подробный список характерных особенностей Bash, вы найдете в Bash F.A.Q..


    33.10. Сценарии командной оболочки под Windows

    Даже те пользователи, которые работают в другой, не UNIX-подобной операционной системе, смогут запускать сценарии командной оболочки, а потому -- найти для себя много полезного в этой книге. Пакеты Cygwin от Cygnus, и MKS utilities от Mortice Kern Associates, позволяют дополнить Windows возможностями командной оболочки.


    Глава 34. Bash, версия 2

    Текущая версия Bash, та, которая скорее всего установлена в вашей системе, фактически -- 2.XX.Y.

    bash$ echo $BASH_VERSION

    2.05.8(1)-release

    В этой версии классического языка сценариев Bash были добавлены переменные-массивы[ 64 ], расширение строк и подстановка параметров, улучшен метод косвенных ссылок на переменные.

    Пример 34-1. Расширение строк

    #!/bin/bash


    # "Расширение" строк (String expansion).

    # Введено в Bash, начиная с версии 2.


    # Строки вида $'xxx'

    # могут содержать дополнительные экранированные символы.


    echo $'Звонок звенит 3 раза \a \a \a'

    echo $'Три перевода формата \f \f \f'

    echo $'10 новых строк \n\n\n\n\n\n\n\n\n\n'


    exit 0

    Пример 34-2. Косвенные ссылки на переменные -- новый метод

    #!/bin/bash


    # Косвенные ссылки на переменные.


    a=letter_of_alphabet

    letter_of_alphabet=z


    echo "a = $a" # Прямая ссылка.


    echo "Now a = ${!a}" # Косвенная ссылка.

    # Форма записи ${!variable} намного удобнее старой "eval var1=\$$var2"


    echo


    t=table_cell_3

    table_cell_3=24

    echo "t = ${!t}" # t = 24

    table_cell_3=387

    echo "Значение переменной t изменилось на ${!t}" # 387


    # Теперь их можно использовать для ссылок на элементы массива,

    # или для эмуляции многомерных массивов.

    # Было бы здорово, если бы косвенные ссылки допускали индексацию.


    exit 0

    Пример 34-3. Простая база данных, с применением косвенных ссылок

    #!/bin/bash

    # resistor-inventory.sh

    # Простая база данных, с применением косвенных ссылок.


    # ============================================================== #

    # Данные


    B1723_value=470 # сопротивление (Ом)

    B1723_powerdissip=.25 # рассеиваемая мощность (Вт)

    B1723_colorcode="желтый-фиолетовый-коричневый" # цветовая маркировка

    B1723_loc=173 # где

    B1723_inventory=78 # количество (шт)


    B1724_value=1000

    B1724_powerdissip=.25

    B1724_colorcode="коричневый-черный-красный"

    B1724_loc=24N

    B1724_inventory=243


    B1725_value=10000

    B1725_powerdissip=.25

    B1725_colorcode="коричневый-черный-оранжевый"

    B1725_loc=24N

    B1725_inventory=89


    # ============================================================== #


    echo


    PS3='Введите ноиер: '


    echo


    select catalog_number in "B1723" "B1724" "B1725"

    do

    Inv=${catalog_number}_inventory

    Val=${catalog_number}_value

    Pdissip=${catalog_number}_powerdissip

    Loc=${catalog_number}_loc

    Ccode=${catalog_number}_colorcode


    echo

    echo "Номер по каталогу $catalog_number:"

    echo "Имеется в наличии ${!Inv} шт. [${!Val} Ом / ${!Pdissip} Вт]."

    echo "Находятся в лотке # ${!Loc}."

    echo "Цветовая маркировка: \"${!Ccode}\"."


    break

    done


    echo; echo


    # Упражнение:

    # ----------

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

    # Какой из вариантов более простой и интуитивный?


    # Примечание:

    # ----------

    # Язык командной оболочки не очень удобен для написания приложений,

    #+ работающих с базами данных.

    # Для этой цели лучше использовать языки программирования, имеющие

    #+ развитые средства для работы со структурами данных,

    #+ такие как C++ или Java (может быть Perl).


    exit 0

    Пример 34-4. Массивы и другие хитрости для раздачи колоды карт в четыре руки

    #!/bin/bash

    # На старых системах может потребоваться вставить #!/bin/bash2.


    # Карты:

    # раздача в четыре руки.


    UNPICKED=0

    PICKED=1


    DUPE_CARD=99


    LOWER_LIMIT=0

    UPPER_LIMIT=51

    CARDS_IN_SUIT=13

    CARDS=52


    declare -a Deck

    declare -a Suits

    declare -a Cards

    # Проще и понятнее было бы, имей мы дело

    # с одним 3-мерным массивом.

    # Будем надеяться, что в будущем, поддержка многомерных массивов будет введена в Bash.


    initialize_Deck ()

    {

    i=$LOWER_LIMIT

    until [ "$i" -gt $UPPER_LIMIT ]

    do

    Deck[i]=$UNPICKED # Пометить все карты в колоде "Deck", как "невыданная".

    let "i += 1"

    done

    echo

    }


    initialize_Suits ()

    {

    Suits[0]=Т # Трефы

    Suits[1]=Б # Бубны

    Suits[2]=Ч # Червы

    Suits[3]=П # Пики

    }


    initialize_Cards ()

    {

    Cards=(2 3 4 5 6 7 8 9 10 В Д K Т)

    # Альтернативный способ инициализации массива.

    }


    pick_a_card ()

    {

    card_number=$RANDOM

    let "card_number %= $CARDS"

    if [ "${Deck[card_number]}" -eq $UNPICKED ]

    then

    Deck[card_number]=$PICKED

    return $card_number

    else

    return $DUPE_CARD

    fi

    }


    parse_card ()

    {

    number=$1

    let "suit_number = number / CARDS_IN_SUIT"

    suit=${Suits[suit_number]}

    echo -n "$suit-"

    let "card_no = number % CARDS_IN_SUIT"

    Card=${Cards[card_no]}

    printf %-4s $Card

    # Вывод по столбцам.

    }


    seed_random () # Переустановка генератора случайных чисел.

    {

    seed=`eval date +%s`

    let "seed %= 32766"

    RANDOM=$seed

    }


    deal_cards ()

    {

    echo


    cards_picked=0

    while [ "$cards_picked" -le $UPPER_LIMIT ]

    do

    pick_a_card

    t=$?


    if [ "$t" -ne $DUPE_CARD ]

    then

    parse_card $t


    u=$cards_picked+1

    # Возврат к индексации с 1 (временно).

    let "u %= $CARDS_IN_SUIT"

    if [ "$u" -eq 0 ] # вложенный if/then.

    then

    echo

    echo

    fi

    # Смена руки.


    let "cards_picked += 1"

    fi

    done


    echo


    return 0

    }


    # Структурное программирование:

    # вся логика приложения построена на вызове функций.


    #================

    seed_random

    initialize_Deck

    initialize_Suits

    initialize_Cards

    deal_cards


    exit 0

    #================


    # Упражнение 1:

    # Добавьте комментарии, чтобы до конца задокументировать этот сценарий.


    # Упражнение 2:

    # Исправьте сценарий так, чтобы карты в каждой руке выводились отсортированными по масти.

    # Вы можете добавить и другие улучшения.


    # Упражнение 3:

    # Упростите логику сценария.


    Глава 35. Замечания и дополнения

    35.1. От автора

    Как я пришел к мысли о написании этой книги? Это необычная история. Случилось это лет несколько тому назад. Мне потребовалось изучить язык командной оболочки -- а что может быть лучше, как не чтение хорошей книги!? Я надеялся купить учебник и справочник, которые охватывали бы в полной мере данную тематику. Я искал книгу, которая возьмет трудные понятия, вывернет их наизнанку и подробно разжует на хорошо откомментированных примерах. В общем, я искал очень хорошую книгу. К сожалению, в природе таковой не существовало, поэтому я счел необходимым написать ее.

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


    35.2. Об авторе

    Автор не стремится ни к званиям, ни к наградам, им движет неодолимое желание писать[ 65 ]. Эта книга -- своего рода отдых от основной работы, HOW-2 Meet Women: The Shy Man's Guide to Relationships (Руководство Застенчивого Мужчины о том Как Познакомиться С Женщиной) . Он также написал Software-Building HOWTO.

    Пользуется Linux с 1995 года (Slackware 2.2, kernel 1.2.1). Выпустил несколько программ, среди которых cruft -- утилита шифрования, заменявшая стандартную UNIX-овую crypt, mcalc -- финансовый калькулятор, для выполнения расчетов по займам, judge и yawl -- пакет игр со словами. Программировать начинал с языка FORTRAN IV на CDC 3800, но не испытывает ностальгии по тем дням.

    Живет в глухой, заброшенной деревушке со своей женой и собакой.


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

    35.3.1. Аппаратура

    IBM Thinkpad, model 760XL laptop (P166, 104 Mb RAM) под управлением Red Hat 7.1/7.3. Несомненно, это довольно медлительный агрегат, но он имеет отличную клавиатуру, и это много лучше, чем пара карандашей и письменный стол.


    35.3.2. Программное обеспечение

    Мощный текстовый редактор vim (автор: Bram Moolenaar) .

    OpenJade -- инструмент, выполняющий, на основе DSSSL, верификацию и преобразование SGML-документов в другие форматы.

    Таблицы стилей DSSSL от Norman Walsh.

    DocBook, The Definitive Guide (Norman Walsh, Leonard Muellner O'Reilly, ISBN 1-56592-580-7). Полное руководство по созданию документов в формате Docbook SGML.

    35.4. Благодарности

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

    Philippe Martin -- перевел этот документ в формат DocBook/SGML. Работает в маленькой французской компании, в качестве разработчика программного обеспечения. В свободное от работы время -- любит работать над документацией или программным обеспечением для GNU/Linux, читать книги, слушать музыку и веселиться с друзьями. Вы можете столкнуться с ним, где-нибудь во Франции, в провинции Басков, или написать ему письмо на feloy@free.fr.

    Philippe Martin также отметил, что возможно использование позиционных параметров за $9, при использовании {фигурных скобок}, см. Пример 4-5.

    Stephane Chazelas -- выполнил титаническую работу по корректировке, дополнению и написанию примеров сценариев. Фактически, он взвалил на свои плечи обязанности редактора этого документа. Огромное спасибо!

    Особенно я хотел бы поблагодарить Patrick Callahan, Mike Novak и Pal Domokos за исправление ошибок и неточностей, за разъяснения и дополнения. Их живое обсуждение проблем, связанных с созданием сценариев на языке командной оболочки вдохновило меня на попытку сделать этот документ более удобочитаемым.

    Я благодарен Jim Van Zandt за выявленные им ошибки и упущения, в версии 0.2 этого документа, и за поучительный пример сценария.

    Большое спасибо Jordi Sanfeliu за то, что он дал возможность использовать его прекрасный сценарий в этой книге (Пример A-19).

    Выражаю свою благодарность Michel Charpentier за разрешение использовать его dc сценарий разложения на простые множители (Пример 12-37).

    Спасибо Noah Friedman, предоставившему право использовать его сценарий (Пример A-20).

    Emmanuel Rouat предложил несколько изменений и дополнений в разделах, посвященных подстановке команд и псевдонимам. Он так же предоставил замечательный пример файла .bashrc (Приложение G).

    Heiner Steven любезно разрешил опубликовать его сценарий Пример 12-33. Он сделал множество исправлений и внес большое количество предложений. Особое спасибо!

    Rick Boivie предоставил отличный сценарий, демонстрирующий рекурсию, pb.sh (Пример 33-7) и внес предложения по повышению производительности сценария monthlypmt.sh (Пример 12-32).

    Florian Wisser оказывал содействие при написании разделов, посвященных строкам (см. Пример 7-6).

    Oleg Philon передал свои предложения относительно команд cut и pidof.

    Michael Zick расширил пример с пустыми массивами, введя туда демонстрацию необычных свойств массивов. Он также предоставил ряд других примеров.

    Marc-Jano Knopp выполнил исправления в разделе, посвященном пакетным файлам DOS.

    Hyun Jin Cha, в процессе работы над корейским переводом, обнаружил несколько опечаток в документе. Спасибо ему за это!

    Andreas Abraham передал большое число типографских ошибок и внес ряд исправлений. Особое спасибо!

    Кроме того, я хотел бы выразить свою признательность Gabor Kiss, Leopold Toetsch, Peter Tillier, Marcus Berglof, Tony Richardson, Nick Drage, Rich Bartell, Jess Thrysoee, Adam Lazur, Bram Moolenaar, Baris Cicek, Greg Keraunen, Keith Matthews, Sandro Magi, Albert Reiner, Dim Segebart, Rory Winston, Lee Bigelow, Wayne Pollock, "jipe", Emilio Conti, Dennis Leeuw, Dan Jacobson и David Lawyer (автор 4-х HOWTO).

    Мои благодарности Chet Ramey и Brian Fox за создание Bash -- этого элегантного и мощного инструмента!

    Особое спасибо добровольцам из Linux Documentation Project. Проект LDP сделал возможным публикацию этой книги в своем архиве.

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



    Примечания:



    4

    Некоторые разновидности UNIX (основанные на 4.2BSD) требуют, чтобы эта последовательность состояла из 4-х байт, за счет добавления пробела после !, #! /bin/sh.



    5

    В shell-скриптах последовательность #! должна стоять самой первой и задает интерпретатор (sh или bash). Интерпретатор, в свою очередь, воспринимает эту строку как комментарий, поскольку она начинается с символа #.

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

    #!/bin/bash


    echo "Первая часть сценария."

    a=1


    #!/bin/bash

    # Это *НЕ* означает запуск нового сценария.


    echo "Вторая часть сценария."

    echo $a # Значение переменной $a осталось равно 1.



    6

    Эта особенность позволяет использовать различные хитрости.

    #!/bin/rm

    # Самоуничтожающийся сценарий.


    # Этот скрипт ничего не делает -- только уничтожает себя.


    WHATEVER=65


    echo "Эта строка никогда не будет напечатана."


    exit $WHATEVER # Не имеет смысла, поскольку работа сценария завершается не здесь.


    Попробуйте запустить файл README с сигнатурой #!/bin/more (предварительно не забудьте сделать его исполняемым).



    46

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



    47

    [47]Поскольку с помощью sed, awk и grep обрабатывают одиночные строки, то обычно символ перевода строки не принимается во внимание. В тех же случаях, когда производится разбор многострочного текста, метасимвол "точка" будет соответствовать символу перевода строки.

    #!/bin/bash


    sed -e 'N;s/.*/[&]/' << EOF # Встроенный документ

    line1

    line2

    EOF

    # OUTPUT:

    # [line1

    # line2]


    echo


    awk '{ $0=$1 "\n" $2; if (/line.1/) {print}}' << EOF

    line 1

    line 2

    EOF

    # OUTPUT:

    # line

    # 1


    # Спасибо S.C.


    exit 0



    48

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

    ~/[.]bashrc # Не будет соответствовать имени ~/.bashrc

    ~/?bashrc # То же самое.

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


    ~/.[b]ashrc # Имя ~./bashrc будет соответствовать данному шаблону

    ~/.ba?hrc # Аналогично.

    ~/.bashr* # Аналогично.


    # Установка ключа "dotglob" отключает такое поведение интерпретатора.

    # Спасибо S.C.



    49

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



    50

    Механизм косвенных ссылок на переменные (см. Пример 34-2) слишком неудобен для передачи аргументов по ссылке.

    #!/bin/bash


    ITERATIONS=3 # Количество вводимых значений.

    icount=1


    my_read () {

    # При вызове my_read varname,

    # выводит предыдущее значение в квадратных скобках,

    # затем просит ввести новое значение.


    local local_var


    echo -n "Введите говое значение переменной "

    eval 'echo -n "[$'$1'] "' # Прежнее значение.

    read local_var

    [ -n "$local_var" ] && eval $1=\$local_var


    # Последовательность "And-list": если "local_var" не пуста, то ее значение переписывается в "$1".

    }


    echo


    while [ "$icount" -le "$ITERATIONS" ]

    do

    my_read var

    echo "Значение #$icount = $var"

    let "icount += 1"

    echo

    done


    # Спасибо Stephane Chazelas за этот поучительный пример.


    exit 0



    51

    Команда return -- это встроенная команда Bash.



    52

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



    53

    Слишком глубокая рекурсия может вызвать крах сценария.

    #!/bin/bash


    recursive_function ()

    {

    (( $1 < $2 )) && recursive_function $(( $1 + 1 )) $2;

    # Увеличивать 1-й параметр до тех пор,

    #+ пока он не станет равным, или не превысит, второму параметру.

    }


    recursive_function 1 50000 # Глубина рекурсии = 50,000!

    # Само собой -- Segmentation fault.


    # Рекурсия такой глубины может "обрушить" даже программу, написанную на C,

    #+ по исчерпании памяти, выделенной под сегмент стека.


    # Спасибо S.C.


    exit 0 # Этот сценарий завершает работу не здесь, а в результате ошибки Segmentation fault.



    54

    Однако, псевдонимы могут "раскручивать" позиционные параметры.



    55

    Это не относится к таким оболочкам, как csh, tcsh и другим, которые не являются производными от классической Bourne shell (sh).



    56

    Каталог /dev содержит специальные файлы -- точки монтирования физических и виртуальных устройств. Они занимают незначительное пространство на диске.

    Некоторые из устройств, такие как /dev/null, /dev/zero или /dev/urandom -- являются виртуальными. Они не являются файлами физических устройств, система эмулирует эти устройства программным способом.



    57

    Блочное устройство читает и/или пишет данные целыми блоками, в отличие от символьных устройств, которые читают и/или пишут данные по одному символу. Примером блочного устройства может служить жесткий диск, CD-ROM. Примером символьного устройства -- клавиатура.



    58

    Отдельные системные команды, такие как procinfo, free, vmstat, lsdev и uptime делают это именно таким образом.



    59

    Bash debugger (автор: Rocky Bernstein) частично возмещает этот недостаток.



    60

    В соответствии с соглашениями, сигнал с номером 0 соответствует команде exit.



    61

    Установка этого бита на файлы сценариев не имеет никакого эффекта.



    62

    ANSI -- аббревиатура от American National Standards Institute.



    63

    См. статью Marius van Oers, Unix Shell Scripting Malware, а также ссылку на Denning в разделе Литература.



    64

    Chet Ramey обещал ввести в Bash ассоциативные массивы (они хорошо знакомы программистам, работающим с языком Perl) в одном из следующих релизов Bash.



    65

    Кто может -- тот делает. Кто не может... тот получает сертификат MCSE.







     


    Главная | В избранное | Наш E-MAIL | Добавить материал | Нашёл ошибку | Другие сайты | Наверх