Текст книги "Командная строка Linux"
Автор книги: Уильям Шоттс
Жанр:
ОС и Сети
сообщить о нарушении
Текущая страница: 28 (всего у книги 30 страниц)
33. Управление потоком выполнения: цикл for
В этой заключительной главе, посвященной управлению потоком выполнения, мы познакомимся еще с одной конструкцией организации циклов в командной оболочке. Цикл for отличается от циклов while и until поддержкой средств обработки последовательностей. Это очень полезная возможность. Как следствие, цикл for пользуется большой популярностью среди создателей сценариев для bash.
Цикл for реализован, что вполне естественно, в виде команды for. В современных версиях bash поддерживается две формы команды for.
for: традиционная форма
Оригинальный синтаксис команды for имеет следующий вид:
for переменная [in слова]; do
команды
done
где переменная – это имя переменной, значение которой будет увеличиваться в ходе выполнения цикла, слова – необязательный список элементов, которые последовательно будут присваиваться переменной, и команды – это команды, выполняемые в каждой итерации.
Команду for удобно использовать в командной строке. Рассмотрим, как она работает:
[me@linuxbox ~]$ for i in A B C D; do echo $i; done
A
B
C
D
В этом примере команда for получает список из четырех слов: A, B, C и D. Для обхода этого списка выполняется четыре итерации цикла. В начале каждой итерации переменной i присваивается очередное слово. Внутри цикла находится команда echo, она выводит значение i, чтобы показать, что присваивание действительно выполняется. Так же как в случае с циклами while и until, цикл for заканчивается ключевым словом done.
По-настоящему мощной особенностью for является разнообразие способов формирования списка слов. Например, можно использовать подстановку в фигурных скобках:
[me@linuxbox ~]$ for i in {A..D}; do echo $i; done
A
B
C
D
или подстановку имен файлов:
[me@linuxbox ~]$ for i in distros*.txt; do echo $i; done
distros-by-date.txt
distros-dates.txt
distros-key-names.txt
distros-key-vernums.txt
distros-names.txt
distros.txt
distros-vernums.txt
distros-versions.txt
или подстановку команд:
#!/bin/bash
# longest-word : поиск самой длинной строки в файле
while [[ -n $1 ]]; do
if [[ -r $1 ]]; then
max_word=
max_len=0
for i in $(strings $1); do
len=$(echo $i | wc -c)
if (( len > max_len )); then
max_len=$len
max_word=$i
fi
done
echo "$1: '$max_word' ($max_len characters)"
fi
shift
done
Этот пример осуществляет поиск самой длинной строки в файле. Когда в командной строке указано несколько имен файлов, сценарий вызывает процедуру strings (входит в состав пакета GNU binutils), чтобы получить список «слов» из каждого файла. Цикл for обрабатывает каждое слово по очереди и определяет, является ли оно самым длинным из встречавшихся до сих пор. По завершении цикла сценарий выводит самое длинное слово.
Если необязательный компонент слова в команде for отсутствует, она по умолчанию обрабатывает позиционные параметры. Чтобы показать использование этого способа, изменим сценарий longest-word:
#!/bin/bash
# longest-word2 : поиск самой длинной строки в файле
for i; do
if [[ -r $i ]]; then
max_word=
max_len=0
for j in $(strings $i); do
len=$(echo $j | wc -c)
if (( len > max_len )); then
max_len=$len
max_word=$j
fi
done
echo "$i: '$max_word' ($max_len characters)"
fi
done
Почему i?
Вы могли заметить, что во всех примерах цикла for выше использовалась переменная i. Почему? В действительности за этим выбором не стоят какие-то определенные причины, кроме стремления следовать традициям. В команде for можно использовать любую допустимую переменную, но чаще всего используется переменная i, а также j и k.
Своими корнями эта традиция уходит в язык программирования Fortran. В Fortran необъявленные переменные, начинающиеся с букв I, J, K, L и M, автоматически становились целочисленными, тогда как переменные, начинающиеся с любой другой буквы, – действительными, или вещественными (способны хранить числа с дробной частью). Эта особенность вынуждала программистов использовать переменные I, J и K в качестве переменных цикла, так как использование их в качестве временных переменных (чем переменные цикла в действительности и являются) требовало меньших усилий.
Из-за этого даже в среде программистов на Fortran ходила острота: «GOD is real, unless declared integer» (Бог действителен, пока явно не объявлен целым).
Как видите, мы заменили внешний цикл while циклом for. Так как список слов в команде for отсутствует, она перебирает позиционные параметры. Во внутреннем цикле вместо переменной i теперь используется переменная j. Кроме того, нам больше не нужна команда shift.
for: форма в стиле языка C
В некоторые версии bash добавлена вторая форма синтаксиса команды for, напоминающая одноименный оператор в языке программирования C, которая поддерживается также многими другими языками.
for (( выражение1; выражение2; выражение3 )); do
команды
done
где выражение1, выражение2 и выражение3 – это арифметические выражения, а команды – это команды, выполняемые в каждой итерации цикла.
Своим поведением эта форма эквивалентна следующей конструкции:
(( выражение1 ))
while (( выражение2 )); do
команды
(( выражение3 ))
done
выражение1 инициализирует цикл, выражение2 определяет условие завершения цикла, выражение3 выполняется в конце каждой итерации.
Ниже приводится пример типичного применения:
#!/bin/bash
# simple_counter : демонстрация команды for в стиле языка C
for (( i=0; i<5; i=i+1 )); do
echo $i
done
Этот сценарий произведет следующий вывод:
[me@linuxbox ~]$ simple_counter
0
1
2
3
4
Здесь выражение1 инициализирует переменную i значением 0, выражение2 позволяет продолжать итерации, пока значение i остается меньше 5, выражение3 увеличивает на единицу значение i в конце каждой итерации.
Форма команды for в стиле языка C выглядит предпочтительнее, если требуется работать с числовыми последовательностями. Несколько примеров ее применения будут приведены в следующих двух главах.
Заключительное замечание
Познакомившись с командой for, внесем заключительное усовершенствование в наш сценарий sys_info_page. В настоящий момент функция report_home_space выглядит так:
report_home_space () {
if [[ $(id -u) -eq 0 ]]; then
cat <<– _EOF_
Home Space Utilization (All Users)
$(du -sh /home/*)
_EOF_
else
cat <<– _EOF_
Home Space Utilization ($USER)
$(du -sh $HOME)
_EOF_
fi
return
}
Теперь мы можем переписать ее, добавив вывод информации о домашнем каталоге каждого пользователя и включив в вывод общее число файлов и подкаталогов в каждом из них:
report_home_space () {
local format="%8s%10s%10sn"
local i dir_list total_files total_dirs total_size user_name
if [[ $(id -u) -eq 0 ]]; then
dir_list=/home/*
user_name="All Users"
else
dir_list=$HOME
user_name=$USER
fi
echo "
Home Space Utilization ($user_name)
"for i in $dir_list; do
total_files=$(find $i -type f | wc -l)
total_dirs=$(find $i -type d | wc -l)
total_size=$(du -sh $i | cut -f 1)
echo "
$i
"echo "
""printf "$format" "Dirs" "Files" "Size"
printf "$format" "–" "–" "–"
printf "$format" $total_dirs $total_files $total_size
echo "
done
return
}
В этой новой версии применено многое из того, что мы узнали к данному моменту. Она все еще проверяет наличие привилегий суперпользователя, но вместо того, чтобы выполнить полный набор операций в каждой из ветвей if, здесь устанавливаются некоторые переменные, которые затем используются в цикле for. В функции использованы несколько локальных переменных и команда printf для форматирования части вывода.
34. Строки и числа
Любые компьютерные программы обрабатывают данные. В предыдущих главах основное внимание уделялось обработке данных на уровне файлов. Однако многие задачи решаются с использованием меньших единиц данных, таких как строки и числа.
В этой главе мы рассмотрим некоторые возможности командной оболочки для работы со строками и числами. Командная оболочка поддерживает большое разнообразие способов подстановки параметров, которые выполняют строковые операции. В дополнение к подстановке результатов арифметических выражений (о которой рассказывалось в главе 7) существует программа командной строки bc, выполняющая математические операции.
Подстановка параметров
Механизм подстановки параметров уже рассматривался в главе 7, но там этот механизм не был описан детально, потому что большая часть его возможностей используется в сценариях, а не в командной строке. Мы уже знакомы с некоторыми формами подстановки параметров, например с подстановкой значений переменных командной оболочки. Но в командной оболочке их намного больше.
Простые параметры
Простейшую форму подстановки параметров можно наблюдать в использовании переменных. Например, запись $a после подстановки превращается в содержимое переменной a. Простые параметры можно заключать в фигурные скобки, например: ${a}. Это не оказывает влияния на результат подстановки, но является необходимым, если сразу за именем переменной следует какой-то другой текст, который может сбивать с толку командную оболочку. В следующем примере выполняется попытка сконструировать имя файла добавлением строки _file к содержимому переменной a.
[me@linuxbox ~]$ a="foo"
[me@linuxbox ~]$ echo «$a_file»
Если выполнить эту последовательность команд, результатом будет пустое значение, потому что командная оболочка попытается выполнить подстановку значения переменной a_file вместо a. Эта проблема устраняется с помощью фигурных скобок:
[me@linuxbox ~]$ echo «${a}_file»
foo_file
Мы видели также, что доступ к позиционным параметрам с порядковыми номерами выше 9 тоже осуществляется с помощью фигурных скобок. Например, прочитать 11-й позиционный параметр можно следующим образом: ${11}.
Подстановка пустых переменных
Некоторые формы подстановки параметров помогают решать проблемы с несуществующими, или пустыми, переменными. Эти формы удобно использовать для обработки ситуаций отсутствия позиционных параметров и назначения им значений по умолчанию. Ниже приводится пример такой подстановки:
${параметр:-слово}
Если параметр не определен (то есть отсутствует) или содержит пустое значение, механизм подстановки вернет значение указанного слова. Если параметр не пустой, механизм подстановки вернет значение параметра.
[me@linuxbox ~]$ foo=
[me@linuxbox ~]$ echo ${foo:-"substitute value if unset"}
substitute value if unset
[me@linuxbox ~]$ echo $foo
[me@linuxbox ~]$ foo=bar
[me@linuxbox ~]$ echo ${foo:-"substitute value if unset"}
bar
[me@linuxbox ~]$ echo $foo
bar
Вот еще один вариант подстановки, где вместо дефиса используется знак «равно»:
${параметр:=слово}
Если параметр не определен или содержит пустое значение, механизм подстановки вернет значение указанного слова и дополнительно присвоит его параметру. Если параметр не пустой, механизм подстановки вернет значение параметра.
[me@linuxbox ~]$ foo=
[me@linuxbox ~]$ echo ${foo:="default value if unset"}
default value if unset
[me@linuxbox ~]$ echo $foo
default value if unset
[me@linuxbox ~]$ foo=bar
[me@linuxbox ~]$ echo ${foo:="default value if unset"}
bar
[me@linuxbox ~]$ echo $foo
bar
ПРИМЕЧАНИЕ
Таким способом нельзя присваивать значения позиционным и другим специальным параметрам.
Ниже демонстрируется форма со знаком вопроса:
${параметр:?слово}
Если параметр не определен или содержит пустое значение, механизм подстановки завершит сценарий с ошибкой и выведет значение указанного слова в стандартный вывод ошибок. Если параметр не пустой, механизм подстановки вернет значение параметра.
[me@linuxbox ~]$ foo=
[me@linuxbox ~]$ echo ${foo:?"parameter is empty"}
bash: foo: parameter is empty
[me@linuxbox ~]$ echo $?
1
[me@linuxbox ~]$ foo=bar
[me@linuxbox ~]$ echo ${foo:?"parameter is empty"}
bar
[me@linuxbox ~]$ echo $?
0
Ниже демонстрируется форма со знаком «плюс»:
${параметр:+слово}
Если параметр не определен или содержит пустое значение, механизм подстановки вернет пустое значение. Если параметр не пустой, механизм подстановки вернет значение слова, но сам параметр не изменится.
[me@linuxbox ~]$ foo=
[me@linuxbox ~]$ echo ${foo:+"substitute value if set"}
[me@linuxbox ~]$ foo=bar
[me@linuxbox ~]$ echo ${foo:+"substitute value if set"}
substitute value if set
Получение имен переменных
Командная оболочка может возвращать имена переменных. Это используется в некоторых экзотических ситуациях.
${!префикс*}
${!префикс@}
Эти две формы подстановки возвращают имена существующих переменных, начинающиеся с указанного префикса. Согласно документации bash, обе формы действуют совершенно одинаково. Следующая команда выводит список всех переменных окружения с именами, начинающимися с BASH:
[me@linuxbox ~]$ echo ${!BASH*}
BASH BASH_ARGC BASH_ARGV BASH_COMMAND BASH_COMPLETION BASH_COMPLETION_DIR BASH_LINENO BASH_SOURCE BASH_SUBSHELL BASH_VERSINFO BASH_VERSION
Операции со строками
Существует множество форм подстановки, которые можно использовать для работы со строками. Многие из них особенно хорошо подходят для операций с путями. Форма
${#параметр}
вернет длину строки, содержащуюся в указанном параметре. Обычно роль параметра играет строка, но если передать @ или *, то механизм подстановки вернет число позиционных параметров.
[me@linuxbox ~]$ foo="This string is long."
[me@linuxbox ~]$ echo «'$foo' is ${#foo} characters long.»
'This string is long.' is 20 characters long.
Следующая форма подстановки:
${параметр:смещение}
${параметр:смещение:длина}
используется для извлечения фрагмента строки, содержащейся в параметре. Извлечение начинается с указанного смещения от начала строки и продолжается до конца строки, если не указана длина.
[me@linuxbox ~]$ foo="This string is long."
[me@linuxbox ~]$ echo ${foo:5}
string is long.
[me@linuxbox ~]$ echo ${foo:5:6}
string
Если указать отрицательное смещение, его отсчет начнется с конца строки вместо начала. Обратите внимание, что отрицательному значению должен предшествовать пробел, чтобы предотвратить путаницу с формой ${параметр:-слово}. Длина, если указана, в этом случае также должна быть меньше 0. Если в качестве параметра передать @, результатом подстановки будет длина позиционных параметров, начиная с указанного смещения.
[me@linuxbox ~]$ foo="This string is long."
[me@linuxbox ~]$ echo ${foo: -5}
long.
[me@linuxbox ~]$ echo ${foo: -5:2}
lo
Следующие две формы:
${параметр#шаблон}
${параметр##шаблон}
возвращают значение параметра, удаляя из него начальную часть, определяемую указанным шаблоном. В шаблоне допускается использовать групповые символы: например, те, что используются в подстановке путей. Эти две формы отличаются тем, что форма # удаляет кратчайшее совпадение, тогда как форма ## удаляет самое длинное совпадение.
[me@linuxbox ~]$ foo=file.txt.zip
[me@linuxbox ~]$ echo ${foo#*.}
txt.zip
[me@linuxbox ~]$ echo ${foo##*.}
zip
Следующие две формы:
${параметр%шаблон}
${параметр%%шаблон}
действуют так же, как формы # и ##, представленные выше, но удаляют текст с конца строки, содержащейся в параметре.
[me@linuxbox ~]$ foo=file.txt.zip
[me@linuxbox ~]$ echo ${foo%.*}
file.txt
[me@linuxbox ~]$ echo ${foo%%.*}
file
Следующие формы:
${параметр/шаблон/строка}
${параметр//шаблон/строка}
${параметр/#шаблон/строка}
${параметр/%шаблон/строка}
выполняют поиск с заменой в содержимом указанного параметра. Если в параметре будет найдено совпадение с шаблоном, который может содержать групповые символы, это совпадение будет заменено содержимым указанной строки. Первая форма заменит только первое совпадение с шаблоном. Форма // заменит все найденные совпадения. Форма /# выполняет замену, только если совпадение с шаблоном найдено в самом начале строки, а форма /% выполняет замену, только если совпадение найдено в конце строки. Часть /строка можно опустить, и тогда совпавший фрагмент будет удален.
[me@linuxbox ~]$ foo=JPG.JPG
[me@linuxbox ~]$ echo ${foo/JPG/jpg}
jpg.JPG
[me@linuxbox ~]$ echo ${foo//JPG/jpg}
jpg.jpg
[me@linuxbox ~]$ echo ${foo/#JPG/jpg}
jpg.JPG
[me@linuxbox ~]$ echo ${foo/%JPG/jpg}
JPG.jpg
Механизм подстановки параметров – ценный инструмент. Его возможности для работы со строками можно использовать вместо других широко используемых команд, таких как sed и cut. Применение механизма подстановки способствует увеличению производительности сценария за счет отсутствия необходимости выполнять внешние программы. Например, изменим программу longest-word из предыдущей главы, задействовав подстановку параметра ${#j} взамен подстановки команды $(echo $j | wc -c), которая к тому же выполняется в подоболочке:
#!/bin/bash
# longest-word3 : поиск самой длинной строки в файле
for i; do
if [[ -r $i ]]; then
max_word=
max_len=
for j in $(strings $i); do
len=${#j}
if (( len > max_len )); then
max_len=$len
max_word=$j
fi
done
echo "$i: '$max_word' ($max_len characters)"
fi
shift
done
Далее, сравним эффективность двух версий с помощью команды time:
[me@linuxbox ~]$ time longest-word2 dirlist-usr-bin.txt
dirlist-usr-bin.txt: 'scrollkeeper-get-extended-content-list' (38 characters)
real 0m3.618s
user 0m1.544s
sys 0m1.768s
[me@linuxbox ~]$ time longest-word3 dirlist-usr-bin.txt
dirlist-usr-bin.txt: 'scrollkeeper-get-extended-content-list' (38 characters)
real 0m0.060s
user 0m0.056s
sys 0m0.008s
Первоначальной версии потребовалось 3,618 секунды, чтобы просканировать текстовый файл, тогда как новой версии, использующей механизм подстановки параметров, понадобилось всего 0,06 секунды – весьма существенное улучшение.
Вычисление и подстановка арифметических выражений
В главе 7 мы видели, как работает механизм подстановки результатов арифметических выражений. Он используется для выполнения разных арифметических операций с целыми числами. Ниже приводится его базовый синтаксис
$((выражение))
где выражение – это любое допустимое арифметическое выражение.
Он тесно связан с составной командой (( )), использовавшейся в главе 27 для вычисления арифметических выражений (оценки истинности).
В предыдущих главах мы видели некоторые наиболее типичные выражения и операторы, а здесь рассмотрим более полный их список.
Основание системы счисления
В главе 9 мы познакомились с восьмеричными (в системе счисления с основанием 8) и шестнадцатеричными (в системе счисления с основанием 16) числами. В арифметических выражениях командная оболочка позволяет использовать целочисленные константы в системах счисления с любым основанием. В табл. 34.1 показаны формы записи чисел с указанием основания системы счисления.
Таблица 34.1. Определение основания системы счисления
Форма записи
Описание
Число
По умолчанию числа без упоминания системы счисления интерпретируются как десятичные числа (в системе счисления с основанием 10)
0число
В арифметических выражениях числа, начинающиеся с нуля, интерпретируются как восьмеричные (в системе счисления с основанием 8)
0xчисло
Форма записи шестнадцатеричных чисел
основание#число
Число в системе счисления с указанным основанием
Несколько примеров:
[me@linuxbox ~]$ echo $((0xff))
255
[me@linuxbox ~]$ echo $((2#11111111))
255
В этих примерах выводится значение шестнадцатеричного числа ff (наибольшее двухзначное число) и наибольшее восьмизначное двоичное число (в системе счисления с основанием 2).
Унарные операторы
Оболочка поддерживает два унарных оператора, + и -, используемых для обозначения положительных и отрицательных чисел соответственно.
Простая арифметика
В табл. 34.2 перечислены обычные арифметические операторы.
Таблица 34.2. Арифметические операторы
Оператор
Описание
+
Сложение
–
Вычитание
*
Умножение
/
Целочисленное деление
**
Степень числа
%
Деление по модулю (остаток от целочисленного деления)
Действия большинства из перечисленных операторов не вызывают вопросов, кроме целочисленного деления и деления по модулю, которые требуют дополнительного обсуждения.
Поскольку оболочка поддерживает только арифметические операции с целыми числами, результатом деления всегда будет целое число:
[me@linuxbox ~]$ echo $(( 5 / 2 ))
2
Это обстоятельство увеличивает важность операции определения остатка от деления:
[me@linuxbox ~]$ echo $(( 5 % 2 ))
1
Используя операторы деления и деления по модулю, можно определить, что деление 5 на 2 дает в результате 2 с остатком 1.
Вычисление остатка от деления удобно использовать в циклах. Это позволяет выполнять в цикле определенные операции с заданным интервалом. В примере ниже выводится строка чисел, в которой выделяются числа, кратные 5:
#!/bin/bash
# modulo : демонстрация оператора деления по модулю
for ((i = 0; i <= 20; i = i + 1)); do
remainder=$((i % 5))
if (( remainder == 0 )); then
printf "<%d> " $i
else
printf "%d " $i
fi
done
printf "n"
Запустив этот сценарий, вы получите следующий результат:
[me@linuxbox ~]$ modulo
<0> 1 2 3 4 <5> 6 7 8 9 <10> 11 12 13 14 <15> 16 17 18 19 <20>
Присваивание
Хотя на данном этапе это не очевидно, тем не менее арифметические выражения могут выполнять операцию присваивания. Мы уже выполняли присваивание много раз, хотя и в других контекстах. Каждый раз, передавая переменной число, мы выполняем присваивание. То же самое можно делать в арифметических выражениях:
[me@linuxbox ~]$ foo=
[me@linuxbox ~]$ echo $foo
[me@linuxbox ~]$ if (( foo = 5 ));then echo «It is true.»; fi
It is true.
[me@linuxbox ~]$ echo $foo
5
В примере выше мы сначала присвоили переменной foo пустое значение и проверили, что она действительно получила пустое значение. Далее выполнили команду if с составной командой (( foo = 5 )). Эта команда имеет два интересных аспекта: (1) она присваивает значение 5 переменной foo и (2) оценивает ее значение как истинное, потому что присваивание прошло успешно.
ПРИМЕЧАНИЕ
Важно запомнить значение оператора = в примере выше. Одиночный знак = выполняет присваивание: выражение foo = 5 говорит: «Сделать значение переменной foo равным 5». Двойной знак == определяет эквивалентность: выражение foo == 5 говорит: «Переменная foo равна 5?» Это обстоятельство может вызывать путаницу, потому что команда test интерпретирует одиночный знак = как оператор сравнения строк. Это еще одна причина предпочесть более современные составные команды [[ ]] и (( )) вместо test.
В дополнение к оператору = командная оболочка поддерживает еще несколько очень полезных операторов присваивания, перечисленных в табл. 34.3.
Таблица 34.3. Операторы присваивания
Форма записи
Описание
параметр = значение
Простое присваивание. Присваивает указанное значение указанному параметру
параметр += значение
Присваивание со сложением. Эквивалентно выражению параметр = параметр + значение
параметр -= значение
Присваивание с вычитанием. Эквивалентно выражению параметр = параметр – значение
параметр *= значение
Присваивание с умножением. Эквивалентно выражению параметр = параметр × значение
параметр /= значение
Присваивание с целочисленным делением. Эквивалентно выражению параметр = параметр ÷ значение
параметр %= значение
Присваивание с делением по модулю. Эквивалентно выражению параметр = параметр % значение
параметр++
Постинкремент переменной. Эквивалентно выражению параметр = параметр + 1. (Но см. обсуждение ниже.)
параметр–
Постдекремент переменной. Эквивалентно выражению параметр = параметр – 1
++параметр
Преинкремент переменной. Эквивалентно выражению параметр = параметр + 1
–параметр
Предекремент переменной. Эквивалентно выражению параметр = параметр – 1
Эти операторы присваивания обеспечивают удобный и компактный способ записи многих арифметических вычислений. Особый интерес представляют операторы инкремента (++) и декремента (–), они увеличивают или уменьшают значение своего параметра на 1. Эти операторы заимствованы из языка программирования C и внедрены в несколько других языков программирования, включая bash.
Операторы инкремента и декремента могут находиться перед параметром или после него. Хотя в обоих случаях они увеличивают или уменьшают значение параметра на 1, тем не менее их местоположение играет важную роль. Если оператор помещается перед параметром, сначала выполняется операция инкремента (или декремента) и только потом возвращается измененное значение параметра. Если оператор помещается за параметром, операция выполняется после возврата значения. Такое поведение может показаться странным, но оно реализовано с умыслом. Взгляните на следующий пример:
[me@linuxbox ~]$ foo=1
[me@linuxbox ~]$ echo $((foo++))
1
[me@linuxbox ~]$ echo $foo
2
Если присвоить переменной foo значение 1 и затем увеличить ее значение с помощью оператора ++, следующего за именем переменной, выражение вернет прежнее значение 1 переменной foo. Однако если вывести значение переменной второй раз, мы увидим увеличенное значение. Если поместить оператор ++ перед параметром, мы получим более ожидаемый результат:
[me@linuxbox ~]$ foo=1
[me@linuxbox ~]$ echo $((++foo))
2
[me@linuxbox ~]$ echo $foo
2
Для большинства приложений на языке командной оболочки более полезным будет префиксный оператор.
Операторы ++ и – часто используются совместно с циклами. Внесем некоторые улучшения в сценарий, демонстрирующий применение оператора деления по модулю, чтобы немного сократить его:
#!/bin/bash
# modulo2 : демонстрация оператора деления по модулю
for ((i = 0; i <= 20; ++i )); do
if (((i % 5) == 0 )); then
printf "<%d> " $i
else
printf "%d " $i
fi
done
printf "n"
Битовые операции
Командной оболочкой поддерживается класс операторов, которые манипулируют числами не совсем обычным способом. Эти операторы действуют на уровне битов. Они применяются для выполнения некоторых низкоуровневых операций, часто связанных с установкой или чтением битовых флагов. Описание битовых операторов приводится в табл. 34.4.
Таблица 34.4. Битовые операторы
Оператор
Описание
~
Поразрядное отрицание. Изменяет значения всех битов в числе на противоположные
<<
Поразрядный сдвиг влево. Сдвигает все биты в числе на один разряд влево
>>
Поразрядный сдвиг вправо. Сдвигает все биты в числе на один разряд вправо
&
Поразрядная операция И (AND). Выполняет операцию И над всеми битами двух чисел
|
Поразрядная операция ИЛИ (OR). Выполняет операцию ИЛИ над всеми битами двух чисел
^
Поразрядная операция ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR). Выполняет операцию ИСКЛЮЧАЮЩЕЕ ИЛИ над всеми битами двух чисел
Обратите внимание, что для всех битовых операторов, кроме поразрядного отрицания, существуют соответствующие операторы присваивания (например, <<=).
Ниже показано, как с использованием оператора поразрядного сдвига влево вывести список степеней 2:
[me@linuxbox ~]$ for ((i=0;i<8;++i)); do echo $((1<
1
2
4
8
16
32
64
128
Логические операторы
Как мы узнали в главе 27, составная команда (( )) поддерживает разные операторы сравнения. Однако существует еще несколько операторов, которые можно использовать для оценки. Полный список приводится в табл. 34.5.
Таблица 34.5. Операторы сравнения
Оператор
Описание
<=
Меньше или равно
>=
Больше или равно
<
Меньше
>
Больше
==
Равно
!=
Не равно
&&
Логическое И (AND)
||
Логическое ИЛИ (OR)
выражение1?выражение2:выражение3
Тернарный (трехместный) оператор сравнения. Если выражение1 вернет ненулевое значение (арифметическую истину), будет выполнено выражение2, иначе – выражение3
При использовании логических операторов в арифметических выражениях действуют следующие правила: выражение, возвращающее 0, считается ложным, а выражение, возвращающее ненулевое значение, – истинным. Составная команда (( )) отображает результаты в обычные для командной оболочки коды завершения:
[me@linuxbox ~]$ if ((1)); then echo «true»; else echo «false»; fi
true
[me@linuxbox ~]$ if ((0)); then echo «true»; else echo «false»; fi
false
Самым странным из логических операторов выглядит тернарный (или трехместный) оператор. Этот оператор (заимствованный из языка программирования C) самостоятельно выполняет логическую проверку. Его можно использовать вместо инструкции if/then/else. Он оперирует тремя арифметическими выражениями (этот оператор не работает со строками), и если первое выражение оценивается как истинное (то есть возвращает ненулевое значение), выполняется второе выражение. Иначе выполняется третье выражение. Опробуем его в командной строке.
[me@linuxbox ~]$ a=0
[me@linuxbox ~]$ ((a<1?++a:–a))
[me@linuxbox ~]$ echo $a
1
[me@linuxbox ~]$ ((a<1?++a:–a))
[me@linuxbox ~]$ echo $a
0
Этот пример реализует переключение значения переменной. Каждый раз, когда выполняется оператор, значение переменной a переключается с 0 на 1 или обратно.
Обратите внимание, что прямое присваивание в этом операторе считается недопустимой операцией. Если попытаться выполнить присваивание, bash сообщит об ошибке:
[me@linuxbox ~]$ a=0
[me@linuxbox ~]$ ((a<1?a+=1:a-=1))
bash: ((: a<1?a+=1:a-=1: attempted assignment to non-variable (error token is "-=1")
Эту проблему можно решить, заключив выражения присваивания в круглые скобки:
[me@linuxbox ~]$ ((a<1?(a+=1):(a-=1)))
Далее приводится более полный пример использования арифметических операторов в сценарии, который выводит простую таблицу чисел:
#!/bin/bash
# arith-loop: сценарий для демонстрации арифметических операторов
finished=0
a=0
printf "ata**2ta**3n"
printf "=t====t====n"
until ((finished)); do
b=$((a**2))
c=$((a**3))
