• Глава 3. Служебные символы
  • Пример 3-1. Вложенные блоки и перенаправление ввода-вывода
  • Пример 3-2. Сохранение результата исполнения вложенного блока в файл
  • Пример 3-3. Запуск цикла в фоновом режиме
  • Пример 3-4. Резервное архивирование всех файлов, которые были изменены в течение последних суток
  • Глава 4. Переменные и параметры. Введение.
  • 4.1. Подстановка переменных
  • Пример 4-1. Присваивание значений переменным и подстановка значений переменных
  • 4.2. Присваивание значений переменным
  • Пример 4-2. Простое присваивание
  • Пример 4-3. Присваивание значений переменным простое и замаскированное
  • 4.3. Переменные Bash не имеют типа
  • Пример 4-4. Целое число или строка?
  • 4.4. Специальные типы переменных
  • Пример 4-5. Позиционные параметры
  • Пример 4-6. wh, whois выяснение имени домена
  • Пример 4-7. Использование команды shift
  • Глава 5. Кавычки
  • Пример 5-1. Вывод "причудливых" переменных
  • Пример 5-2. Экранированные символы
  • Глава 6. Завершение и код завершения
  • Пример 6-1. завершение / код завершения
  • Пример 6-2. Использование символа ! для логической инверсии кода возврата
  • Глава 7. Проверка условий
  • 7.1. Конструкции проверки условий
  • Пример 7-1. Что есть "истина"?
  • Пример 7-2. Эквиваленты команды test -- /usr/bin/test, [ ], и /usr/bin/[
  • Пример 7-3. Арифметические выражения внутри (( ))
  • 7.2. Операции проверки файлов
  • Пример 7-4. Проверка "битых" ссылок
  • 7.3. Операции сравнения
  • Пример 7-5. Операции сравнения
  • Пример 7-6. Проверка -- является ли строка пустой
  • Пример 7-7. zmost
  • 7.4. Вложенные условные операторы if/then
  • 7.5. Проверка степени усвоения материала
  • Глава 8. Операции и смежные темы
  • 8.1. Операторы
  • Пример 8-1. Наибольший общий делитель
  • Пример 8-2. Арифметические операции
  • Пример 8-3. Построение сложных условий, использующих && и ||
  • 8.2. Числовые константы
  • Пример 8-4. Различные представления числовых констант
  • Часть 2. Основы

    Глава 3. Служебные символы

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

    #

    Комментарии. Строки, начинающиеся с символа # (за исключением комбинации #!) -- являются комментариями.

    # Эта строка -- комментарий.


    Комментарии могут располагаться и в конце строки с исполняемым кодом.

    echo "Далее следует комментарий." # Это комментарий.


    Комментариям могут предшествовать пробелы (пробел, табуляция).

    # Перед комментарием стоит символ табуляции.


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

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

    echo "Символ # не означает начало комментария."

    echo 'Символ # не означает начало комментария.'

    echo Символ \# не означает начало комментария.

    echo А здесь символ # означает начало комментария.


    echo ${PATH#*:} # Подстановка -- не комментарий.

    echo $(( 2#101011 )) # База системы счисления -- не комментарий.


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

    Кавычки " ' и \ экранируют действие символа #.

    В операциях поиска по шаблону символ # так же не воспринимается как начало комментария.

    ;

    Разделитель команд. [Точка-с-запятой] Позволяет записывать две и более команд в одной строке.

    echo hello; echo there


    Следует отметить, что символ ";" иногда так же как и # необходимо экранировать.

    ;;

    Ограничитель в операторе выбора case . [Двойная-точка-с-запятой]

    case "$variable" in

    abc) echo "$variable = abc" ;;

    xyz) echo "$variable = xyz" ;;

    esac


    .

    команда "точка". Эквивалент команды source (см. Пример 11-18). Это встроенная команда bash.

    .

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

    bash$ touch .hidden-file

    bash$ ls -l

    total 10

    -rw-r--r-- 1 bozo 4034 Jul 18 22:04 data1.addressbook

    -rw-r--r-- 1 bozo 4602 May 25 13:58 data1.addressbook.bak

    -rw-r--r-- 1 bozo 877 Dec 17 2000 employment.addressbook


    bash$ ls -al

    total 14

    drwxrwxr-x 2 bozo bozo 1024 Aug 29 20:54 ./

    drwx------ 52 bozo bozo 3072 Aug 29 20:51 ../

    -rw-r--r-- 1 bozo bozo 4034 Jul 18 22:04 data1.addressbook

    -rw-r--r-- 1 bozo bozo 4602 May 25 13:58 data1.addressbook.bak

    -rw-r--r-- 1 bozo bozo 877 Dec 17 2000 employment.addressbook

    -rw-rw-r-- 1 bozo bozo 0 Aug 29 20:54 .hidden-file


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

    bash$ pwd

    /home/bozo/projects


    bash$ cd .

    bash$ pwd

    /home/bozo/projects


    bash$ cd ..

    bash$ pwd

    /home/bozo/


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

    bash$ cp /home/bozo/current_work/junk/* .


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

    "

    Двойные кавычки . В строке "STRING", ограниченной двойными кавычками не выполняется интерпретация большинства служебных символов, которые могут находиться в строке. см. Глава 5.

    '

    Одинарные кавычки . [Одинарные кавычки] 'STRING' экранирует все служебные символы в строке STRING. Это более строгая форма экранирования. Смотрите так же Глава 5.

    ,

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

    let "t2 = ((a = 9, 15 / 3))" # Присваивает значение переменной "a" и вычисляет "t2".


    \

    escape. [обратный слэш] Комбинация \X "экранирует" символ X. Аналогичный эффект имеет комбинация с "одинарными кавычками", т.е. 'X'. Символ \ может использоваться для экранирования кавычек " и '.

    Более детальному рассмотрению темы экранирования посвящена Глава 5.

    /

    Разделитель, используемый в указании пути к каталогам и файлам. [слэш] Отделяет элементы пути к каталогам и файлам (например /home/bozo/projects/Makefile).

    В арифметических операциях -- это оператор деления.

    `

    Подстановка команд. [обратные кавычки] Обратные кавычки могут использоваться для записи в переменную команды `command`.

    :

    пустая команда. [двоеточие] Это эквивалент операции "NOP" (no op, нет операции). Может рассматриваться как синоним встроенной команды true. Команда ":" так же является встроенной командой Bash, которая всегда возвращает "true" (0).

    :

    echo $? # 0


    Бесконечный цикл:

    while :

    do

    operation-1

    operation-2

    ...

    operation-n

    done


    # То же самое:

    # while true

    # do

    # ...

    # done


    Символ-заполнитель в условном операторе if/then:

    if condition

    then : # Никаких действий не производится и управление передается дальше

    else

    take-some-action

    fi


    Как символ-заполнитель в операциях, которые предполагают наличие двух операндов, см. Пример 8-2 и параметры по-умолчанию.

    : ${username=`whoami`}

    # ${username=`whoami`} без символа : выдает сообщение об ошибке,

    # если "username" не является командой...


    Как символ-заполнитель для оператора вложенного документа. См. Пример 17-9.

    В операциях с подстановкой параметров (см. Пример 9-13).

    : ${HOSTNAME?} ${USER?} ${MAIL?}

    #Вывод сообщения об ошибке, если одна или более переменных не определены.


    В операциях замены подстроки с подстановкой значений переменных.

    В комбинации с оператором > (оператор перенаправления вывода), усекает длину файла до нуля. Если указан несуществующий файл -- то он создается.

    : > data.xxx # Файл "data.xxx" -- пуст


    # Тот же эффект имеет команда cat /dev/null >data.xxx

    # Однако в данном случае не производится создание нового процесса, поскольку ":" является встроенной командой.

    См. так же Пример 12-11.

    В комбинации с оператором >> -- оператор перенаправления с добавлением в конец файла и обновлением времени последнего доступа (: >> new_file). Если задано имя несуществующего файла, то он создается. Эквивалентно команде touch.

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

    Символ : может использоваться для создания комментариев, хотя и не рекомендуется. Если строка комментария начинается с символа #, то такая строка не проверяется интерпретатором на наличие ошибок. Однако в случае оператора : это не так.

    : Это комментарий, который генерирует сообщение об ошибке, ( if [ $x -eq 3] ).


    Символ ":" может использоваться как разделитель полей в /etc/passwd и переменной $PATH.

    bash$ echo $PATH

    /usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/sbin:/usr/sbin:/usr/games


    !

    инверсия (или логическое отрицание) используемое в условных операторах. Оператор ! инвертирует код завершения команды, к которой он применен. (см. Пример 6-2). Так же используется для логического отрицания в операциях сравнения, например, операция сравнения "равно" ( = ), при использовании оператора отрицания, преобразуется в операцию сравнения -- "не равно" ( != ). Символ ! является зарезервированным ключевым словом BASH.

    В некоторых случаях символ ! используется для косвенного обращения к переменным.

    Кроме того, из командной строки оператор ! запускает механизм историй Bash (см. Приложение F). Примечательно, что этот механизм недоступен из сценариев (т.е. исключительно из командной строки).

    *

    символ-шаблон. [звездочка] Символ * служит "шаблоном" для подстановки в имена файлов. Одиночный символ * означает любое имя файла в заданном каталоге.

    bash$ echo *

    abs-book.sgml add-drive.sh agram.sh alias.sh


    В регулярных выражениях токен * представляет любое количество (в том числе и 0) символов.

    *

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

    Двойная звездочка (два символа звездочки, следующих подряд друг за другом -- **), обозначает операцию возведения в степень.

    ?

    Оператор проверки условия. В некоторых выражениях символ ? служит для проверки выполнения условия.

    В конструкциях с двойными скобками, символ ? подобен трехместному оператору языка C. См. Пример 9-28.

    В выражениях с подстановкой параметра, символ ? проверяет -- установлена ли переменная.

    ?

    сивол-шаблон. Символ ? обозначает одиночный символ при подстановке в имена файлов. В регулярных выражениях служит для обозначения одиночного символа.

    $

    Подстановка переменной.

    var1=5

    var2=23skidoo


    echo $var1 # 5

    echo $var2 # 23skidoo


    Символ $, предшествующий имени переменной, указывает на то, что будет получено значение переменной.

    $

    end-of-line (конец строки). В регулярных выражениях, символ "$" обозначает конец строки.

    ${}

    Подстановка параметра.

    $*, $@

    параметры командной строки.

    $?

    код завершения. Переменная $? хранит код завершения последней выполненной команды, функции или сценария.

    $$

    id процесса. Переменная $$ хранит id процесса сценария.

    ()

    группа команд.

    (a=hello; echo $a)


    Команды, заключенные в круглые скобки исполняются в дочернем процессе -- subshell-е.

    Переменные, создаваемые в дочернем процессе не видны в "родительском" сценарии. Родительский процесс-сценарий, не может обращаться к переменным, создаваемым в дочернем процессе.

    a=123

    ( a=321; )


    echo "a = $a" # a = 123

    # переменная "a" в скобках подобна локальной переменной.


    инициализация массивов.

    Array=(element1 element2 element3)


    {xxx,yyy,zzz,...}

    Фигурные скобки.

    grep Linux file*.{txt,htm*}

    # Поиск всех вхождений слова "Linux"

    # в файлах "fileA.txt", "file2.txt", "fileR.html", "file-87.htm", и пр.


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

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

    echo {file1,file2}\ :{\ A," B",' C'}

    file1 : A file1 : B file1 : C file2 : A file2 : B file2 : C

    {}

    Блок кода. [фигурные скобки] Известен так же как "вложенный блок", эта конструкция, фактически, создает анонимную функцию. Однако, в отличии от обычных функций, переменные, создаваемые во вложенных блоках кода, доступны объемлющему сценарию.

    bash$ { local a; a=123; }

    bash: local: can only be used in a function


    a=123

    { a=321; }

    echo "a = $a" # a = 321 (значение, присвоенное во вложенном блоке кода)


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


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

    Пример 3-1. Вложенные блоки и перенаправление ввода-вывода

    #!/bin/bash

    # Чтение строк из файла /etc/fstab.


    File=/etc/fstab


    {

    read line1

    read line2

    } < $File


    echo "Первая строка в $File :"

    echo "$line1"

    echo

    echo "Вторая строка в $File :"

    echo "$line2"


    exit 0

    Пример 3-2. Сохранение результата исполнения вложенного блока в файл

    #!/bin/bash

    # rpm-check.sh


    # Запрашивает описание rpm-архива, список файлов, и проверяется возможность установки.

    # Результат сохраняется в файле.

    #

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


    SUCCESS=0

    E_NOARGS=65


    if [ -z "$1" ]

    then

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

    exit $E_NOARGS

    fi


    {

    echo

    echo "Описание архива:"

    rpm -qpi $1 # Запрос описания.

    echo

    echo "Список файлов:"

    rpm -qpl $1 # Запрос списка.

    echo

    rpm -i --test $1 # Проверка возможности установки.

    if [ "$?" -eq $SUCCESS ]

    then

    echo "$1 может быть установлен."

    else

    echo "$1 -- установка невозможна!"

    fi

    echo

    } > "$1.test" # Перенаправление вывода в файл.


    echo "Результаты проверки rpm-архива находятся в файле $1.test"


    # За дополнительной информацией по ключам команды rpm см. man rpm.


    exit 0

    В отличие от групп команд в (круглых скобках), описаных выше, вложенные блоки кода, заключенные в {фигурные скобки} исполняются в пределах того же процесса, что и сам скрипт (т.е. не вызывают запуск дочернего процесса -- subshell).[ 12 ]

    {} \;

    pathname -- полное имя файла (т.е. путь к файлу и его имя). Чаще всего используется совместно с командой find.

    Обратите внимание на то, что символ ";", которым завершается ключ -exec команды find, экранируется обратным слэшем. Это необходимо, чтобы предотвратить его интерпретацию.

    [ ]

    test.

    Проверка истинности выражения, заключенного в квадратные скобки [ ]. Примечательно, что [ является частью встроенной команды test (и ее синонимом), И не имеет никакого отношения к "внешней" утилите /usr/bin/test.

    [[ ]]

    test.

    Проверка истинности выражения, заключенного между [[ ]] (зарезервированное слово интерпретатора).

    См. описание конструкции [[ ... ]] ниже.

    [ ]

    элемент массива.

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

    Array[1]=slot_1

    echo ${Array[1]}


    [ ]

    диапазон символов.

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

    (( ))

    двойные круглые скобки.

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

    См. обсуждение, посвященное конструкции (( ... )) .

    > &> >& >> <

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

    Конструкция scriptname >filename перенаправляет вывод scriptname в файл filename. Если файл filename уже существовал, то его прежнее содержимое будет утеряно.

    Конструкция command &>filename перенаправляет вывод команды command, как со stdout, так и с stderr, в файл filename.

    Конструкция command >&2 перенаправляет вывод со stdout на stderr.

    Конструкция scriptname >>filename добавляет вывод scriptname к файлу filename. Если задано имя несуществующего файла, то он создается.

    подстановка процесса.

    (command)>

    <(command)

    В операциях сравнения, символы "<" и ">" обозначают операции сравнения строк .

    А так же -- операции сравнения целых чисел. См. так же Пример 12-6.

    <<

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

    <, >

    Посимвольное ASCII-сравнение.

    veg1=carrots

    veg2=tomatoes


    if [[ "$veg1" < "$veg2" ]]

    then

    echo "Не смотря на то, что в словаре слово $veg1 предшествует слову $veg2,"

    echo "это никак не отражает мои кулинарные предпочтения."

    else

    echo "Интересно. Каким словарем вы пользуетесь?"

    fi


    \<, \>

    границы отдельных слов в регулярных выражениях.

    bash$ grep '\<the\>' textfile

    |

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

    echo ls -l | sh

    # Передает вывод "echo ls -l" команлному интерпретатору shell,

    #+ тот же результат дает простая команда "ls -l".


    cat *.lst | sort | uniq

    # Объединяет все файлы ".lst", сортирует содержимое и удаляет повторяющиеся строки.


    Конвейеры (еще их называют каналами) -- это классический способ взаимодействия процессов, с помощью которого stdout одного процесса перенаправляется на stdin другого. Обычно используется совместно с командами вывода, такими как cat или echo, от которых поток данных поступает в "фильтр" (команда, которая на входе получает данные, преобразует их и обрабатывает).

    cat $filename | grep $search_word

    В конвейер могут объединяться и сценарии на языке командной оболочки.

    #!/bin/bash

    # uppercase.sh : Преобразование вводимых символов в верхний регистр.


    tr 'a-z' 'A-Z'

    # Диапазоны символов должны быть заключены в кавычки

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


    exit 0

    А теперь попробуем объединить в конвейер команду ls -l с этим сценарием.

    bash$ ls -l | ./uppercase.sh

    -RW-RW-R-- 1 BOZO BOZO 109 APR 7 19:49 1.TXT

    -RW-RW-R-- 1 BOZO BOZO 109 APR 14 16:48 2.TXT

    -RW-R--R-- 1 BOZO BOZO 725 APR 20 20:56 DATA-FILE


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

    cat file1 file2 | ls -l | sort

    # Вывод команды "cat file1 file2" будет утерян.


    Конвейер исполняется в дочернем процессе, а посему -- не имеет доступа к переменным сценария.

    variable="initial_value"

    echo "new_value" | read variable

    echo "variable = $variable" # variable = initial_value


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

    >|

    принудительное перенаправление, даже если установлен ключ noclobber option.

    ||

    логическая операция OR (логическое ИЛИ). В опрециях проверки условий, оператор || возвращает 0 (success), если один из операндов имеет значение true (ИСТИНА).

    &

    Выполнение задачи в фоне. Команда, за которой стоит &, будет исполняться в фоновом режиме.

    bash$ sleep 10 &

    [1] 850

    [1]+ Done sleep 10


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

    Пример 3-3. Запуск цикла в фоновом режиме

    #!/bin/bash

    # background-loop.sh


    for i in 1 2 3 4 5 6 7 8 9 10 # Первый цикл.

    do

    echo -n "$i "

    done & # Запуск цикла в фоне.

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


    echo # Этот 'echo' иногда не отображается на экране.


    for i in 11 12 13 14 15 16 17 18 19 20 # Второй цикл.

    do

    echo -n "$i "

    done


    echo # Этот 'echo' иногда не отображается на экране.


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


    # Ожидается, что данный сценарий выведет следующую последовательность:

    # 1 2 3 4 5 6 7 8 9 10

    # 11 12 13 14 15 16 17 18 19 20


    # Иногда возможен такой вариант:

    # 11 12 13 14 15 16 17 18 19 20

    # 1 2 3 4 5 6 7 8 9 10 bozo $

    # (Второй 'echo' не был выполнен. Почему?)


    # Изредка возможен такой вариант:

    # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    # (Первый 'echo' не был выполнен. Почему?)


    # Крайне редко встречается и такое:

    # 11 12 13 1 2 3 4 5 6 7 8 9 10 14 15 16 17 18 19 20

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


    exit 0

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

    &&

    Логическая операция AND (логическое И). В операциях проверки условий, оператор && возвращает 0 (success) тогда, и только тогда, когда оба операнда имеют значение true (ИСТИНА).

    -

    префикс ключа. С этого символа начинаются опциональные ключи команд.

    COMMAND -[Option1][Option2][...]

    ls -al

    sort -dfu $filename

    set -- $variable

    if [ $file1 -ot $file2 ]

    then

    echo "Файл $file1 был создан раньше чем $file2."

    fi


    if [ "$a" -eq "$b" ]

    then

    echo "$a равно $b."

    fi


    if [ "$c" -eq 24 -a "$d" -eq 47 ]

    then

    echo "$c равно 24, а $d равно 47."

    fi


    -

    перенаправление из/в stdin или stdout. [дефис]

    (cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)

    # Перемещение полного дерева файлов и подкаталогов из одной директории в другую

    # [спасибо Алану Коксу (Alan Cox) <a.cox@swansea.ac.uk>, за небольшие поправки]


    # 1) cd /source/directory Переход в исходный каталог, содержимое которого будет перемещено

    # 2) && "И-список": благодаря этому все последующие команды будут выполнены

    # только тогда, когда 'cd' завершится успешно

    # 3) tar cf - . ключом 'c' архиватор 'tar' создает новый архив,

    # ключом 'f' (file) и последующим '-' задается файл архива -- stdout,

    # в архив помещается текущий каталог ('.') с вложенными подкаталогами.

    # 4) | конвейер с ...

    # 5) ( ... ) subshell-ом (дочерним экземпляром командной оболочки)

    # 6) cd /dest/directory Переход в каталог назначения.

    # 7) && "И-список", см. выше

    # 8) tar xpvf - Разархивирование ('x'), с сохранением атрибутов "владельца" и прав доступа ('p') к файлам,

    # с выдачей более подробных сообщений на stdout ('v'),

    # файл архива -- stdin ('f' с последующим '-').

    #

    # Примечательно, что 'x' -- это команда, а 'p', 'v' и 'f' -- ключи

    # Во как!


    # Более элегантный вариант:

    # cd source-directory

    # tar cf - . | (cd ../target-directory; tar xzf -)

    #

    # cp -a /source/directory /dest имеет тот же эффект.


    bunzip2 linux-2.4.3.tar.bz2 | tar xvf -

    # --разархивирование tar-файла-- | --затем файл передается утилите "tar"--

    # Если у вас утилита "tar" не поддерживает работу с "bunzip2",

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

    # Целью данного примера является разархивирование тарбола (tar.bz2) с исходными текстами ядра.


    Обратите внимание, что в этом контексте "-" - не самостоятельный оператор Bash, а скорее опция, распознаваемая некоторыми утилитами UNIX (такими как tar, cat и т.п.), которые выводят результаты своей работы в stdout.

    bash$ echo "whatever" | cat -

    whatever


    В случае, когда ожидается имя файла, тогда "-" перенаправляет вывод на stdout (вспомните пример с tar cf) или принимает ввод с stdin.

    bash$ file

    Usage: file [-bciknvzL] [-f namefile] [-m magicfiles] file...

    Сама по себе команда file без параметров завершается с сообщением об ошибке.

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

    bash$ file -

    abc

    standard input: ASCII text


    bash$ file -

    #!/bin/bash

    standard input: Bourne-Again shell script text executable

    Теперь команда принимает ввод пользователя со stdin и анализирует его.

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

    С помощью команды diff -- находить различия между одним файлом и частью другого:

    grep Linux file1 | diff file2 -

    И наконец пример использования служебного символа "-" с командой tar.

    Пример 3-4. Резервное архивирование всех файлов, которые были изменены в течение последних суток

    #!/bin/bash


    # Резервное архивирование (backup) всех файлов в текущем каталоге,

    # которые были изменены в течение последних 24 часов

    #+ в тарболл (tarball) (.tar.gz - файл).


    BACKUPFILE=backup

    archive=${1:-$BACKUPFILE}

    # На случай, если имя архива в командной строке не задано,

    #+ т.е. по-умолчанию имя архива -- "backup.tar.gz"


    tar cvf - `find . -mtime -1 -type f -print` > $archive.tar

    gzip $archive.tar

    echo "Каталог $PWD заархивирован в файл \"$archive.tar.gz\"."


    # Stephane Chazelas заметил, что вышеприведенный код будет "падать"

    #+ если будет найдено слишком много файлов

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


    # Им предложен альтернативный код:

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

    # find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"

    # используется версия GNU утилиты "find".


    # find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;

    # более универсальный вариант, хотя и более медленный,

    # зато может использоваться в других версиях UNIX.

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


    exit 0

    Могут возникнуть конфликтные ситуации между опреатором перенаправления "-" и именами файлов, начинающимися с символа "-". Поэтому сценарий должен проверять имена файлов и предаварять их префиксом пути, например, ./-FILENAME, $PWD/-FILENAME или $PATHNAME/-FILENAME.

    Если значение переменной начинается с символа "-", то это тоже может быть причиной появления ошибок.

    var="-n"

    echo $var

    # В данном случае команда приобретет вид "echo -n" и ничего не выведет.


    -

    предыдущий рабочий каталог. [дефис] Команда cd - выполнит переход в предыдущий рабочий каталог, путь к которому хранится в переменной окружения $OLDPWD .

    Не путайте оператор "-" (предыдущего рабочего каталога) с оператором "-" (переназначения). Еще раз напомню, что интерпретация символа "-" зависит от контекста, в котором он употребляется.

    -

    Минус. Знак минус в арифметических операциях.

    =

    Символ "равно". Оператор присваивания

    a=28

    echo $a # 28


    В зависимости от контекста применения, символ "=" может выступать в качестве оператора сравнения.

    +

    Плюс. Оператор сложения в арифметических операциях.

    В зависимости от контекста применения, символ + может выступать как оператор регулярного выражения.

    +

    Ключ (опция). Дополнительный флаг для ключей (опций) команд.

    Отдельные внешние и встроенные команды используют символ "+" для разрешения некоторой опции, а символ "-" -- для запрещения.

    %

    модуль. Модуль (остаток от деления) -- арифметическая операция.

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

    ~

    домашний каталог. [тильда] Соответствует содержимому внутренней переменной $HOME. ~bozo -- домашний каталог пользователя bozo, а команда ls ~bozo выведет содержимое его домашнего каталога. ~/ -- это домашний каталог текущего пользователя, а команда ls ~/ выведет содержимое домашнего каталога текущего пользователя.

    bash$ echo ~bozo

    /home/bozo


    bash$ echo ~

    /home/bozo


    bash$ echo ~/

    /home/bozo/


    bash$ echo ~:

    /home/bozo:


    bash$ echo ~nonexistent-user

    ~nonexistent-user


    ~+

    текущий рабочий каталог. Соответствует содержимому внутренней переменной $PWD.

    ~-

    предыдущий рабочий каталог. Соответствует содержимому внутренней переменной $OLDPWD.

    ^

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

    Управляющий символ

    изменяет поведение терминала или управляет выводом текста. Управляющий символ набирается с клавиатуры как комбинация CONTROL + <клавиша>.

    ? Ctl-C

    Завершение выполнения процесса.

    ? Ctl-D

    Выход из командного интерпретатора (log out) (аналог команды exit).

    "EOF" (признак конца файла). Этот символ может выступать в качестве завершающего при вводе с stdin.

    ? Ctl-G

    "BEL" (звуковой сигнал -- "звонок").

    ? Ctl-H

    Backspace -- удаление предыдущего символа.

    #!/bin/bash

    # Вставка символа Ctl-H в строку.


    a="^H^H" # Два символа Ctl-H (backspace).

    echo "abcdef" # abcdef

    echo -n "abcdef$a " # abcd f

    # Пробел в конце ^ ^ двойной шаг назад.

    echo -n "abcdef$a" # abcdef

    # Пробела в конце нет backspace не работает (почему?).

    # Результаты могут получиться совсем не те, что вы ожидаете.

    echo; echo


    ? Ctl-J

    Возврат каретки.

    ? Ctl-L

    Перевод формата (очистка экрана (окна) терминала). Аналогична команде clear.

    ? Ctl-M

    Перевод строки.

    ? Ctl-U

    Стирание строки ввода.

    ? Ctl-Z

    Приостановка процесса.

    Пробельный символ

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

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

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

    Глава 4. Переменные и параметры. Введение.

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


    4.1. Подстановка переменных

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

    $

    Необходимо всегда помнить о различиях между именем переменной и ее значением. Если variable1 -- это имя переменной, то $variable1 -- это ссылка на ее значение. "Чистые" имена переменных, без префикса $, могут использоваться только при объявлении переменный, при присваивании переменной некоторого значения, при удалении (сбросе), при экспорте и в особых случаях -- когда переменная представляет собой название сигнала (см. Пример 29-5). Присваивание может производится с помощью символа = (например: var1=27), инструкцией read и в заголовке цикла (for var2 in 1 2 3).

    Заключение ссылки на переменную в двойные кавычки (" ") никак не сказывается на работе механизма подстановки. Этот случай называется "частичные кавычки", иногда можно встретить название "нестрогие кавычки". Одиночные кавычки (' ') заставляют интерпретатор воспринимать ссылку на переменную как простой набор символов, потому в одинарных кавычках операции подстановки не производятся. Этот случай называется "полные", или "строгие" кавычки. Дополнительную информацию вы найдете в Глава 5.

    Примечательно, что написание $variable фактически является упрощенной формой написания ${variable}. Более строгая форма записи ${variable} может с успехом использоваться в тех случаях, когда применение упрощенной формы записи порождает сообщения о синтаксических ошибках (см. Section 9.3, ниже).

    Пример 4-1. Присваивание значений переменным и подстановка значений переменных

    #!/bin/bash


    # Присваивание значений переменным и подстановка значений переменных


    a=375

    hello=$a


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

    # Использование пробельных символов

    # с обеих сторон символа "=" присваивания недопустимо.


    # Если записать "VARIABLE =value",

    #+ то интерпретатор попытается выполнить команду "VARIABLE" с параметром "=value".


    # Если записать "VARIABLE= value",

    #+ то интерпретатор попытается установить переменную окружения "VARIABLE" в ""

    #+ и выполнить команду "value".

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


    echo hello # Это не ссылка на переменную, выведет строку "hello".


    echo $hello

    echo ${hello} # Идентично предыдущей строке.


    echo "$hello"

    echo "${hello}"


    echo


    hello="A B C D"

    echo $hello # A B C D

    echo "$hello" # A B C D

    # Здесь вы сможете наблюдать различия в выводе echo $hello и echo "$hello".

    # Заключение ссылки на переменную в кавычки сохраняет пробельные символы.


    echo


    echo '$hello' # $hello

    # Внутри одинарных кавычек не производится подстановка значений переменных,

    #+ т.е. "$" интерпретируется как простой символ.


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


    hello= # Запись пустого значения в переменную.

    echo "\$hello (пустое значение) = $hello"

    # Обратите внимание: запись пустого значения -- это не то же самое,

    #+ что сброс переменной, хотя конечный результат -- тот же (см. ниже).


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


    # Допускается присваивание нескольких переменных в одной строке,

    #+ если они отделены пробельными символами.

    # Внимание! Это может снизить читабельность сценария и оказаться непереносимым.


    var1=variable1 var2=variable2 var3=variable3

    echo

    echo "var1=$var1 var2=$var2 var3=$var3"


    # Могут возникнуть проблемы с устаревшими версиями "sh".


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


    echo; echo


    numbers="один два три"

    other_numbers="1 2 3"

    # Если в значениях переменных встречаются пробелы,

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

    echo "numbers = $numbers"

    echo "other_numbers = $other_numbers" # other_numbers = 1 2 3

    echo


    echo "uninitialized_variable = $uninitialized_variable"

    # Неинициализированная переменная содержит "пустое" значение.

    uninitialized_variable= # Объявление неинициализированной переменной

    #+ (то же, что и присваивание пустого значения, см. выше).

    echo "uninitialized_variable = $uninitialized_variable"

    # Переменная содержит "пустое" значение.


    uninitialized_variable=23 # Присваивание.

    unset uninitialized_variable # Сброс.

    echo "uninitialized_variable = $uninitialized_variable"

    # Переменная содержит "пустое" значение.


    echo


    exit 0

    Неинициализированная переменная хранит "пустое" значение - не ноль!. Использование неинициализированных переменных может приводить к ошибкам разного рода в процессе исполнения.

    Не смотря на это в арифметических операциях допускается использовать неинициализированные переменные.

    echo "$uninitialized" # (пустая строка)

    let "uninitialized += 5" # Прибавить 5.

    echo "$uninitialized" # 5


    # Заключение:

    # Неинициализированные переменные не имеют значения, однако

    #+ в арифметических операциях за значение таких переменных принимается число 0.

    # Это недокументированная (и возможно непереносимая) возможность.

    См. так же Пример 11-19.


    4.2. Присваивание значений переменным

    =

    оператор присваивания (пробельные символы до и после оператора -- недопустимы)

    Не путайте с операторами сравнения = и -eq!

    Обратите внимание: символ = может использоваться как в качестве оператора присваивания, так и в качестве оператора сравнения, конкретная интерпретация зависит от контекста применения.

    Пример 4-2. Простое присваивание

    #!/bin/bash

    # Явные переменные


    echo


    # Когда перед именем переменной не употребляется символ '$'?

    # В операциях присваивания.


    # Присваивание

    a=879

    echo "Значение переменной \"a\" -- $a."


    # Присваивание с помощью ключевого слова 'let'

    let a=16+5

    echo "Значение переменной \"a\" теперь стало равным: $a."


    echo


    # В заголовке цикла 'for' (своего рода неявное присваивание)

    echo -n "Значения переменной \"a\" в цикле: "

    for a in 7 8 9 11

    do

    echo -n "$a "

    done


    echo

    echo


    # При использовании инструкции 'read' (тоже одна из разновидностей присваивания)

    echo -n "Введите значение переменной \"a\" "

    read a

    echo "Значение переменной \"a\" теперь стало равным: $a."


    echo


    exit 0

    Пример 4-3. Присваивание значений переменным простое и замаскированное

    #!/bin/bash


    a=23 # Простейший случай

    echo $a

    b=$a

    echo $b


    # Теперь немного более сложный вариант (подстановка команд).


    a=`echo Hello!` # В переменную 'a' попадает результат работы команды 'echo'

    echo $a

    # Обратите внимание на восклицательный знак (!) в подстанавливаемой команде

    #+ этот вариант не будет работать при наборе в командной строке,

    #+ поскольку здесь используется механизм "истории команд" BASH

    # Однако, в сценариях, механизм истории команд запрещен.


    a=`ls -l` # В переменную 'a' записывается результат работы команды 'ls -l'

    echo $a # Кавычки отсутствуют, удаляются лишние пробелы и пустые строки.

    echo

    echo "$a" # Переменная в кавычках, все пробелы и пустые строки сохраняются.

    # (См. главу "Кавычки.")


    exit 0

    Присваивание переменных с использованием $(...) (более современный метод, по сравнению с обратными кавычками)

    # Взято из /etc/rc.d/rc.local

    R=$(cat /etc/redhat-release)

    arch=$(uname -m)


    4.3. Переменные Bash не имеют типа

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

    Пример 4-4. Целое число или строка?

    #!/bin/bash

    # int-or-string.sh: Целое число или строка?


    a=2334 # Целое число.

    let "a += 1"

    echo "a = $a " # a = 2335

    echo # Все еще целое число.


    b=${a/23/BB} # замена "23" на "BB".

    # Происходит трансформация числа в строку.

    echo "b = $b" # b = BB35

    declare -i b # Явное указание типа здесь не поможет.

    echo "b = $b" # b = BB35


    let "b += 1" # BB35 + 1 =

    echo "b = $b" # b = 1

    echo


    c=BB34

    echo "c = $c" # c = BB34

    d=${c/BB/23} # замена "BB" на "23".

    # Переменная $d становится целочисленной.

    echo "d = $d" # d = 2334

    let "d += 1" # 2334 + 1 =

    echo "d = $d" # d = 2335

    echo


    # А что происходит с "пустыми" переменными?

    e=""

    echo "e = $e" # e =

    let "e += 1" # Арифметические операции допускают использование "пустых" переменных?

    echo "e = $e" # e = 1

    echo # "Пустая" переменная становится целочисленной.


    # А что происходит с необъявленными переменными?

    echo "f = $f" # f =

    let "f += 1" # Арифметические операции допустимы?

    echo "f = $f" # f = 1

    echo # Необъявленная переменная трансформируется в целочисленную.


    # Переменные Bash не имеют типов.


    exit 0

    Отсутствие типов -- это и благословение и проклятие. С одной стороны -- отсутствие типов делает сценарии более гибкими (чтобы повеситься -- достаточно иметь веревку!) и облегчает чтение кода. С другой -- является источником потенциальных ошибок и поощряет привычку к "неряшливому" программированию.

    Бремя отслеживания типа той или иной переменной полностью лежит на плечах программиста. Bash не будет делать это за вас!


    4.4. Специальные типы переменных

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

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

    переменные окружения

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

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

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

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

    bash$ eval "`seq 10000 | sed -e 's/.*/export var&=ZZZZZZZZZZZZZZ/'`"


    bash$ du

    bash: /usr/bin/du: Argument list too long


    (Спасибо S. C. за вышеприведенный пример и пояснения.)

    Если сценарий изменяет переменные окружения, то они должны "экспортироваться", т.е передаваться окружению, локальному по отношению к сценарию. Эта функция возложена на команду export.

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

    ---

    позиционные параметры

    аргументы, передаваемые скрипту из командной строки -- $0, $1, $2, $3..., где $0 -- это название файла сценария, $1 -- это первый аргумент, $2 -- второй, $3 -- третий и так далее[ 13 ]. Аргументы, следующие за $9, должны заключаться в фигурные скобки, например: ${10}, ${11}, ${12}.

    Специальные переменные $* и $@ содержат все позиционные параметры (аргументы командной строки).

    Пример 4-5. Позиционные параметры

    #!/bin/bash


    # Команда вызова сценария должна содержать по меньшей мере 10 параметров, например

    # ./scriptname 1 2 3 4 5 6 7 8 9 10

    MINPARAMS=10


    echo


    echo "Имя файла сценария: \"$0\"."

    # Для текущего каталога добавит ./

    echo "Имя файла сценария: \"`basename $0`\"."

    # Добавит путь к имени файла (см. 'basename')


    echo


    if [ -n "$1" ] # Проверяемая переменная заключена в кавычки.

    then

    echo "Параметр #1: $1" # необходимы кавычки для экранирования символа #

    fi


    if [ -n "$2" ]

    then

    echo "Параметр #2: $2"

    fi


    if [ -n "$3" ]

    then

    echo "Параметр #3: $3"

    fi


    # ...


    if [ -n "${10}" ] # Параметры, следующие за $9 должны заключаться в фигурные скобки

    then

    echo "Параметр #10: ${10}"

    fi


    echo "-----------------------------------"

    echo "Все аргументы командной строки: "$*""


    if [ $# -lt "$MINPARAMS" ]

    then

    echo

    echo "Количество аргументов командной строки должно быть не менее $MINPARAMS !"

    fi


    echo


    exit 0

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

    args=$# # Количество переданных аргументов.

    lastarg=${!args} # Обратите внимание: lastarg=${!$#} неприменимо.


    В сценарии можно предусмотреть различные варианты развития событий, в зависимости от имени сценария. Для этого сценарий должен проанализировать аргумент $0 -- имя файла сценария. Это могут быть и имена символических ссылок на файл сценария.

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

    variable1_=$1_

    # Это предотвратит появление ошибок, даже при отсутствии входного аргумента.


    critical_argument01=$variable1_


    # Дополнительные символы всегда можно "убрать" позднее.

    # Это может быть сделано примерно так:

    variable1=${variable1_/_/} # Побочный эффект возникает только если имя переменной

    # $variable1_ будет начинаться с символа "_".

    # Здесь используется один из вариантов подстановки параметров, обсуждаемых в Главе 9.

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


    # Более простой способ заключается

    #+ в обычной проверке наличия позиционного параметра.

    if [ -z $1 ]

    then

    exit $POS_PARAMS_MISSING

    fi

    ---

    Пример 4-6. wh, whois выяснение имени домена

    #!/bin/bash


    # Команда 'whois domain-name' выясняет имя домена на одном из 3 серверов:

    # ripe.net, cw.net, radb.net


    # Разместите этот скрипт под именем 'wh' в каталоге /usr/local/bin


    # Требуемые символические ссылки:

    # ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe

    # ln -s /usr/local/bin/wh /usr/local/bin/wh-cw

    # ln -s /usr/local/bin/wh /usr/local/bin/wh-radb


    if [ -z "$1" ]

    then

    echo "Порядок использования: `basename $0` [domain-name]"

    exit 65

    fi


    case `basename $0` in

    # Проверка имени скрипта и, соответственно, имени сервера

    "wh" ) whois $1@whois.ripe.net;;

    "wh-ripe") whois $1@whois.ripe.net;;

    "wh-radb") whois $1@whois.radb.net;;

    "wh-cw" ) whois $1@whois.cw.net;;

    * ) echo "Порядок использования: `basename $0` [domain-name]";;

    esac


    exit 0

    ---

    Команда shift "сдвигает" позиционные параметры, в результате чего парметры "сдвигаются" на одну позицию влево.

    $1 <--- $2, $2 <--- $3, $3 <--- $4, и т.д.

    Прежний аргумент $1 теряется, но аргумент $0 (имя файла сценария) остается без изменений. Если вашему сценарию передается большое количество входных аргументов, то команда shift позволит вам получить доступ к аргументам, с порядковым номером больше 9, без использования {фигурных скобок}.

    Пример 4-7. Использование команды shift

    #!/bin/bash

    # Использование команды 'shift' с целью перебора всех аргументов командной строки.


    # Назовите файл с этим сценарием, например "shft",

    #+ и вызовите его с набором аргументов, например:

    # ./shft a b c def 23 skidoo


    until [ -z "$1" ] # До тех пор пока не будут разобраны все входные аргументы...

    do

    echo -n "$1 "

    shift

    done


    echo # Дополнительная пустая строка.


    exit 0

    Команда shift может применяться и к входным аргументам функций. См. Пример 33-10.


    Глава 5. Кавычки

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

    bash$ ls -l [Vv]*

    -rw-rw-r-- 1 bozo bozo 324 Apr 2 15:05 VIEWDATA.BAT

    -rw-rw-r-- 1 bozo bozo 507 May 4 14:25 vartrace.sh

    -rw-rw-r-- 1 bozo bozo 539 Apr 14 17:11 viewdata.sh


    bash$ ls -l '[Vv]*'

    ls: [Vv]*: No such file or directory


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

    bash$ grep '[Пп]ервая' *.txt

    file1.txt:Это первая строка в file1.txt.

    file2.txt:Это Первая строка в file2.txt.


    Примечательно, что "не окавыченный" вариант команды grep [Пп]ервая *.txt будет правильно исполняться в Bash, но не в tcsh.

    Вообще, желательно использовать двойные кавычки (" ") при обращении к переменным. Это предотвратит интерпретацию специальных символов, которые могут содержаться в именах переменных, за исключением $, ` (обратная кавычка) и \ (escape -- обратный слэш)[ 14 ]. То, что символ $ попал в разряд исключений, позволяет выполнять обращение к переменным внутри строк, ограниченных двойными кавычками ("$variable"), т.е. выполнять подстановку значений переменных (см. Пример 4-1, выше).

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

    variable1="a variable containing five words"

    COMMAND This is $variable1 # Исполнение COMMAND с 7 входными аргументами:

    # "This" "is" "a" "variable" "containing" "five" "words"


    COMMAND "This is $variable1" # Исполнение COMMAND с одним входным аргументом:

    # "This is a variable containing five words"


    variable2="" # Пустая переменная.


    COMMAND $variable2 $variable2 $variable2 # Исполнение COMMAND без аргументов.

    COMMAND "$variable2" "$variable2" "$variable2" # Исполнение COMMAND с 3 "пустыми" аргументами.

    COMMAND "$variable2 $variable2 $variable2" # Исполнение COMMAND с 1 аргументом (и 2 пробелами).


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


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

    Пример 5-1. Вывод "причудливых" переменных

    #!/bin/bash

    # weirdvars.sh: Вывод "причудливых" переменных


    var="'(]\\{}\$\""

    echo $var # '(]\{}$"

    echo "$var" # '(]\{}$" Никаких различий.


    echo


    IFS='\'

    echo $var # '(] {}$" \ символ-разделитель преобразован в пробел.

    echo "$var" # '(]\{}$"


    # Примеры выше предоставлены S.C.


    exit 0

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

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

    echo "Why can't I write 's between single quotes"


    echo


    # Обходной метод.

    echo 'Why can'\''t I write '"'"'s between single quotes'

    # |-------| |----------| |-----------------------|

    # Три строки, ограниченных одинарными кавычками,

    # и экранированные одиночные кавычки между ними.


    # Пример любезно предоставлен Stephane Chazelas.


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

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

    Специальное назначение некоторых экранированных символов

    используемых совместно с echo и sed

    \n

    перевод строки (новая строка)

    \r

    перевод каретки

    \t

    табуляция

    \v

    вертикальная табуляция

    \b

    забой (backspace)

    \a

    "звонок" (сигнал)

    \0xx

    ASCII-символ с кодом 0xx в восьмеричном виде)

    Пример 5-2. Экранированные символы

    #!/bin/bash

    # escaped.sh: экранированные символы


    echo; echo


    echo "\v\v\v\v" # Вывод последовательности символов \v\v\v\v.

    # Для вывода экранированных символов следует использовать ключ -e.

    echo "============="

    echo "ВЕРТИКАЛЬНАЯ ТАБУЛЯЦИЯ"

    echo -e "\v\v\v\v" # Вывод 4-х вертикальных табуляций.

    echo "=============="


    echo "КАВЫЧКИ"

    echo -e "\042" # Выводит символ " (кавычки с восьмеричным кодом ASCII 42).

    echo "=============="


    # Конструкция $'\X' делает использование ключа -e необязательным.

    echo; echo "НОВАЯ СТРОКА И ЗВОНОК"

    echo $'\n' # Перевод строки.

    echo $'\a' # Звонок (сигнал).


    echo "==============="

    echo "КАВЫЧКИ"

    # Bash версии 2 и выше допускает использование конструкции $'\nnn'.

    # Обратите внимание: здесь под '\nnn' подразумевается восьмеричное значение.

    echo $'\t \042 \t' # Кавычки (") окруженные табуляцией.


    # В конструкции $'\xhhh' допускается использовать и шестнадцатеричные значения.

    echo $'\t \x22 \t' # Кавычки (") окруженные табуляцией.

    # Спасибо Greg Keraunen, за это примечание.

    # Ранние версии Bash допускали употребление конструкции в виде '\x022'.

    echo "==============="

    echo


    # Запись ASCII-символов в переменную.

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

    quote=$'\042' # запись символа " в переменную.

    echo "$quote Эта часть строки ограничена кавычками, $quote а эта -- нет."


    echo


    # Конкатенация ASCII-символов в переменную.

    triple_underline=$'\137\137\137' # 137 -- это восьмеричный код символа '_'.

    echo "$triple_underline ПОДЧЕРКИВАНИЕ $triple_underline"


    echo


    ABC=$'\101\102\103\010' # 101, 102, 103 это A, B и C соответственно.

    echo $ABC


    echo; echo


    escape=$'\033' # 033 -- восьмеричный код экранирующего символа.

    echo "\"escape\" выводится как $escape"

    # вывод отсутствует.


    echo; echo


    exit 0

    Еще один пример использования конструкции $' ' вы найдете в Пример 34-1.

    \"

    кавычки

    echo "Привет" # Привет

    echo "Он сказал: \"Привет\"." # Он сказал: "Привет".


    \$

    символ доллара (если за комбинацией символов \$ следует имя переменной, то она не будет разыменована)

    echo "\$variable01" # выведет $variable01


    \\

    обратный слэш

    echo "\\" # выведет \


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

    # Простое экранирование и кавычки

    echo \z # z

    echo \\z # \z

    echo '\z' # \z

    echo '\\z' # \\z

    echo "\z" # \z

    echo "\\z" # \z


    # Подстановка команды

    echo `echo \z` # z

    echo `echo \\z` # z

    echo `echo \\\z` # \z

    echo `echo \\\\z` # \z

    echo `echo \\\\\\z` # \z

    echo `echo \\\\\\\z` # \\z

    echo `echo "\z"` # \z

    echo `echo "\\z"` # \z


    # Встроенный документ

    cat <<EOF

    \z

    EOF # \z


    cat <<EOF

    \\z

    EOF # \z


    # Эти примеры предоставил Stephane Chazelas.


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

    variable=\

    echo "$variable"

    # Не работает - дает сообщение об ошибке:

    # test.sh: : command not found

    # В "чистом" виде экранирующий (escape) символ не может быть записан в переменную.

    #

    # Фактически, в данном примере, происходит экранирование символа перевода строки

    #+ в результате получается такая команда: variable=echo "$variable"

    #+ ошибочное присваивание


    variable=\

    23skidoo

    echo "$variable" # 23skidoo

    # Здесь все в порядке, поскольку вторая строка

    #+ является нормальным, с точки зрения присваивания, выражением.


    variable=\

    # \^ За escape-символом следует пробел

    echo "$variable" # пробел


    variable=\\

    echo "$variable" # \


    variable=\\\

    echo "$variable"

    # Не работает - сообщение об ошибке:

    # test.sh: \: command not found

    #

    # Первый escape-символ экранирует второй, а третий оказывается неэкранированным,

    #+ результат тот же, что и в первом примере.


    variable=\\\\

    echo "$variable" # \\

    # Второй и четвертый escape-символы экранированы.

    # Это нормально.


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

    file_list="/bin/cat /bin/gzip /bin/more /usr/bin/less /usr/bin/emacs-20.7"

    # Список файлов как аргумент(ы) командной строки.


    # Добавить два файла в список и вывести список.

    ls -l /usr/X11R6/bin/xsetroot /sbin/dump $file_list


    echo "-------------------------------------------------------------------------"


    # Что произойдет, если экранировать пробелы в списке?

    ls -l /usr/X11R6/bin/xsetroot\ /sbin/dump\ $file_list

    # Ошибка: первые три файла будут "слиты" воедино

    # и переданы команде 'ls -l' как один аргумент

    # потому что два пробела, разделяющие аргументы (слова) -- экранированы.


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

    (cd /source/directory && tar cf - . ) | \

    (cd /dest/directory && tar xpvf -)

    # Команда копирования дерева каталогов.

    # Разбита на две строки для большей удобочитаемости.


    # Альтернативный вариант:

    tar cf - -C /source/directory . |

    tar xpvf - -C /dest/directory

    # См. примечание ниже.

    # (Спасибо Stephane Chazelas.)

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


    echo "foo

    bar"

    #foo

    #bar


    echo


    echo 'foo

    bar' # Никаких различий.

    #foo

    #bar


    echo


    echo foo\

    bar # Перевод строки экранирован.

    #foobar


    echo


    echo "foo\

    bar" # Внутри "нестрогих" кавычек символ "\" интерпретируется как экранирующий.

    #foobar


    echo


    echo 'foo\

    bar' # В "строгих" кавычках обратный слэш воспринимается как обычный символ.

    #foo\

    #bar


    # Примеры предложены Stephane Chazelas.


    Глава 6. Завершение и код завершения

    ...эта часть Bourne shell покрыта мраком, тем не менее все пользуются ею.

    Chet Ramey

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

    Каждая команда возвращает код завершения (иногда код завершения называют возвращаемым значением ). В случае успеха команда должна возвращать 0, а в случае ошибки -- ненулевое значение, которое, как правило, интерпретируется как код ошибки. Практически все команды и утилиты UNIX возвращают 0 в случае успешного завершения, но имеются и исключения из правил.

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

    Когда работа сценария завершается командой exit без параметров, то код возврата сценария определяется кодом возврата последней исполненной командой.

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

    Пример 6-1. завершение / код завершения

    #!/bin/bash


    echo hello

    echo $? # код возврата = 0, поскольку команда выполнилась успешно.


    lskdf # Несуществующая команда.

    echo $? # Ненулевой код возврата, поскольку команду выполнить не удалось.


    echo


    exit 113 # Явное указание кода возврата 113.

    # Проверить можно, если набрать в командной строке "echo $?"

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


    # В соответствии с соглашениями, 'exit 0' указывает на успешное завершение,

    #+ в то время как ненулевое значение означает ошибку.

    Переменная $? особенно полезна, когда необходимо проверить результат исполнения команды (см. Пример 12-27 и Пример 12-13).

    Символ !, может выступать как логическое "НЕ" для инверсии кода возврата.

    Пример 6-2. Использование символа ! для логической инверсии кода возврата

    true # встроенная команда "true".

    echo "код возврата команды \"true\" = $?" # 0


    ! true

    echo "код возврата команды \"! true\" = $?" # 1

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

    # !true вызовет сообщение об ошибке "command not found"


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


    В отдельных случаях коды возврата должны иметь предопределенные значения и не должны задаваться пользователем.


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

    практически любой язык программирования включает в себя условные операторы, предназначенные для проверки условий, чтобы выбрать тот или иной путь развития событий в зависимости от этих условий. В Bash, для проверки условий, имеется команда test, различного вида скобочные операторы и условный оператор if/then.


    7.1. Конструкции проверки условий

    Оператор if/then проверяет -- является ли код завершения списка команд 0 (поскольку 0 означает "успех"), и если это так, то выполняет одну, или более, команд, следующие за словом then.

    Существует специальная команда -- [ (левая квадратная скобка). Она является синонимом команды test, и является встроенной командой (т.е. более эффективной, в смысле производительности). Эта команда воспринимает свои аргументы как выражение сравнения или как файловую проверку и возвращает код завершения в соответствии с результатами проверки (0 -- истина, 1 -- ложь).

    Начиная с версии 2.02, Bash предоставляет в распоряжение программиста конструкцию [[ ... ]] расширенный вариант команды test, которая выполняет сравнение способом более знакомым программистам, пишущим на других языках программирования. Обратите внимание: [[ -- это зарезервированное слово, а не команда.

    Bash исполняет [[ $a -lt $b ]] как один элемент, который имеет код возврата.

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

    Предложение let "1<2" возвращает 0 (так как результат сравнения "1<2" -- "1", или "истина")

    (( 0 && 1 )) возвращает 1 (так как результат операции "0 && 1" -- "0", или "ложь")


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

    if cmp a b &> /dev/null # Подавление вывода.

    then echo "Файлы a и b идентичны."

    else echo "Файлы a и b имеют различия."

    fi


    if grep -q Bash file

    then echo "Файл содержит, как минимум, одно слово Bash."

    fi


    if COMMAND_WHOSE_EXIT_STATUS_IS_0_UNLESS_ERROR_OCCURRED

    then echo "Команда выполнена успешно."

    else echo "Обнаружена ошибка при выполнении команды."

    fi


    Оператор if/then допускает наличие вложенных проверок.

    if echo "Следующий *if* находится внутри первого *if*."


    if [[ $comparison = "integer" ]]

    then (( a < b ))

    else

    [[ $a < $b ]]

    fi


    then

    echo '$a меньше $b'

    fi


    Это детальное описание конструкции "if-test" любезно предоставлено Stephane Chazelas.

    Пример 7-1. Что есть "истина"?

    #!/bin/bash


    echo


    echo "Проверяется \"0\""

    if [ 0 ] # ноль

    then

    echo "0 -- это истина."

    else

    echo "0 -- это ложь."

    fi # 0 -- это истина.


    echo


    echo "Проверяется \"1\""

    if [ 1 ] # единица

    then

    echo "1 -- это истина."

    else

    echo "1 -- это ложь."

    fi # 1 -- это ложь.


    echo


    echo "Testing \"-1\""

    if [ -1 ] # минус один

    then

    echo "-1 -- это истина."

    else

    echo "-1 -- это ложь."

    fi # -1 -- это истина.


    echo


    echo "Проверяется \"NULL\""

    if [ ] # NULL (пустое условие)

    then

    echo "NULL -- это истина."

    else

    echo "NULL -- это ложь."

    fi # NULL -- это ложь.


    echo


    echo "Проверяется \"xyz\""

    if [ xyz ] # строка

    then

    echo "Случайная строка -- это истина."

    else

    echo "Случайная строка -- это ложь."

    fi # Случайная строка -- это истина.


    echo


    echo "Проверяется \"\$xyz\""

    if [ $xyz ] # Проверка, если $xyz это null, но...

    # только для неинициализированных переменных.

    then

    echo "Неинициализированная переменная -- это истина."

    else

    echo "Неинициализированная переменная -- это ложь."

    fi # Неинициализированная переменная -- это ложь.


    echo


    echo "Проверяется \"-n \$xyz\""

    if [ -n "$xyz" ] # Более корректный вариант.

    then

    echo "Неинициализированная переменная -- это истина."

    else

    echo "Неинициализированная переменная -- это ложь."

    fi # Неинициализированная переменная -- это ложь.


    echo


    xyz= # Инициализирована пустым значением.


    echo "Проверяется \"-n \$xyz\""

    if [ -n "$xyz" ]

    then

    echo "Пустая переменная -- это истина."

    else

    echo "Пустая переменная -- это ложь."

    fi # Пустая переменная -- это ложь.


    echo


    # Кргда "ложь" истинна?


    echo "Проверяется \"false\""

    if [ "false" ] # это обычная строка "false".

    then

    echo "\"false\" -- это истина." #+ и она истинна.

    else

    echo "\"false\" -- это ложь."

    fi # "false" -- это истина.


    echo


    echo "Проверяется \"\$false\"" # Опять неинициализированная переменная.

    if [ "$false" ]

    then

    echo "\"\$false\" -- это истина."

    else

    echo "\"\$false\" -- это ложь."

    fi # "$false" -- это ложь.

    # Теперь мв получили ожидаемый результат.


    echo


    exit 0

    Упражнение. Объясните результаты, полученные в Пример 7-1.

    if [ condition-true ]

    then

    command 1

    command 2

    ...

    else

    # Необязательная ветка (можно опустить, если в ней нет необходимости).

    # Дополнительный блок кода,

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

    command 3

    command 4

    ...

    fi


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

    if [ -x "$filename" ]; then


    Else if и elif

    elif

    elif -- это краткая форма записи конструкции else if. Применяется для построения многоярусных инструкций if/then.

    if [ condition1 ]

    then

    command1

    command2

    command3

    elif [ condition2 ]

    # То же самое, что и else if

    then

    command4

    command5

    else

    default-command

    fi


    Конструкция if test condition-true является точным эквивалентом конструкции if [ condition-true ], где левая квадратная скобка [ выполняет те же действия, что и команда test. Закрывающая правая квадратная скобка ] не является абсолютно необходимой, однако, более новые версии Bash требуют ее наличие.

    Команда test -- это встроенная команда Bash, которая выполняет проверки файлов и производит сравнение строк. Таким образом, в Bash-скриптах, команда test не вызывает внешнюю (/usr/bin/test) утилиту, которая является частью пакета sh-utils. Аналогично, [ не производит вызов утилиты /usr/bin/[, которая является символической ссылкой на /usr/bin/test.

    bash$ type test

    test is a shell builtin

    bash$ type '['

    [ is a shell builtin

    bash$ type '[['

    [[ is a shell keyword

    bash$ type ']]'

    ]] is a shell keyword

    bash$ type ']'

    bash: type: ]: not found


    Пример 7-2. Эквиваленты команды test -- /usr/bin/test, [ ], и /usr/bin/[

    #!/bin/bash


    echo


    if test -z "$1"

    then

    echo "Аргументы командной строки отсутствуют."

    else

    echo "Первый аргумент командной строки: $1."

    fi


    echo


    if /usr/bin/test -z "$1" # Дает тот же рузультат, что и встроенная команда "test".

    then

    echo "Аргументы командной строки отсутствуют."

    else

    echo "Первый аргумент командной строки: $1."

    fi


    echo


    if [ -z "$1" ] # Функционально идентично вышеприведенному блоку кода.

    # if [ -z "$1" эта конструкция должна работать, но...

    #+ Bash выдает сообщение об отсутствующей закрывающей скобке.

    then

    echo "Аргументы командной строки отсутствуют."

    else

    echo "Первый аргумент командной строки: $1."

    fi


    echo


    if /usr/bin/[ -z "$1" # Функционально идентично вышеприведенному блоку кода.

    # if /usr/bin/[ -z "$1" ] # Работает, но выдает сообщение об ошибке.

    then

    echo "Аргументы командной строки отсутствуют."

    else

    echo "Первый аргумент командной строки: $1."

    fi


    echo


    exit 0

    Конструкция [[ ]] более универсальна, по сравнению с [ ]. Этот расширенный вариант команды test перекочевал в Bash из ksh88.

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

    file=/etc/passwd


    if [[ -e $file ]]

    then

    echo "Файл паролей найден."

    fi


    Конструкция [[ ... ]] более предпочтительна, нежели [ ... ], поскольку поможет избежать некоторых логических ошибок. Например, операторы &&, ||, < и > внутри [[ ]] вполне допустимы, в то время как внутри [ ] порождают сообщения об ошибках.

    Строго говоря, после оператора if, ни команда test, ни квадратные скобки ( [ ] или [[ ]] ) не являются обязательными.

    dir=/home/bozo


    if cd "$dir" 2>/dev/null; then # "2>/dev/null" подавление вывода сообщений об ошибках.

    echo "Переход в каталог $dir выполнен."

    else

    echo "Невозможно перейти в каталог $dir."

    fi

    Инструкция "if COMMAND" возвращает код возврата команды COMMAND.

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

    var1=20

    var2=22

    [ "$var1" -ne "$var2" ] && echo "$var1 не равно $var2"


    home=/home/bozo

    [ -d "$home" ] || echo "каталог $home не найден."


    Внутри (( )) производится вычисление арифметического выражения. Если результатом вычислений является ноль, то возвращается 1, или "ложь". Ненулевой результат дает код возврата 0, или "истина". То есть полная противоположность инструкциям test и [ ], обсуждавшимся выше.

    Пример 7-3. Арифметические выражения внутри (( ))

    #!/bin/bash

    # Проверка арифметических выражений.


    # Инструкция (( ... )) вычисляет арифметические выражения.

    # Код возврата противоположен коду возврата инструкции [ ... ] !


    (( 0 ))

    echo "Код возврата \"(( 0 ))\": $?." # 1


    (( 1 ))

    echo "Код возврата \"(( 1 ))\": $?." # 0


    (( 5 > 4 )) # true

    echo "Код возврата \"(( 5 > 4 ))\": $?." # 0


    (( 5 > 9 )) # false

    echo "Код возврата \"(( 5 > 9 ))\": $?." # 1


    (( 5 - 5 )) # 0

    echo "Код возврата \"(( 5 - 5 ))\": $?." # 1


    (( 5 / 4 )) # Деление, все в порядке

    echo "Код возврата \"(( 5 / 4 ))\": $?." # 0


    (( 1 / 2 )) # Результат деления < 1.

    echo "Код возврата \"(( 1 / 2 ))\": $?." # Округляется до 0.

    # 1


    (( 1 / 0 )) 2>/dev/null # Деление на 0.

    echo "Код возврата \"(( 1 / 0 ))\": $?." # 1


    # Для чего нужна инструкция "2>/dev/null" ?

    # Что произойдет, если ее убрать?

    # Попробуйте убрать ее и выполнить сценарий.


    exit 0

    7.2. Операции проверки файлов

    Возвращает true если...

    -e

    файл существует

    -f

    обычный файл (не каталог и не файл устройства)

    -s

    ненулевой размер файла

    -d

    файл является каталогом

    -b

    файл является блочным устройством (floppy, cdrom и т.п.)

    -c

    файл является символьным устройством (клавиатура, модем, звуковая карта и т.п.)

    -p

    файл является каналом

    -h

    файл является символической ссылкой

    -L

    файл является символической ссылкой

    -S

    файл является сокетом

    -t

    файл (дескриптор) связан с терминальным устройством

    Этот ключ может использоваться для проверки -- является ли файл стандартным устройством ввода stdin ([ -t 0 ]) или стандартным устройством вывода stdout ([ -t 1 ]).

    -r

    файл доступен для чтения (пользователю, запустившему сценарий)

    -w

    файл доступен для записи (пользователю, запустившему сценарий)

    -x

    файл доступен для исполнения (пользователю, запустившему сценарий)

    -g

    set-group-id (sgid) флаг для файла или каталога установлен

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

    -u

    set-user-id (suid) флаг для файла установлен

    Установленный флаг suid приводит к изменению привилегий запущенного процесса на привилегии владельца исполняемого файла. Исполняемые файлы, владельцем которых является root, с установленным флагом set-user-id запускаются с привилегиями root, даже если их запускает обычный пользователь[ 16 ]. Это может оказаться полезным для некоторых программ (таких как pppd и cdrecord), которые осуществляют доступ к аппаратной части компьютера. В случае отсутствия флага suid, программы не смогут быть запущены рядовым пользователем, не обладающим привилегиями root.

    -rwsr-xr-t 1 root 178236 Oct 2 2000 /usr/sbin/pppd

    Файл с установленным флагом suid отображается с включенным флагом s в поле прав доступа.

    -k

    флаг sticky bit (бит фиксации) установлен

    Общеизвестно, что флаг "sticky bit" -- это специальный тип прав доступа к файлам. Программы с установленным флагом "sticky bit" остаются в системном кэше после своего завершения, обеспечивая тем самым более быстрый запуск программы[ 17 ]. Если флаг установлен для каталога, то это приводит к ограничению прав на запись. Установленный флаг "sticky bit" отображается в виде символа t в поле прав доступа.

    drwxrwxrwt 7 root 1024 May 19 21:26 tmp/

    Если пользователь не является владельцем каталога, с установленным "sticky bit", но имеет право на запись в каталог, то он может удалять только те файлы в каталоге, владельцем которых он является. Это предотвращает удаление и перезапись "чужих" файлов в общедоступных каталогах, таких как /tmp.

    -O

    вы являетесь владельцем файла

    -G

    вы принадлежите к той же группе, что и файл

    -N

    файл был модифицирован с момента последнего чтения

    f1 -nt f2

    файл f1 более новый, чем f2

    f1 -ot f2

    файл f1 более старый, чем f2

    f1 -ef f2

    файлы f1 и f2 являются "жесткими" ссылками на один и тот же файл

    !

    "НЕ" -- логическое отрицание (инверсия) результатов всех вышеприведенных проверок (возвращается true если условие отсутствует).

    Пример 7-4. Проверка "битых" ссылок

    #!/bin/bash

    # broken-link.sh

    # Автор Lee Bigelow <ligelowbee@yahoo.com>

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


    #Сценарий поиска "битых" ссылок и их вывод в "окавыченном" виде

    #таким образом они могут передаваться утилите xargs для дальнейшей обработки :)

    #например. broken-link.sh /somedir /someotherdir|xargs rm

    #

    #На всякий случай приведу лучший метод:

    #

    #find "somedir" -type l -print0|\

    #xargs -r0 file|\

    #grep "broken symbolic"|

    #sed -e 's/^\|: *broken symbolic.*$/"/g'

    #

    #но это не чисто BASH-евский метод, а теперь сам сценарий.

    #Внимание! будьте осторожны с файловой системой /proc и циклическими ссылками!

    ##############################################################


    #Если скрипт не получает входных аргументов,

    #то каталогом поиска является текущая директория

    #В противном случае, каталог поиска задается из командной строки

    ####################

    [ $# -eq 0 ] && directorys=`pwd` || directorys=$@


    #Функция linkchk проверяет каталог поиска

    #на наличие в нем ссылок на несуществующие файлы, и выводит их имена.

    #Если анализируемый файл является каталогом,

    #то он передается функции linkcheck рекурсивно.

    ##########

    linkchk () {

    for element in $1/*; do

    [ -h "$element" -a ! -e "$element" ] && echo \"$element\"

    [ -d "$element" ] && linkchk $element

    # Само собой, '-h' проверяет символические ссылки, '-d' -- каталоги.

    done

    }


    #Вызов функции linkchk для каждого аргумента командной строки,

    #если он является каталогом. Иначе выводится сообщение об ошибке

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

    ################

    for directory in $directorys; do

    if [ -d $directory ]

    then linkchk $directory

    else

    echo "$directory не является каталогом"

    echo "Порядок использования: $0 dir1 dir2 ..."

    fi

    done


    exit 0

    Пример 28-1, Пример 10-7, Пример 10-3, Пример 28-3 и Пример A-2 так же иллюстрируют операции проверки файлов.

    7.3. Операции сравнения

    сравнение целых чисел

    -eq

    равно

    if [ "$a" -eq "$b" ]

    -ne

    не равно

    if [ "$a" -ne "$b" ]

    -gt

    больше

    if [ "$a" -gt "$b" ]

    -ge

    больше или равно

    if [ "$a" -ge "$b" ]

    -lt

    меньше

    if [ "$a" -lt "$b" ]

    -le

    меньше или равно

    if [ "$a" -le "$b" ]

    <

    меньше (внутри двойных круглых скобок )

    (("$a" < "$b"))

    <=

    меньше или равно (внутри двойных круглых скобок)

    (("$a" <= "$b"))

    >

    больше (внутри двойных круглых скобок)

    (("$a" > "$b"))

    >=

    больше или равно (внутри двойных круглых скобок)

    (("$a" >= "$b"))

    сравнение строк

    =

    равно

    if [ "$a" = "$b" ]

    ==

    равно

    if [ "$a" == "$b" ]

    Синоним оператора =.

    [[ $a == z* ]] # истина, если $a начинается с символа "z" (сравнение по шаблону)

    [[ $a == "z*" ]] # истина, если $a равна z*


    [ $a == z* ] # имеют место подстановка имен файлов и разбиение на слова

    [ "$a" == "z*" ] # истина, если $a равна z*


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


    !=

    не равно

    if [ "$a" != "$b" ]

    Этот оператор используется при поиске по шаблону внутри [[ ... ]].

    <

    меньше, в смысле величины ASCII-кодов

    if [[ "$a" < "$b" ]]

    if [ "$a" \< "$b" ]

    Обратите внимание! Символ "<" необходимо экранировать внутри [ ].

    >

    больше, в смысле величины ASCII-кодов

    if [[ "$a" > "$b" ]]

    if [ "$a" \> "$b" ]

    Обратите внимание! Символ ">" необходимо экранировать внутри [ ].

    См. Пример 25-6 относительно применения этого оператора сравнения.

    -z

    строка "пустая", т.е. имеет нулевую длину

    -n

    строка не "пустая".

    Оператор -n требует, чтобы строка была заключена в кавычки внутри квадратных скобок. Как правило, проверка строк, не заключенных в кавычки, оператором ! -z, или просто указание строки без кавычек внутри квадратных скобок (см. Пример 7-6), проходит нормально, однако это небезопасная, с точки зрения отказоустойчивости, практика. Всегда заключайте проверяемую строку в кавычки[ 18 ].

    Пример 7-5. Операции сравнения

    #!/bin/bash


    a=4

    b=5


    # Здесь переменные "a" и "b" могут быть как целыми числами, так и строками.

    # Здесь наблюдается некоторое размывание границ

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

    #+ поскольку переменные в Bash не имеют типов.


    # Bash выполняет целочисленные операции над теми переменными,

    #+ которые содержат только цифры

    # Будьте внимательны!


    echo


    if [ "$a" -ne "$b" ]

    then

    echo "$a не равно $b"

    echo "(целочисленное сравнение)"

    fi


    echo


    if [ "$a" != "$b" ]

    then

    echo "$a не равно $b."

    echo "(сравнение строк)"

    # "4" != "5"

    # ASCII 52 != ASCII 53

    fi


    # Оба варианта, "-ne" и "!=", работают правильно.


    echo


    exit 0

    Пример 7-6. Проверка -- является ли строка пустой

    #!/bin/bash

    # str-test.sh: Проверка пустых строк и строк, не заключенных в кавычки,


    # Используется конструкция if [ ... ]


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

    # Такое состояние называется "null" (пустая) (это не то же самое, что ноль).


    if [ -n $string1 ] # $string1 не была объявлена или инициализирована.

    then

    echo "Строка \"string1\" не пустая."

    else

    echo "Строка \"string1\" пустая."

    fi

    # Неверный результат.

    # Выводится сообщение о том, что $string1 не пустая,

    #+не смотря на то, что она не была инициализирована.


    echo


    # Попробуем еще раз.


    if [ -n "$string1" ] # На этот раз, переменная $string1 заключена в кавычки.

    then

    echo "Строка \"string1\" не пустая."

    else

    echo "Строка \"string1\" пустая."

    fi # Внутри квадратных скобок заключайте строки в кавычки!


    echo


    if [ $string1 ] # Опустим оператор -n.

    then

    echo "Строка \"string1\" не пустая."

    else

    echo "Строка \"string1\" пустая."

    fi

    # Все работает прекрасно.

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

    # Тем не менее, хорошим тоном считается заключать строки в кавычки ("$string1").

    #

    # Как указывает Stephane Chazelas,

    # if [ $string 1 ] один аргумент "]"

    # if [ "$string 1" ] два аргумента, пустая "$string1" и "]"


    echo


    string1=initialized


    if [ $string1 ] # Опять, попробуем строку без ничего.

    then

    echo "Строка \"string1\" не пустая."

    else

    echo "Строка \"string1\" пустая."

    fi

    # И снова получим верный результат.

    # И опять-таки, лучше поместить строку в кавычки ("$string1"), поскольку...


    string1="a = b"


    if [ $string1 ] # И снова, попробуем строку без ничего..

    then

    echo "Строка \"string1\" не пустая."

    else

    echo "Строка \"string1\" пустая."

    fi

    # Строка без кавычек дает неверный результат!


    exit 0

    # Спвсибо Florian Wisser, за предупреждение.

    Пример 7-7. zmost

    #!/bin/bash


    #Просмотр gz-файлов с помощью утилиты 'most'


    NOARGS=65

    NOTFOUND=66

    NOTGZIP=67


    if [ $# -eq 0 ] # то же, что и: if [ -z "$1" ]

    # $1 должен существовать, но может быть пустым: zmost "" arg2 arg3

    then

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

    # Сообщение об ошибке на stderr.

    exit $NOARGS

    # Код возврата 65 (код ошибки).

    fi


    filename=$1


    if [ ! -f "$filename" ] # Кавычки необходимы на тот случай, если имя файла содержит пробелы.

    then

    echo "Файл $filename не найден!" >&2

    # Сообщение об ошибке на stderr.

    exit $NOTFOUND

    fi


    if [ ${filename##*.} != "gz" ]

    # Квадратные скобки нужны для выполнения подстановки значения переменной

    then

    echo "Файл $1 не является gz-файлом!"

    exit $NOTGZIP

    fi


    zcat $1 | most


    # Используется утилита 'most' (очень похожа на 'less').

    # Последние версии 'most' могут просматривать сжатые файлы.

    # Можно вставить 'more' или 'less', если пожелаете.


    exit $? # Сценарий возвращает код возврата, полученный по конвейеру.

    # На самом деле команда "exit $?" не является обязательной,

    # так как работа скрипта завершится здесь в любом случае,

    построение сложных условий проверки

    -a

    логическое И (and)

    exp1 -a exp2 возвращает true, если оба выражения, и exp1, и exp2 истинны.

    -o

    логическое ИЛИ (or)

    exp1 -o exp2 возвращает true, если хотябы одно из выражений, exp1 или exp2 истинно.

    Они похожи на операторы Bash && и ||, употребляемые в двойных квадратных скобках.

    [[ condition1 && condition2 ]]

    Операторы -o и -a употребляются совместно с командой test или внутри одинарных квадратных скобок.

    if [ "$exp1" -a "$exp2" ]


    Чтобы увидеть эти операторы в действии, смотрите Пример 8-3 и Пример 25-11.


    7.4. Вложенные условные операторы if/then

    Операторы проверки условий if/then могут быть вложенными друг в друга. Конечный результат будет таким же как если бы результаты всех проверок были объединены оператором &&.

    if [ condition1 ]

    then

    if [ condition2 ]

    then

    do-something # Только если оба условия "condition1" и "condition2" истинны.

    fi

    fi


    См. Пример 34-4 -- пример использования вложенных операторов if/then.


    7.5. Проверка степени усвоения материала

    Для запуска X-сервера может быть использован файл xinitrc. Этот файл содержит некоторое число операторов if/then. Ниже приводится отрывок из этого файла.

    if [ -f $HOME/.Xclients ]; then

    exec $HOME/.Xclients

    elif [ -f /etc/X11/xinit/Xclients ]; then

    exec /etc/X11/xinit/Xclients

    else

    # failsafe settings. Although we should never get here

    # (we provide fallbacks in Xclients as well) it can't hurt.

    xclock -geometry 100x100-5+5 &

    xterm -geometry 80x50-50+150 &

    if [ -f /usr/bin/netscape -a -f /usr/share/doc/HTML/index.html ]; then

    netscape /usr/share/doc/HTML/index.html &

    fi

    fi


    Объясните действия условных операторов в вышеприведенном отрывке, затем просмотрите файл /etc/X11/xinit/xinitrc и проанализируйте его. Возможно вам придется обратиться к разделам, посвященным grep, sed и регулярным выражениям.


    Глава 8. Операции и смежные темы

    8.1. Операторы

    присваивание

    variable assignment

    Инициализация переменной или изменение ее значения

    =

    Универсальный оператор присваивания, пригоден как для сравнения целых чисел, так и для сравнения строк.

    var=27

    category=minerals # Пробелы до и после оператора "=" -- недопустимы.


    Пусть вас не смущает, что оператор присваивания ("="), по своему внешнему виду, совпадает с оператором сравнения (=).

    # Здесь знак "=" выступает в качестве оператора сравнения


    if [ "$string1" = "$string2" ]

    # if [ "X$string1" = "X$string2" ] более отказоустойчивый вариант,

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

    # (добавленные символы "X" компенсируют друг друга.)

    then

    command

    fi


    арифметические операторы

    +

    сложение

    -

    вычитание

    *

    умножение

    /

    деление

    **

    возведение в степень

    # В Bash, начиная с версии 2.02, был введен оператор возведения в степень -- "**".


    let "z=5**3"

    echo "z = $z" # z = 125


    %

    модуль (деление по модулю), возвращает остаток от деления

    bash$ echo `expr 5 % 3`

    2


    Этот оператор может применяться в алгоритмах генерации псевдослучайных чисел в заданном диапазоне (см. Пример 9-23 и Пример 9-25), для форматирования вывода на экран (см. Пример 25-10 и Пример A-7), и даже для генерации простых чисел (см. Пример A-18). На удивление часто операцию деления по модулю можно встретить в различных численных алгоритмах.

    Пример 8-1. Наибольший общий делитель

    #!/bin/bash

    # gcd.sh: поиск наибольшего общего делителя

    # по алгоритму Эвклида


    # Под "наибольшим общим делителем" (нод) двух целых чисел

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


    # Алгоритм Эвклида выполняет последовательное деление.

    # В каждом цикле,

    #+ делимое <--- делитель

    #+ делитель <--- остаток

    #+ до тех пор, пока остаток не станет равным нулю (остаток = 0).

    #+ The gcd = dividend, on the final pass.

    #

    # Замечательное описание алгоритма Эвклида можно найти

    # на сайте Jim Loy, http://www.jimloy.com/number/euclids.htm.


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

    # Проверка входных параметров

    ARGS=2

    E_BADARGS=65


    if [ $# -ne "$ARGS" ]

    then

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

    exit $E_BADARGS

    fi

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


    gcd ()

    {


    # Начальное присваивание.

    dividend=$1 # В сущности, не имеет значения

    divisor=$2 #+ какой из них больше.

    # Почему?


    remainder=1 # Если переменные неинициализировать,

    #+ то работа сценария будет прервана по ошибке

    #+ в первом же цикле.


    until [ "$remainder" -eq 0 ]

    do

    let "remainder = $dividend % $divisor"

    dividend=$divisor # Повторить цикл с новыми исходными данными

    divisor=$remainder

    done # алгоритм Эвклида


    } # последнее $dividend и есть нод.


    gcd $1 $2


    echo; echo "НОД чисел $1 и $2 = $dividend"; echo


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

    # --------

    # Вставьте дополнительную проверку входных аргументов,

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

    #+ входные аргументы не являются целыми числами.


    exit 0

    +=

    "плюс-равно" (увеличивает значение переменной на заданное число)

    let "var += 5" значение переменной var будет увеличено на 5.

    -=

    "минус-равно" (уменьшение значения переменной на заданное число)

    *=

    "умножить-равно" (умножить значение переменной на заданное число, результат записать в переменную)

    let "var *= 4" значение переменной var будет увеличено в 4 раза.

    /=

    "слэш-равно" (уменьшение значения переменной в заданное число раз)

    %=

    "процент-равно" (найти остаток от деления значения переменной на заданное число, результат записать в переменную)

    Арифметические операторы очень часто используются совместно с командами expr и let.

    Пример 8-2. Арифметические операции

    #!/bin/bash

    # От 1 до 6 пятью различными способами.


    n=1; echo -n "$n "


    let "n = $n + 1" # let "n = n + 1" тоже допустимо

    echo -n "$n "


    : $((n = $n + 1))

    # оператор ":" обязателен, поскольку в противном случае, Bash будет

    #+ интерпретировать выражение "$((n = $n + 1))" как команду.

    echo -n "$n "


    n=$(($n + 1))

    echo -n "$n "


    : $[ n = $n + 1 ]

    # оператор ":" обязателен, поскольку в противном случае, Bash будет

    #+ интерпретировать выражение "$[ n = $n + 1 ]" как команду.

    # Не вызывает ошибки даже если "n" содержит строку.

    echo -n "$n "


    n=$[ $n + 1 ]

    # Не вызывает ошибки даже если "n" содержит строку.

    #* Старайтесь избегать употребления такой конструкции,

    #+ поскольку она уже давно устарела и не переносима.

    echo -n "$n "; echo


    # Спасибо Stephane Chazelas.


    exit 0

    Целые числа в Bash фактически являются знаковыми длинными целыми (32-бит), с диапазоном изменений от -2147483648 до 2147483647. Если в результате какой либо операции эти пределы будут превышены, то результат получится ошибочным.

    a=2147483646

    echo "a = $a" # a = 2147483646

    let "a+=1" # Увеличить "a" на 1.

    echo "a = $a" # a = 2147483647

    let "a+=1" # увеличить "a" еще раз, с выходом за границы диапазона.

    echo "a = $a" # a = -2147483648

    # ОШИБКА! (выход за границы диапазона)


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

    a=1.5


    let "b = $a + 1.3" # Ошибка.

    # t2.sh: let: b = 1.5 + 1.3: syntax error in expression (error token is ".5 + 1.3")


    echo "b = $b" # b=1

    Для работы с числами с плавающей запятой в сценариях можно использовать утилиту-калькулятор bc.

    битовые операции. Битовые операции очень редко используются в сценариях командного интерпретатора. Их главное назначение, на мой взгляд, установка и проверка некоторых значений, читаемых из портов ввода-вывода и сокетов. "Битовые операции" гораздо более уместны в компилирующих языках программирования, таких как C и C++.

    битовые операции

    <<

    сдвигает на 1 бит влево (умножение на 2)

    <<=

    "сдвиг-влево-равно"

    let "var <<= 2" значение переменной var сдвигается влево на 2 бита (умножается на 4)

    >>

    сдвиг вправо на 1 бит (деление на 2)

    >>=

    "сдвиг-вправо-равно" (имеет смысл обратный <<=)

    &

    по-битовое И (AND)

    &=

    "по-битовое И-равно"

    |

    по-битовое ИЛИ (OR)

    |=

    "по-битовое ИЛИ-равно"

    ~

    по-битовая инверсия

    !

    По-битовое отрицание

    ^

    по-битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)

    ^=

    "по-битовое ИСКЛЮЧАЮЩЕЕ-ИЛИ-равно"

    логические операции

    &&

    логическое И (and)

    if [ $condition1 ] && [ $condition2 ]

    # То же самое, что: if [ $condition1 -a $condition2 ]

    # Возвращает true если оба операнда condition1 и condition2 истинны...


    if [[ $condition1 && $condition2 ]] # То же верно

    # Обратите внимание: оператор && не должен использоваться внутри [ ... ].


    оператор &&, в зависимости от контекста, может так же использоваться в И-списках для построения составных команд.

    ||

    логическое ИЛИ (or)

    if [ $condition1 ] || [ $condition2 ]

    # То же самое, что: if [ $condition1 -o $condition2 ]

    # Возвращает true если хотя бы один из операндов истинен...


    if [[ $condition1 || $condition2 ]] # Also works.

    # Обратите внимание: оператор || не должен использоваться внутри [ ... ].


    Bash производит проверку кода возврата КАЖДОГО из операндов в логических выражениях.

    Пример 8-3. Построение сложных условий, использующих && и ||

    #!/bin/bash


    a=24

    b=47


    if [ "$a" -eq 24 ] && [ "$b" -eq 47 ]

    then

    echo "Первая проверка прошла успешно."

    else

    echo "Первая проверка не прошла."

    fi


    # ОКА: if [ "$a" -eq 24 && "$b" -eq 47 ]

    # пытается выполнить ' [ "$a" -eq 24 '

    # и терпит неудачу наткнувшись на ']'.

    #

    # if [[ $a -eq 24 && $b -eq 24 ]] это правильный вариант

    # (в строке 17 оператор "&&" имеет иной смысл, нежели в строке 6.)

    # Спасибо Stephane Chazelas.


    if [ "$a" -eq 98 ] || [ "$b" -eq 47 ]

    then

    echo "Вторая проверка прошла успешно."

    else

    echo "Вторая проверка не прошла."

    fi


    # Опции -a и -o предоставляют

    #+ альтернативный механизм проверки условий.

    # Спасибо Patrick Callahan.


    if [ "$a" -eq 24 -a "$b" -eq 47 ]

    then

    echo "Третья проверка прошла успешно."

    else

    echo "Третья проверка не прошла."

    fi


    if [ "$a" -eq 98 -o "$b" -eq 47 ]

    then

    echo "Четвертая проверка прошла успешно."

    else

    echo "Четвертая проверка не прошла."

    fi


    a=rhino

    b=crocodile

    if [ "$a" = rhino ] && [ "$b" = crocodile ]

    then

    echo "Пятая проверка прошла успешно."

    else

    echo "Пятая проверка не прошла."

    fi


    exit 0

    Операторы && и || могут использоваться и в арифметических вычислениях.

    bash$ echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0))

    1 0 1 0


    прочие операции

    ,

    запятая

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

    let "t1 = ((5 + 3, 7 - 1, 15 - 4))"

    echo "t1 = $t1" # t1 = 11


    let "t2 = ((a = 9, 15 / 3))" # Выполняется присваивание "a" = 9,

    #+ а затем вычисляется "t2".

    echo "t2 = $t2 a = $a" # t2 = 5 a = 9


    Оператор запятая чаще всего находит применение в циклах for. См. Пример 10-12.


    8.2. Числовые константы

    Интерпретатор командной оболочки воспринимает числа как десятичные, в противном случае числу должен предшествовать специальный префикс, либо число должно быть записано в особой нотации. Числа, начинающиеся с символа 0, считаются восьмеричными. если числу предшествует префикс 0x, то число считается шестнадцатиричным. Число, в записи которого присутствует символ #, расценивается как запись числа с указанием основы счисления в виде ОСНОВА#ЧИСЛО.

    Пример 8-4. Различные представления числовых констант

    #!/bin/bash

    # numbers.sh: Различные представления числовых констант.


    # Десятичное: по-умолчанию

    let "dec = 32"

    echo "десятичное число = $dec" # 32

    # Вобщем-то ничего необычного.


    # Восьмеричное: числа начинаются с '0' (нуля)

    let "oct = 032"

    echo "восьмеричное число = $oct" # 26

    # Результат печатается в десятичном виде.

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


    # Шестнадцатиричное: числа начинаются с '0x' или '0X'

    let "hex = 0x32"

    echo "шестнадцатиричное число = $hex" # 50

    # Результат печатается в десятичном виде.


    # Другие основы счисления: ОСНОВА#ЧИСЛО

    # ОСНОВА должна быть между 2 и 64.

    # для записи ЧИСЛА должен использоваться соответствующий ОСНОВЕ диапазон символов,

    # см. ниже.


    let "bin = 2#111100111001101"

    echo "двоичное число = $bin" # 31181


    let "b32 = 32#77"

    echo "32-ричное число = $b32" # 231


    let "b64 = 64#@_"

    echo "64-ричное число = $b64" # 4094

    #

    # Нотация ОСНОВА#ЧИСЛО может использоваться на ограниченном

    #+ диапазоне основ счисления (от 2 до 64)

    # 10 цифр + 26 символов в нижнем регистре + 26 символов в верхнем регистре + @ + _


    echo


    echo $((36#zz)) $((2#10101010)) $((16#AF16)) $((53#1aA))

    # 1295 170 44822 3375


    # Важное замечание:

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

    # Использование символов, для записи числа, выходящих за диапазо,

    #+ соответствующий ОСНОВЕ счисления

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


    let "bad_oct = 081"

    # numbers.sh: let: oct = 081: value too great for base (error token is "081")

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

    #+ только цифры в диапазоне 0 - 7.


    exit 0 # Спасибо Rich Bartell и Stephane Chazelas, за разъяснения.


    Примечания:



    1

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



    11

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



    12

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

    ls | { read firstline; read secondline; }

    # Ошибка! Вложенный блок будет запущен в дочернем процессе,

    # таким образом, вывод команды "ls" не может быть записан в переменные

    # находящиеся внутри блока.

    echo "Первая строка: $firstline; вторая строка: $secondline" # Не работает!


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



    13

    Аргумент $0 устанавливается вызывающим процессом. В соответствии с соглашениями, этот параметр содержит имя файла скрипта. См. страницы руководства для execv (man execv).



    14

    Символ "!", помещенный в двойные кавычки, порождает сообщение об ошибке, если команда вводится с командной строки. Вероятно это связано с тем, что этот символ интерпретируется как попытка обращения к истории команд. Однако внутри сценариев такой прием проблем не вызывает.

    Не менее любопытно поведение символа "\", употребляемого внутри двойных кавычек.

    bash$ echo hello\!

    hello!


    bash$ echo "hello\!"

    hello\!


    bash$ echo -e x\ty

    xty


    bash$ echo -e "x\ty"

    x y

    (Спасибо Wayne Pollock за пояснения.)



    15

    "Разбиение на слова", в данном случае это означает разделение строки символов на некоторое число аргументов.



    16

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



    17

    В современных UNIX-системах, "sticky bit" больше не используется для файлов, только для каталогов.



    18

    Как указывает S.C., даже заключение строки в кавычки, при построении сложных условий проверки, может оказаться недостаточным. [ -n "$string" -o "$a" = "$b" ] в некоторых версиях Bash такая проверка может вызвать сообщение об ошибке, если строка $string пустая. Безопаснее, в смысле отказоустойчивости, было бы добавить какой-либо символ к, возможно пустой, строке: [ "x$string" != x -o "x$a" = "x$b" ] (символ "x" не учитывается).







     


    Главная | В избранное | Наш E-MAIL | Добавить материал | Нашёл ошибку | Другие сайты | Наверх