33.7. Разные советы


  • Для ведения учета использования сценария пользователями, добавьте следующие строки в сценарий. Они запишут в файл отчета название сценария и время запуска.

    1. # Добавление (>>) учетной записи, об использовании сценария, в файл отчета.
    2. date>> $SAVE_FILE      # Дата и время.
    3. echo $0>> $SAVE_FILE   # Название сценария.
    4. echo>> $SAVE_FILE      # Пустая строка — как разделитель записей.
    5. # Не забудьте определить переменную окружения SAVE_FILE в ~/.bashrc
    6. # (что нибудь, типа: ~/.scripts-run)


  • Оператор >> производит добавление строки в конец файла. А как быть, если надо добавить строку в начало существующего файла?

    1. file=data.txt
    2. title="***Это титульная строка в текстовом файле***"
    3. echo $title | cat - $file >$file.new
    4. # "cat -" объединяет stdout с содержимым $file.
    5. #  В результате получится
    6. #+ новый файл $file.new, в начало которого добавлена строка $title.


    Само собой разумеется, то же самое можно сделать с помощью sed.

  • Сценарий командной оболочки может использоваться как команда внутри другого сценария командной оболочки, Tcl, или wish сценария или, даже в Makefile. Он может быть вызван как внешняя команда из программы на языке C, с помощью функции system(), т.е. system("script_name");.

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

    1. # Сценарий-библиотека
    2. # ------ -------
    3. # Обратите внимание:
    4. # Здесь нет sha-bang ("#!").
    5. # И нет "живого кода".
    6. # Определения переменных
    7. ROOT_UID=0             # UID root-а, 0.
    8. E_NOTROOT=101          # Ошибка — "обычный пользователь".
    9. MAXRETVAL=255          # Максимальное значение, которое могут возвращать функции.
    10. SUCCESS=0
    11. FAILURE=-1
    12. # Функции
    13. Usage ()               # Сообщение "Порядок использования:".
    14. {
    15.   if [ -z "$1" ]       # Нет аргументов.
    16.   then
    17.     msg=filename
    18.   else
    19.     msg=$@
    20.   fi
    21.   echo "Порядок использования: `basename $0` "$msg""
    22. }
    23. Check_if_root ()       # Проверка прав пользователя.
    24. {                      # из примера "ex39.sh".
    25.   if [ "$UID" -ne "$ROOT_UID" ]
    26.   then
    27.     echo "Этот сценарий должен запускаться с привилегиями root."
    28.     exit $E_NOTROOT
    29.   fi
    30. }
    31. CreateTempfileName ()  # Создание "уникального" имени для временного файла.
    32. {                      # Из примера "ex51.sh".
    33.   prefix=temp
    34.   suffix=`eval date +%s`
    35.   Tempfilename=$prefix.$suffix
    36. }
    37. isalpha2 ()            # Проверка, состоит ли строка только из алфавитных символов.
    38. {                      # Из примера "isalpha.sh".
    39.   [ $# -eq 1 ] || return $FAILURE
    40.   case $1 in
    41.   *[!a-zA-Z]*|"") return $FAILURE;;
    42.   *) return $SUCCESS;;
    43.   esac                 # Спасибо S.C.
    44. }
    45. abs ()                           # Абсолютное значение.
    46. {                                # Внимание: Максимально возможное возвращаеиое значение
    47.                                  # не может превышать 255.
    48.   E_ARGERR=-999999
    49.   if [ -z "$1" ]                 # Проверка наличия входного аргумента.
    50.   then
    51.     return $E_ARGERR             # Код ошибки, обычно возвращаемый в таких случаях.
    52.   fi
    53.   if [ "$1" -ge 0 ]              # Если не отрицательное,
    54.   then                           #
    55.     absval=$1                    # оставить как есть.
    56.   else                           # Иначе,
    57.     let "absval = (( 0 - $1 ))"  # изменить знак.
    58.   fi
    59.   return $absval
    60. }
    61. tolower ()             #  Преобразование строк символов в нижний регистр
    62. {
    63.   if [ -z "$1" ]       #  Если нет входного аргумента,
    64.   then                 #+ выдать сообщение об ошибке
    65.     echo "(null)"
    66.     return             #+ и выйти из функции.
    67.   fi
    68.   echo "$@" | tr A-Z a-z
    69.   # Преобразовать все входные аргументы ($@).
    70.   return
    71. # Для записи результата работы функции в переменную, используйте операцию подстановки команды.
    72. # Например:
    73. #    oldvar="A seT of miXed-caSe LEtTerS"
    74. #    newvar=`tolower "$oldvar"`
    75. #    echo "$newvar"    # a set of mixed-case letters
    76. #
    77. # Упражнение: Добавьте в эту библиотеку функцию перевода символов в верхний регистр.
    78. #           toupper()  [это довольно просто].
    79. }


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

    1. ## Внимание!
    2. rm -rf *.zzy   ##  Комбинация ключей "-rf", в команде "rm", чрезвычайно опасна,
    3.                ##+ особенно при удалении по шаблону.
    4. #+ Продолжение комментария на новой строке.
    5. #  Это первая строка комментария
    6. #+ это вторая строка комментария,
    7. #+ это последняя строка комментария.
    8. #* Обратите внимание.
    9. #o Элемент списка.
    10. #> Альтернативный вариант.
    11. while [ "$var1" != "end" ]    #> while test "$var1" != "end"


  • Для создания блочных комментариев, можно использовать конструкцию if-test.

    1. #!/bin/bash
    2. COMMENT_BLOCK=
    3. #  Если попробовать инициализировать эту переменную чем нибудь,
    4. #+ то вы получите неожиданный результат.
    5. if [ $COMMENT_BLOCK ]; then
    6. Блок комментария --
    7. =================================
    8. Это строка комментария.
    9. Это другая строка комментария.
    10. Это еще одна строка комментария.
    11. =================================
    12. echo "Эта строка не выводится."
    13. Этот блок комментария не вызывает сообщения об ошибке! Круто!
    14. fi
    15. echo "Эта строка будет выведена на stdout."
    16. exit 0


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

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

    1. #!/bin/bash
    2. SUCCESS=0
    3. E_BADINPUT=65
    4. test "$1" -ne 0 -o "$1" -eq 0 2>/dev/null
    5. # Проверка: "равно нулю или не равно нулю".
    6. # 2>/dev/null подавление вывода сообщений об ошибках.
    7. if [ $? -ne "$SUCCESS" ]
    8. then
    9.   echo "Порядок использования: `basename $0` целое_число"
    10.   exit $E_BADINPUT
    11. fi
    12. let "sum = $1 + 25"             # Будет выдавать ошибку, если $1 не является целым числом.
    13. echo "Sum = $sum"
    14. # Любая переменная может быть проверена таким образом, а не только входные аргументы.
    15. exit 0


  • Диапазон, возвращаемых функциями значений, 0 - 255 — серьезное ограничение. Иногда может оказаться весьма проблематичным использование глобальных переменных, для передачи результата из функции. В таких случаях можно порекомендовать передачу результатов работы функции через запись в stdout. Фактически этот прием является разновидностью подстановки команд.

    Пример 33-11. Необычный способ передачи возвращаемого значения

    1. #!/bin/bash
    2. # multiplication.sh
    3. multiply ()                     # Функции выполняет перемножение всех переданых аргументов.
    4. {
    5.   local product=1
    6.   until [ -z "$1" ]             # Пока не дошли до последнего аргумента...
    7.   do
    8.     let "product *= $1"
    9.     shift
    10.   done
    11.   echo $product                 #  Значение не будет выведено на экран,
    12. }                               #+ поскольку оно будет записано в переменную.
    13. mult1=15383; mult2=25211
    14. val1=`multiply $mult1 $mult2`
    15. echo "$mult1 X $mult2 = $val1"
    16.                                 # 387820813
    17. mult1=25; mult2=5; mult3=20
    18. val2=`multiply $mult1 $mult2 $mult3`
    19. echo "$mult1 X $mult2 X $mult3 = $val2"
    20.                                 # 2500
    21. mult1=188; mult2=37; mult3=25; mult4=47
    22. val3=`multiply $mult1 $mult2 $mult3 $mult4`
    23. echo "$mult1 X $mult2 X $mult3 X mult4 = $val3"
    24.                                 # 8173300
    25. exit 0

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

    1. capitalize_ichar ()          #  Первый символ всех строковых аргументов
    2. {                            #+ переводится в верхний регистр.
    3.   string0="$@"               # Принять все аргументы.
    4.   firstchar=${string0:0:1}   # Первый символ.
    5.   string1=${string0:1}       # Остаток строки.
    6.   FirstChar=`echo "$firstchar" | tr a-z A-Z`
    7.                              # Преобразовать в верхний регистр.
    8.   echo "$FirstChar$string1"  # Выдать на stdout.
    9. }
    10. newstring=`capitalize_ichar "each sentence should start with a capital letter."`
    11. echo "$newstring"          # Each sentence should start with a capital letter.


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

    Пример 33-12. Необычный способ получения нескольких возвращаемых значений

    1. #!/bin/bash
    2. # sum-product.sh
    3. # Функция может "возвращать" несколько значений.
    4. sum_and_product ()   # Вычисляет сумму и произведение аргументов.
    5. {
    6.   echo $(( $1 + $2 )) $(( $1 * $2 ))
    7. # Вывод на stdout двух значений, разделенных пробелом.
    8. }
    9. echo
    10. echo "Первое число: "
    11. read first
    12. echo
    13. echo "Второе число: "
    14. read second
    15. echo
    16. retval=`sum_and_product $first $second`      # Получить результат.
    17. sum=`echo "$retval" | awk '{print $1}'`      # Первое значение (поле).
    18. product=`echo "$retval" | awk '{print $2}'`  # Второе значение (поле).
    19. echo "$first + $second = $sum"
    20. echo "$first * $second = $product"
    21. echo
    22. exit 0
  • Следующая хитрость — передача массива в функцию, и "возврат" массива из функции.

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

    Пример 33-13. Передача массива в функцию и возврат массива из функции

    1. #!/bin/bash
    2. # array-function.sh: Передача массива в функцию и...
    3. #                   "возврат" массива из функции
    4. Pass_Array ()
    5. {
    6.   local passed_array   # Локальная переменная.
    7.   passed_array=( `echo "$1"` )
    8.   echo "${passed_array[@]}"
    9.   #  Список всех элементов в новом массиве,
    10.   #+ объявленном и инициализированном в функции.
    11. }
    12. original_array=( element1 element2 element3 element4 element5 )
    13. echo
    14. echo "original_array = ${original_array[@]}"
    15. #                      Список всех элементов исходного массива.
    16. # Так можно отдать массив в функцию.
    17. # **********************************
    18. argument=`echo ${original_array[@]}`
    19. # **********************************
    20. #  Поместив все элементы массива в переменную,
    21. #+ разделяя их пробелами.
    22. #
    23. # Обратите внимание: метод прямой передачи массива в функцию не сработает.
    24. # Так можно получить массив из функции.
    25. # *****************************************
    26. returned_array=( `Pass_Array "$argument"` )
    27. # *****************************************
    28. # Записать результат в переменную-массив.
    29. echo "returned_array = ${returned_array[@]}"
    30. echo "============================================================="
    31. #  А теперь попробуйте получить доступ к локальному массиву
    32. #+ за пределами функции.
    33. Pass_Array "$argument"
    34. # Функция выведет массив, но...
    35. #+ доступ к локальному массиву, за пределами функции, окажется невозможен.
    36. echo "Результирующий массив (внутри функции) = ${passed_array[@]}"
    37. # "ПУСТОЕ" ЗНАЧЕНИЕ, поскольку это локальная переменная.
    38. echo
    39. exit 0

    Более сложный пример передачи массивов в функции, вы найдете в Пример A-11.

  • Использование конструкций с двойными круглыми скобками позволяет применять C-подобный синтаксис операций присвоения и инкремента переменных, а также оформления циклов for и while. См. Пример 10-12 и Пример 10-17.

  • Иногда очень удобно "пропускать" данные через один и тот же фильтр, но с разными параметрами, используя конвейерную обработку. Особенно это относится к tr и grep.

    1. # Из примера "wstrings.sh".
    2. wlist=`strings "$1" | tr A-Z a-z | tr '[:space:]' Z | \
    3. tr -cs '[:alpha:]' Z | tr -s '\173-\377' Z | tr Z ' '`


    Пример 33-14. Игры с анаграммами

    1. #!/bin/bash
    2. # agram.sh: Игры с анаграммами.
    3. # Поиск анаграмм...
    4. LETTERSET=etaoinshrdlu
    5. anagram "$LETTERSET" | # Найти все анаграммы в наборе символов...
    6. grep '.......' |       # состоящие, как минимум из 7 символов,
    7. grep '^is' |           # начинающиеся с 'is'
    8. grep -v 's$' |         # исключая множественное число
    9. grep -v 'ed$'          # и глаголы в прошедшем времени
    10. #  Здесь используется утилита "anagram"
    11. #+ которая входит в состав пакета "yawl" , разработанного автором.
    12. #  <a href="http://ibiblio.org/pub/Linux/libs/yawl-0.2.tar.gz
    13. exit" title="http://ibiblio.org/pub/Linux/libs/yawl-0.2.tar.gz
    14. exit">http://ibiblio.org/pub/Linux/libs/yawl-0.2.tar.gz
    15. exit</a> 0                 # Конец.
    16. bash$ sh agram.sh
    17. islander
    18. isolate
    19. isolead
    20. isotheral

    См. также Пример 27-3, Пример 12-21 и Пример A-10.

  • Для создания блочных комментариев можно использовать "анонимные встроенные документы". См. Пример 17-11.

  • Попытка вызова утилиты из сценария на машине, где эта утилита отсутствует, потенциально опасна. Для обхода подобных проблем можно воспользоваться утилитой whatis.

    1. CMD=command1                 # Основной вариант.
    2. PlanB=command2               # Запасной вариант.
    3. command_test=$(whatis "$CMD" | grep 'nothing appropriate')
    4. #  Если 'command1' не найдена в системе, то 'whatis' вернет
    5. #+ "command1: nothing appropriate."
    6. #==> От переводчика: Будьте внимательны! Если у вас локализованная версия whatis
    7. #==> то вывод от нее может отличаться от используемого здесь ('nothing appropriate')
    8. if [[ -z "$command_test" ]]  # Проверка наличия утилиты в системе.
    9. then
    10.   $CMD option1 option2       #  Запуск команды с параметрами.
    11. else                         #  Иначе,
    12.   $PlanB                     #+ запустить command2 (запасной вариант).
    13. fi


  • Команда run-parts удобна для запуска нескольких сценариев, особенно в комбинации с cron или at.

  • Иногда было бы неплохо снабдить сценарий графическим интерфейстом X-Window. Для этого можно порекомендовать пакеты Xscript, Xmenu и widtools. Правда, первые два, кажется больше не поддерживаются разработчиками. Зато widtools можно получить здесь.

    Caution

    Пакет widtools (widget tools) требует наличия библиотеки XForms. Кроме того, необходимо слегка подправить Makefile, чтобы этот пакет можно было собрать на типичной Linux-системе. Но хуже всего то, что три из шести виджетов не работают :-(( (segfault).

    Утилита dialog — еще один способ создания диалоговых форм из сценариев командной оболочки. Эта утилита предназначена для работы в текстовой консоли, но имеются ее "наследники" — gdialog, Xdialog и kdialog, которые используют графические элементы X-Windows для построения диалоговых форм.

    Пример 33-15. Сценарий с графическим интерфейсом

    1. #!/bin/bash
    2. # dialog.sh: Использование виджетов 'gdialog'.
    3. # В вашей системе должна быть установлена утилита 'gdialog'.
    4. # Идея создания этого сценария появилась после прочтения статьи
    5. #     "Scripting for X Productivity," by Marco Fioretti,
    6. #      LINUX JOURNAL, Issue 113, September 2003, pp. 86-9.
    7. # Спасибо всем сотрудникам LJ.
    8. # Ошибка ввода в диалоговом окне.
    9. E_INPUT=65
    10. # Размеры окна.
    11. HEIGHT=50
    12. WIDTH=60
    13. # Имя выходного файла (конструируется добавлением суффикса к имени файла-сценария).
    14. OUTFILE=$0.output
    15. # Вывести содержимое файла-сценария в отдельном окне.
    16. gdialog --title "Displaying: $0" --textbox $0 $HEIGHT $WIDTH
    17. # Попробуем записать значение, введенное в окне.
    18. echo -n "VARIABLE=\"" > $OUTFILE   # Кавычка на случай, если пользователь введет
    19.                                    #+ несколько слов, разделенных пробелами.
    20. gdialog --title "User Input" --inputbox "Введите значение переменной:" \
    21. $HEIGHT $WIDTH >> $OUTFILE
    22. if [ "$?" -eq 0 ]
    23. # Хороший тон — проверка кода завершения.
    24. then
    25.   echo "Диалог с пользователем завершился без ошибок."
    26. else
    27.   echo "Обнаружены ошибки во время диалога с пользователем."
    28.         # Или была нажата кнопка "Отменить" ("Cancel") вместо "OK".
    29.   rm $OUTFILE
    30.   exit $E_INPUT
    31. fi
    32. echo -n "\"" >> $OUTFILE           # Завершающая кавычка (см. выше).
    33. # Теперь прочитаем значение переменной из файла и выведем его.
    34. . $OUTFILE   # 'Выходной' файл.
    35. echo "Было введено значение переменной: "$VARIABLE""
    36. rm $OUTFILE  # Удалить временный файл.
    37. exit 0

    Кроме того, для постороения приложений с графическим интерфейсом, можно попробовать Tk, или wish (надстройка над Tcl), PerlTk (Perl с поддержкой Tk), tksh (ksh с поддержкой Tk), XForms4Perl (Perl с поддержкой XForms), Gtk-Perl (Perl с поддержкой Gtk) или PyQt (Python с поддержкой Qt).