Пример 7-2. Эквиваленты команды test -- /usr/bin/test, [ ], и /usr/bin/[
#!/bin/bashecho
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.
|
Внутри этой конструкции не производится никакой дополнительной интерпретации имен файлов и не производится разбиение аргументов на отдельные слова, но допускается подстановка параметров и команд. |
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] |
#!/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. |
битовые операции
<<
сдвигает на 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 производит проверку кода возврата КАЖДОГО из операндов в логических выражениях. |
#!/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, за разъяснения.
Часть 3. Углубленный материал
Содержание
9. К вопросу о переменных
9.1. Внутренние переменные
9.2. Работа со строками
9.2.1. Использование awk при работе со строками
9.2.2. Дальнейшее обсуждение
9.3. Подстановка параметров
9.4. Объявление переменных: declare и typeset
9.5. Косвенные ссылки на переменные
9.6. $RANDOM: генерация псевдослучайных целых чисел
9.7. Двойные круглые скобки
10. Циклы и ветвления
10.1. Циклы
10.2. Вложенные циклы
10.3. Управление ходом выполнения цикла
10.4. Операторы выбора
11. Внутренние команды
11.1. Команды управления заданиями
12. Внешние команды, программы и утилиты
12.1. Базовые команды
12.2. Более сложные команды
12.3. Команды для работы с датой и временем
12.4. Команды обработки текста
12.5. Команды для работы с файлами и архивами
12.6. Команды для работы с сетью
12.7. Команды управления терминалом
12.8. Команды выполнения математических операций
12.9. Прочие команды
13. Команды системного администрирования
14. Подстановка команд
15. Арифметические подстановки
16. Перенаправление ввода/вывода
16.1. С помощью команды exec
16.2. Перенаправление для блоков кода
16.3. Область применения
17. Встроенные документы
Глава 9. К вопросу о переменных
Правильное использование переменных может придать сценариям дополнительную мощь и гибкость, а для этого необходимо изучить все тонкости и нюансы.
9.1. Внутренние переменные
Встроенные
переменные
$BASH
путь к исполняемому файлу Bash
bash$ echo $BASH
/bin/bash
$BASH_VERSINFO[n]
это массив, состоящий из 6 элементов, и содержащий информацию о версии Bash. Очень похожа на переменную $BASH_VERSION, описываемую ниже.
# Информация о версии Bash:
for n in 0 1 2 3 4 5 do echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}" done
# BASH_VERSINFO[0] = 2 # Major version no. # BASH_VERSINFO[1] = 05 # Minor version no. # BASH_VERSINFO[2] = 8 # Patch level. # BASH_VERSINFO[3] = 1 # Build version. # BASH_VERSINFO[4] = release # Release status. # BASH_VERSINFO[5] = i386-redhat-linux-gnu # Architecture # (same as $MACHTYPE).
$BASH_VERSION
версия Bash, установленного в системе
bash$ echo $BASH_VERSION
2.04.12(1)-release
tcsh% echo $BASH_VERSION
BASH_VERSION: Undefined variable.
Проверка переменной $BASH_VERSION -- неплохой метод проверки типа командной оболочки, под которой исполняется скрипт. Переменная $SHELL не всегда дает правильный ответ.
$DIRSTACK
содержимое вершины стека каталогов (который управляется командами pushd и popd)
Эта переменная соответствует команде dirs, за исключением того, что dirs показывает полное содержимое всего стека каталогов.
$EDITOR
заданный по-умолчанию редактор, вызываемый скриптом, обычно vi или emacs.
$EUID
"эффективный" идентификационный номер пользователя (Effective User ID)
Идентификационный номер пользователя, права которого были получены, возможно с помощью команды su.
|
Значение переменной $EUID необязательно должно совпадать с содержимым переменной $UID. |
имя текущей функции
xyz23 () { echo "Исполняется функция $FUNCNAME." # Исполняется функция xyz23. }
xyz23
echo "FUNCNAME = $FUNCNAME" # FUNCNAME = # Пустое (Null) значение за пределеми функций.
$GLOBIGNORE
Перечень шаблонных символов, которые будут проигнорированы при выполнении подстановки имен файлов (globbing) .
$GROUPS
группы, к которым принадлежит текущий пользователь
Это список групп (массив) идентификационных номеров групп для текущего пользователя, как эо записано в /etc/passwd.
root# echo $GROUPS
0
root# echo ${GROUPS[1]}
1
root# echo ${GROUPS[5]}
6
$HOME
домашний каталог пользователя, как правило это /home/username (см. Пример 9-13)
$HOSTNAME
Сетевое имя хоста устанавливается командой hostname во время исполнения инициализирующих сценариев на загрузке системы. Внутренняя переменная $HOSTNAME Bash получает свое значение посредством вызова функции gethostname(). См. так же Пример 9-13.
$HOSTTYPE
тип машины
Подобно $MACHTYPE, идентифицирует аппаратную архитектуру.
bash$ echo $HOSTTYPE
i686
$IFS
разделитель полей во вводимой строке (IFS -- Input Field Separator)
По-умолчанию -- пробельный символ (пробел, табуляция и перевод строки), но может быть изменен, например, для разбора строк, в которых отдельные поля разделены запятыми. Обратите внимание: при составлении содержимого переменной $*, Bash использует первый символ из $IFS для разделения аргументов. См. Пример 5-1.
bash$ echo $IFS | cat -vte
$
bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"'
w:x:y:z
|
При всем при том следует помнить, что при использовании $IFS пробельные символы обрабатываются несколько иначе, чем все остальные. Пример 9-1. $IFS и пробельные символы #!/bin/bash # При использовании $IFS, пробельные символы обрабатываются иначе, чем все остальные. output_args_one_per_line() { for arg do echo "[$arg]" done } echo; echo "IFS=\" \"" echo "-------" IFS=" " var=" a b c " output_args_one_per_line $var # output_args_one_per_line `echo " a b c "` # # [a] # [b] # [c] echo; echo "IFS=:" echo "-----" IFS=: var=":a::b:c:::" # То же самое, только пробелы зменены символом ":". output_args_one_per_line $var # # [] # [a] # [] # [b] # [c] # [] # [] # [] # То же самое происходит и с разделителем полей "FS" в awk. # Спасибо Stephane Chazelas. echo exit 0 |
$LC_COLLATE
Чаще всего устанавливается в .bashrc или /etc/profile, эта переменная задает порядок сортировки символов, в операциях подстановки имен файлов и в поиске по шаблону. При неверной настройке переменной LC_COLLATE можно получить весьма неожиданные результаты.
|
Начиная с версии 2.05, Bash, в операциях подстановки имен файлов, не делает различий между символами верхнего и нижнего регистров, в диапазонах символов в квадратных скобках. Например,, ls [A-M]* выведет как File1.txt, так и file1.txt. Возврат к общепринятому стандарту поведения шаблонов в квадратных скобках выполняется установкой переменной LC_COLLATE в значение C командой export LC_COLLATE=C в файле /etc/profile и/или ~/.bashrc. |
Эта внутренняя переменная определяет кодировку символов. Используется в операциях подстановки и поиске по шаблону.
$LINENO
Номер строки исполняемого сценария. Эта переменная имеет смысл только внутри исполняемого сценария и чаще всего применяется в отладочных целях.
# *** BEGIN DEBUG BLOCK *** last_cmd_arg=$_ # Запомнить.
echo "Строка $LINENO: переменная \"v1\" = $v1" echo "Последний аргумент командной строки = $last_cmd_arg" # *** END DEBUG BLOCK ***
$MACHTYPE
аппаратная архитектура
Идентификатор аппаратной архитектуры.
bash$ echo $MACHTYPE
i686
$OLDPWD
прежний рабочий каталог ("OLD-Print-Working-Directory")
$OSTYPE
тип операционной системы
bash$ echo $OSTYPE
linux
$PATH
путь поиска, как правило включает в себя каталоги /usr/bin/, /usr/X11R6/bin/, /usr/local/bin, и т.д.
Когда командный интерпретатор получает команду, то он автоматически пытается отыскать соответствующий исполняемый файл в указанном списке каталогов (в переменной $PATH). Каталоги, в указанном списке, должны отделяться друг от друга двоеточиями. Обычно, переменная $PATH инициализируется в /etc/profile и/или в ~/.bashrc (см. Глава 26).
bash$ echo $PATH
/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin
Инструкция PATH=${PATH}:/opt/bin
добавляет каталог /opt/bin в конец текущего пути поиска. Иногда может оказаться целесообразным, внутри сценария, временно добавить какой-либо каталог к пути поиска. По завершении работы скрипта, эти изменения будут утеряны (вспомните о том, что невозможно изменить переменные окружения вызывающего процесса).
|
Текущий "рабочий каталог", ./, обычно не включается в $PATH из соображений безопасности. |
Код возврата канала (конвейера). Интересно, что это не то же самое, что код возврата последней исполненной команды.
bash$ echo $PIPESTATUS
0
bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $PIPESTATUS
141
bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $?
127
|
Переменная $PIPESTATUS может давать неверные значения при вызове из командной строки. tcsh% bash bash$ who | grep nobody | sort bash$ echo ${PIPESTATUS[*]} 0 Если поместить эти строки в сценарий и исполнить его, то будут выведены верные значения 0 1 0. Спасибо Wayne Pollock за замечания и предоставленный пример. |
Переменная $PPID хранит PID (идентификатор) родительского процесса. [19]
Сравните с командой pidof.
$PS1
prompt, приглашение командной строки.
$PS2
Вторичное приглашение командной строки, выводится тогда, когда от пользователя ожидается дополнительный ввод. Отображается как ">".
$PS3
Третичное приглашение (prompt), выводится тогда, когда пользователь должен сделать выбор в операторе select (см. Пример 10-29).
$PS4
Приглашение (prompt) четвертого уровня, выводится в начале каждой строки вывода тогда, когда сценарий вызывается с ключом -x. Отображается как "+".
$PWD
рабочий (текущий) каталог
Аналог встроенной команды pwd.
#!/bin/bash
E_WRONG_DIRECTORY=73
clear # Очистка экрана.
TargetDirectory=/home/bozo/projects/GreatAmericanNovel
cd $TargetDirectory echo "Удаление файлов в каталоге $TargetDirectory."
if [ "$PWD" != "$TargetDirectory" ] then # Защита от случайного удаления файлов не в том каталоге.
echo "Неверный каталог!" echo "Переменная $PWD указывает на другой каталог!" exit $E_WRONG_DIRECTORY fi
rm -rf * rm .[A-Za-z0-9]* # удалить "скрытые" файлы (начинающиеся с ".") # rm -f .[^.]* ..?* удалить файлы, чьи имена начинаются с нескольких точек. # (shopt -s dotglob; rm -f *) тоже работает верно. # Спасибо S.C. за замечание.
# Имена файлов могут содержать любые символы из диапазона 0-255, за исключением "/". # Оставляю вопрос удаления файлов с "необычными" символами для самостоятельного изучения.
# Здесь можно вставить дополнительные действия, по мере необходимости.
echo echo "Конец." echo "Файлы, из каталога $TargetDirectory, удалены." echo
exit 0
$REPLY
переменная по-умолчанию, куда записывается ввод пользователя, выполненный с помощью команды read если явно не задана другая переменная. Так же может использоваться в операторе select, для построения меню выбора.
#!/bin/bash
echo echo -n "Ваше любимое растение? " read
echo "Ваше любимое растение: $REPLY." # REPLY хранит последнее значение, прочитанное командой "read" тогда, и только тогда #+ когда команде "read" не передается имя переменной.
echo echo -n "Ваш любимый фрукт? " read fruit echo "Ваш любимый фрукт $fruit." echo "но..." echo "Значение переменной \$REPLY осталось равным $REPLY." # Переменная $REPLY не была перезаписана потому, что # следующей команде "read", в качестве аргумента была передана переменная $fruit
echo
exit 0
$SECONDS
Время паботы сценария в секундах.
#!/bin/bash # Автор: Mendel Cooper # Дополнен переводчиком. #
TIME_LIMIT=10 INTERVAL=1
echo echo "Для прерывания работы сценария, ранее чем через $TIME_LIMIT секунд, нажмите Control-C." echo
while [ "$SECONDS" -le "$TIME_LIMIT" ] do # Оригинальный вариант сценария содержал следующие строки # if [ "$SECONDS" -eq 1 ] # then # units=second # else # units=seconds # fi # # Однако, из-за того, что в русском языке для описания множественного числа # существует большее число вариантов, чем в английском, # переводчик позволил себе смелость несколько подправить сценарий # (прошу ногами не бить! ;-) ) # === НАЧАЛО БЛОКА ИЗМЕНЕНИЙ, ВНЕСЕННЫХ ПЕРЕВОДЧИКОМ ===
let "last_two_sym = $SECONDS - $SECONDS / 100 * 100" # десятки и единицы if [ "$last_two_sym" -ge 11 -a "$last_two_sym" -le 19 ] then units="секунд" # для чисел, которые заканчиваются на "...надцать" else let "last_sym = $last_two_sym - $last_two_sym / 10 * 10" # единицы case "$last_sym" in "1" ) units="секунду" # для чисел, заканчивающихся на 1 ;; "2" | "3" | "4" ) units="секунды" # для чисел, заканчивающихся на 2, 3 и 4 ;; * ) units="секунд" # для всех остальных (0, 5, 6, 7, 8, 9) ;; esac fi # === КОНЕЦ БЛОКА ИЗМЕНЕНИЙ, ВНЕСЕННЫХ ПЕРЕВОДЧИКОМ ===
echo "Сценарий отработал $SECONDS $units." # В случае перегруженности системы, скрипт может перескакивать через отдельные #+ значения счетчика sleep $INTERVAL done
echo -e "\a" # Сигнал!
exit 0
$SHELLOPTS
список допустимых опций интерпретатора shell. Переменная доступна только для чтения.
bash$ echo $SHELLOPTS
braceexpand:hashall:histexpand:monitor:history:interactive-comments:emacs
$SHLVL
Уровень вложенности shell. Если в командной строке
echo $SHLVL
дает 1, то в сценарии значение этой переменной будет больше на 1, т.е. 2.
$TMOUT
Если переменная окружения $TMOUT содержит ненулевое значение, то интерпретатор будет ожидать ввод не более чем заданное число секунд, что, в первичном приглашении (см. описание PS1 выше), может привести к автоматическому завершению сеанса работы.
|
К сожалению это возможно только во время ожидания ввода с консоли или в окне терминала. А как было бы здорово, если бы можно было использовать эту внутреннюю переменную, скажем в комбинации с командой read! Но в данном контексте эта переменная абсолютно не применима и потому фактически бесполезна в сценариях. (Есть сведения о том, что в ksh время ожидания ввода командой read можно ограничить.) |
Как один из вариантов, можно предложить организовать прерывание цикла ожидания по сигналу. Но это потребует написание функции обработки сигналов командой trap (см. Пример 29-5).
Пример 9-2. Ограничения времени ожидания ввода
#!/bin/bash # timed-input.sh
# TMOUT=3 бесполезно в сценариях
TIMELIMIT=3 # Три секунды в данном случае, но может быть установлено и другое значение
PrintAnswer() { if [ "$answer" = TIMEOUT ] then echo $answer else # Чтобы не спутать разные варианты вывода. echo "Ваше любимое растение $answer" kill $! # "Прибить" ненужную больше функцию TimerOn, запущенную в фоновом процессе. # $! -- PID последнего процесса, запущенного в фоне. fi
}
TimerOn() { sleep $TIMELIMIT && kill -s 14 $$ & # Ждать 3 секунды, после чего выдать sigalarm сценарию. }
Int14Vector() { answer="TIMEOUT" PrintAnswer exit 14 }
trap Int14Vector 14 # переназначить процедуру обработки прерывания от таймера (14)
echo "Ваше любимое растение? " TimerOn read answer PrintAnswer
# По общему признанию, это не очень хороший способ ограничения времени ожидания, #+ однако опция "-t"команды "read" упрощает задачу. # См. "t-out.sh", ниже.
# Если вам нужно что-то более элегантное... #+ подумайте о написании программы на C или C++, #+ с использованием соответствующих библиотечных функций, таких как 'alarm' и 'setitimer'.
exit 0
В качестве альтернативы можно использовать stty.
Пример 9-3. Еще один пример ограничения времени ожидания ввода от пользователя
#!/bin/bash # timeout.sh
# Автор: Stephane Chazelas, # дополнен автором документа.
INTERVAL=5 # предел времени ожидания
timedout_read() { timeout=$1 varname=$2 old_tty_settings=`stty -g` stty -icanon min 0 time ${timeout}0 eval read $varname # или просто read $varname stty "$old_tty_settings" # См. man stty. }
echo; echo -n "Как Вас зовут? Отвечайте быстрее! " timedout_read $INTERVAL your_name
# Такой прием может не работать на некоторых типах терминалов. # Максимальное время ожидания зависит от терминала. # (чаще всего это 25.5 секунд).
echo
if [ ! -z "$your_name" ] # Если имя было введено... then echo "Вас зовут $your_name." else echo "Вы не успели ответить." fi
echo
# Алгоритм работы этого сценария отличается от "timed-input.sh". # Каждое нажатие на клавишу вызывает сброс счетчика в начальное состояние.
exit 0
Возможно самый простой способ -- использовать опцию -t команды read.
