Жил-был фермер, который хотел научить своего осла говорить. Он снова и снова пытался заставить осла произнести слова, но каждый раз ему это не удавалось. Однажды ему пришла в голову идея. Он решил повторять одно и то же слово снова и снова перед ослом. Поначалу осел, казалось, не обращал внимания, но через некоторое время начал имитировать звуки, издаваемые фермером. При постоянном повторении осел в конце концов научился говорить.
Мораль этой истории такова: «Повторение — мать учения». Точно так же, как фермер, который научил своего осла говорить посредством постоянных усилий, мы можем научиться чему угодно, постоянно повторяя это, пока это не станет частью наших знаний или навыков.
Притча "Повторение- мать учения" (С) Wizard-Vicuna
В процессе написания программ на Bash я столкнулся с проблемой. Конструкции, заимствованные из примеров, которые мне предоставляли искусственные интеллекты понятны когда уже есть в готовом виде, но ими не получается свободно излагать свои мысли, когда дело доходит до самостоятельной работы. Мне кажется причина этого в том, что при ознакомлении с ними было приложено не достаточно усилий, чтобы они как следует осели. При чтении литературы эти моменты проговариваются более отчётливо и поэтому получается лучший результат. Поэтому практическое прохождение крупного блока тем с ИИ решено закреплять конспектом тех же тем по книгам.
По Bash скриптам под рукой у меня книга Уильяма Шоттса "Командная строка Linux". Её то я и использую для шлифовки своих знаний по этой теме, да простит меня автор за такое использование его трудов.
Итак, вот что мы имеем на сегодня.
Переменные объявляются следующим образом:
title="System Iformation Report"
А подставляются так:
echo "$title"
В переменную можно поместить результат выполнения команды:
d=$(ls -l foo.txt)
Или результат выполнения арифметического выражения:
e=$((5*7))
Некоторые специальные символы можно поместить в переменную с помощью экранирования последовательности
f="\t\ta string\n"
В одной строке можно выполнить присваивание сразу нескольких переменным:
a=5 b="a string"
При использовании подстановки имя переменных можно заключать в необязательные фигурные скобки {}. Это гарантирует, что командная оболочка правильно интерпретирует подстановку.
Арифметические выражения.
В арифметических выражениях командная оболочка позволяет использовать целочисленные константы в системах счисления с любым основанием. По умолчанию используется основание 10. Если числа начинаются с 0, оболочка интерпретирует их как восьмеричные (основание 8). Если числа начинаются с сочетания 0x, оболочка интерпретирует их как шестнадцатеричные. Любое основание можно задать в форме: основание#число.
Примеры:
echo $((0xff))
#Выведет 255
echo $((2#11111111))
#Выведет 255
Допустимые арифметические операторы:
+ Сложение
- Вычитание
* Умножение
/ Целочисленное деление
** Степень числа
% Деление по модулю
Присваивание и другие операторы
Помещение в переменную какого либо значение называется присваиванием. А оператор, который это делает - оператор присваивания. Существуют различные модификации этого оператора:
- параметр = значение. Присваивает указанное значение указанному параметру;
- параметр += значение. Эквивалентно выражению параметр = параметр + значение;
- параметр -= значение. Эквивалентно выражению параметр = параметр - значение;
- параметр *= значение. Эквивалентно выражению параметр = параметр * значение;
- параметр /= значение. Эквивалентно выражению параметр = параметр / значение;
- параметр %= значение. Эквивалентно выражению параметр = параметр % значение.
Командной оболочкой поддерживаются операторы, которые действуют на уровне битов:
"~". Поразрядное отрицание. Изменяет значения всех битов на противоположные.
"<<". Поразрядный сдвиг влево. Сдвигает все биты в числе на один разряд влево.
">>". Поразрядный сдвиг влево. Сдвигает все биты в числе на один разряд вправо.
"&". Поразрядная операция И (AND). Выполняет операцию И над всеми битами двух чисел.
"|". Поразрядная операция ИЛИ (OR). Выполняет операцию ИЛИ над всеми битами двух чисел.
"^". Поразрядная операция ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR). Выполняет операцию ИСКЛЮЧАЮЩЕЕ ИЛИ над всеми битами двух чисел.
Для всех битовых операторов, кроме поразрядного отрицания, существуют соответствующие операторы присваивания, например <<=.
Операторы сравнения, поддерживаемые составной командой (()):
<= Меньше или равно
>= Больше или равно
< Меньше
> Больше
== Равно
!= Не равно
&& Логическое И
|| Логическое ИЛИ
Также имеется тренарный оператор сравнения:
выражение1?выражение2:выражение3
Если выражение 1 вернёт ненулевое значение (арифметическую истину), будет выполнено выражение 2, иначе - выражение 3.
Операции с переменными
Подстановка пустых переменных
- ${параметр:-слово} - если параметр не определён или содержит пустое значение, механизм подстановки вернёт значение указанного слова. Если параметр не пустой, механизм подстановки вернёт значение параметра.
- ${параметр:=слово} - если параметр не определён или содержит пустое значение, механизм подстановки вернёт значение указанного слова и дополнительно присвоит его параметру. Если параметр не пустой, механизм подстановки вернёт значение параметра.
- ${параметр:?слово} - если параметр не определён или содержит пустое значение, механизм подстановки завершит сценарий с ошибкой и выведет значение указанного слова в стандартный вывод ошибок. Если параметр пустой, механизм подстановки вернёт значение параметра.
- ${параметр:+слово} - если параметр не определён или содержит пустое значение, механизм подстановки вернёт пустое значение. Если параметр не пустой, механизм подстановки вернёт значение слова, но сам параметр не изменится.
Командная оболочка может возвращать имена переменных. Для этого используется любая из двух форм:
{!префикс*}
{!префикс@}
Операции со строками - ${#параметр} - вернёт длину строки, содержащуюся в указанном параметре.
- ${параметр:смещение}
- ${параметр:смещение:длина} - используется для извлечения фрагмента строки, содержащейся в параметре. Извлечение начинается с указанного смещения от начала строки и продолжается до конца строки, если не указана длина.
Если указать отрицательное смещение, его отсчёт начнётся с конца строки вместо начала. Отрицательному смещению должен предшествовать пробел, чтобы предотвратить путаницу с формой ${параметр:-слово}
Формы, возвращающие значение параметра, удаляя из него начальную часть, определяемую указанным шаблоном:
- ${параметр#шаблон}
- ${параметр##шаблон}
В шаблоне допускается использовать групповые символы: например те, что используются в подстановке путей. эти две формы отличаются тем, что форма # удаляет кратчайшее совпадение, тогда как форма ## удаляет самое длинное совпадение.
Формы, удаляющие текст с конца строки, содержащейся в параметре:
- ${параметр%шаблон}
- ${параметр%%шаблон}
Формы, выполняющие поиск с заменой в содержимом указанного параметра. Если в параметре будет найдено совпадение с шаблоном, который может содержать групповые символы, это совпадение будет заменено содержимым указанной строки:
- ${параметр/шаблон/строка} - заменяет только первое совпадение с шаблоном;
- ${параметр//шаблон/строка} - заменит все найденные совпадения;
- ${параметр/#шаблон/строка} - выполнит замену, только если совпадение найдено в начале строки;
- ${параметр/%шаблон/строка} - выполнит замену, только если совпадение найдено в конце строки.
Часть /строка можно опустить, и тогда совпавший фрагмент будет удалён.
Дополнительной формой перенаправляя ввода/вывода, которая передаёт текст, встроенный в сценарий, на стандартный ввод команды, называется встроенным документом (here document). Синтаксис этой конструкции имеет вид:
команда << идентификатор
текст
идентификатор.
Пример:
cat << _EOF_
<HTML>
<HEAD>
<TITLE>$TITLE</TITLE>
</HEAD>
<BODY>
<H1>$TITLE</H1>
<P>$TIME_STAMP</P>
</BODY>
</HTML>
_EOF_
Если заменить оператор перенаправляя << на <<-, командная оболочка будет игнорировать начальные символы табуляции во встроенном документе.
Позиционные параметры.
Командная оболочка поддерживает множество переменных, которые называются позиционными параметрами и содержат отельные слова из командной строки. Эти переменные имеют имена от 0 до 9.
Переменная $0 хранит имя сценария. Переменные $1, $2 и т.д. содержат значения параметров сценария или аргументы.
Количество аргументов хранится в специальной переменной $#. Переменная $@ хранит все аргументы сценария.
Переменная $$ хранит идентификатор процесса оболочки в которой запущен сам скрипт.
Переменная $! хранит PID последнего процесса, запущенного в фоновом режиме.
Переменная $? хранит код выхода последней команды, которую выполнила оболочка.
Переменная $* хранит список позиционных параметров, начиная с $1. Если эту переменную заключить в двойные кавычки, позиционные параметры будут перечислены в списке через первый символ в переменной IFS (по умолчанию пробел), а сам список будет размещён в одной строке и заключён в кавычки. С помощью команды shift можно выполнять "сдвиг" параметров к началу списка. В функциях позиционные параметры используются для передачи аргументов.
Чтение со стандартного ввода
Встроенная команда read используется для чтения единственной строки со стандартного ввода. Команда имеет следующий синтаксис:
read [-параметры] [переменная...]
Где параметры - это один или несколько параметров:
-a - сохранить ввод в массив
-d разделитель - использовать в качестве признака конца ввода первый символ из строки разделитель, а не символ перевода строки
-e - использовать Readline для обработки ввода.
-n число - получить указанное число символов, а не всю строку
-p приглашение - показывать указанное приглашение к вводу
-r - режим без промежуточной обработки. Не интерпретировать символы обратного слеша как экранирующие символы.
-s - безмолвный режим
-t секунды - предельное время ожидания
-u дескриптор - произвести ввод из файла с указанным дескриптором вместо стандартного ввода.
Переменная - имя одной или нескольких переменных для сохранения введённого значения.
Команда test.
Чаще всего используется вместе с инструкцией if. Она может выполнять различные проверки и сравнения.
Синтаксис: [ выражение ]
Где выражение возвращает истинное (true) или ложное (false) значение. Команда test возвращает код завершения 0, если выражение истинно, и код завершения 1, если выражение ложно.
Выражения для проверки файлов:
файл1 -ef файл2 - файлы имеют одно и тоже число индексного узла
файл1 -nt файл2 - файл1 новее чем файл2
файл1 -ot файл2 - файл1 старше чем файл2
-b файл блочного устройства
-c файл символьного устройства
-d файл является каталогом
-e файл существует
-f файл существует и является обычным файлом
-g файл имеет атрибут set-group-ID
-G файл принадлежит действующей группе
-k файл имеет атрибут sticky-bit
-L файл является символической ссылкой
-O файл принадлежит действующему пользователю
-p файл является именованным каналом
-r файл доступен для чтения
-s файл имеет размер больше нуля
-S файл является сетевым сокетом
-t дескриптор файла - файл, подключённый к терминалу
-u файл имеет атрибут setuid
-w файл доступен для записи
-x файл доступен для выполнения
Выражения для проверки строк:
строка - строка не пустая
-n - длина строки больше нуля
-z - длина строки равна нулю
Выражения для проверки чисел:
число1 -eq число2 - число1 и число2 равны
число1 -ne число2 - число1 и число2 не равны
число1 -le число2 - число1 меньше или равно числу2
число1 -lt число2 - число1 меньше, чем число2
число1 -ge число2 - число1 больше или равно числу2
число1 -gt число2 - число1 больше, чем число2
Более современная версия команды тест имеет следующий синтаксис:
[[ выражение ]]
Она поддерживает новое выражение для проверки строк:
строка1 =~ регулярное выражение, возвращающее истинное значение, если строка 1 соответствует расширенному регулярному выражению.
В дополнение к этой команде bash также поддерживает составную команду (()) для проверки целых чисел. Она поддерживает полное множество арифметических операторов.
Управление потоком выполнения с помощью инструкции if.
Это базовая инструкция, обеспечивающая ветвление программы.
Она имеет следующий синтаксис:
if команды; then
команды
[elif команды; then
команды...]
[else
команды]
fi
Где команды - это список команд.
Оператор выбора case
Командная оболочка bash поддерживает составную команду выбора из нескольких вариантов, которая называется case. Она имеет следующий синтаксис:
case слово in
[шаблон [| шаблон]...) команды ;;]...
esac
Пример:
read -p "Enter selection [0-3] > "
case $REPLY in
0) echo "Program terminated."
exit
;;
1) echo "Hostname: $HOSTNAME"
uptime
;;
2) df -h
;;
3) if [[ $(id -u) -eq 0 ]]; then
echo "Home Space Utilization (All Users)"
du -sh /home/*
else
echo "Home Space Utilization ($USER)"
du -sh $HOME
fi
;;
*) echo "Invalid entry" >&2
exit 1
;;
esac
Команда case берёт значение слова из переменной REPLY и затем сопоставляет его с указанными шаблонами. Найдя соответствие, она выполняет команды, связанные с найденным шаблоном.
Шаблоны обрабатываются командой case точно также, как пути механизмом подстановки.
Примеры шаблонов:
a) - Соответствует, если слово содержит а.
[[:alpha:]] - Соответствует, если слово содержит единственный алфавитный символ.
???) - Соответствует, если слово содержит ровно три символа.
*.txt) - Соответствует, если слово заканчивается символами .txt.
*) - Соответствует любому значению слова.
Несколько шаблонов можно объединять, перечислив их через символ вертикальной черты. В результате получится комбинированный условный шаблон, объединённый по "ИЛИ".
Циклы while и until
Цикл while имеет следующий синтаксис:
while команды; do команды; done
Команда while проверяет код завершения списка команд. Пока код завершения равен 0, она выполняет команды внутри цикла.
Пример:
count=1
while [ $count -le 5 ]; do
echo $count
count=$((count+1))
done
echo "Finished."
Выдаст:
#1
#2
#3
#4
#5
#Finished
В bash имеются две встроенные команды для управления потоком выполнения внутри циклов. Команда break немедленно завершает цикл, после чего выполнение программы продолжается с первой инструкции, следующей за циклом. Другая команда - continue пропускает оставшуюся часть цикла, и программа переходит к началу его следующей итерации.
Команда until очень похожа на while, но завершает цикл не когда обнаружит ненулевой код завершения, а наоборот.
Цикл until продолжается, пока не получит код завершения 0.
Пример сценария с командой until:
until [ $count -gt 5 ]; do
echo $count
count=$((count + 1))
done
echo "Finished."
Чтение файлов в циклах
Команды while и until могут принимать данные со стандартного ввода. Это даёт возможность обрабатывать файлы с их помощью. Чтобы перенаправить файл в цикл, нужно поместить оператор перенаправления после инструкции done.
Пример:
while read distro version release; do
printf "Distro: %s\tVersion: %s\tReleased: %s\n" \
$distro \
$version \
$release
done < distros.txt
Этот цикл будет выводить поля их указанного файла с помощью read. После ввода каждой строки команда read будет завершаться с кодом 0, пока не достигнет конца файла. В этот момент она вернёт ненулевой код завершения и цикл завершится.
Цикл for.
Оригинальный синтаксис команды for имеет следующий вид:
for переменная [in слова]; do
команды
done
где переменная - это имя переменной, значение которой будет увеличиваться в ходе выполнения цикла, слова - необязательный список элементов, которые последовательно будут присваиваться переменной, и команды - это команды, выполняемые в каждой итерации.
По-настоящему мощной особенностью for является разнообразие способов формирования списка слов. Например, можно использовать подстановку в фигурных скобках:
for i in {A..D}; do echo $i; done
#Выведет
#A
#B
#C
#D
Или можно использовать подстановку имён файлов:
for i in distros*.txt; do echo $i; done
Или подстановку команд:
for i in $(strings $1); do
len=$(echo $i | wc -c)
done
Если необязательный компонент слова в комане for отсутствует, она по умолчанию обрабатывает позиционные параметры:
for i; do
echo "$i:"
done
В некоторые версии Bash добавлена вторая форма синтаксиса команды for, напоминающая одноимнный оператор языка C:
for (( выражение1; выражение 2; выражение 3 )); do
команды
done
где выражение1, выражение2, выражение3 - это арифметические выражения, а команды - это команды, выполняемые в каждой итерации цикла.
Массивы
Это переменные, хранящие более одного значения. Они состоят из ячеек, которые называются элементами, и каждый элемент содержит данные. Доступ к отдельному элементу осуществляется с использованием его адреса, который называется индексом. Массивы bash ограничены единственным измерением. Их можно рассматривать как электронные таблицы с единственным столбцом.
Массив можно создать командой declare -a имя
Значения массиву можно присваивать одним из двух способов:
имя[индекс]=значение
имя=(значение1 значение2 ...)
Значения, присваиваемые последовательным элементам массива, начинаются с элемента с индексом 0.
Вывести содержимое всего массива и определить число его элементов можно с помощтю механизма подстановки параметров.
Пример:
a[100]=foo
echo ${#a[@]} # число элементов в массиве
echo ${#a[100]} # длина элемента с индексом 100
animals=("a dog" "a cat" "a fish")
for i in "${animals[*]}"; do echo $i; done
# Выведет a dog a cat a fish
for i in "${animals[@]}"; do echo $i; done
# Выведет
# a dog
# a cat
# a fish
Индекс * возвращает содержимое массива, разбитое на отдельные слова, тогда как индекс @ возвращает содержимое массива с сохранением такого разделения, которое соответствует соедржимому одельных ячеек.
Данные в массиве могут быть представлены не непрерывно, а фрагментарно, например:
foo=(a[2]=a [4]=b [6]=c)
#Отсутствуют элементы 0, 1, 3, 5
Для поиска используемых индексов можно применить подстановку "${!foo[@]}":
for i in "${!foo[@]}"; do eco $i; done
#Будут выведены:
#2
#4
#6
Для добавления элементов в конец массива можно использовать оператор присваивания +=:
foo=(a b c)
echo ${foo[@]}
#Выведет: a b c
foo+=(d e f)
echo ${foo[@]}
#Выведет: a b c d e f
Удалить массив можно командой unset:
unset foo
Также командой unset можно удалить единственный элемент массива:
unset 'foo[2]'
Командная оболочка не имеет прямой поддержки операции сортировки, но её не трудно реализовать самостоятельно:
a=(f e d c b a)
echo "Original array: "${a[@]}"
# Выведет: f e d c b a
a_sorted=($(for i in "${a[@]}"; do echo $i; done | sort))
# Выведет: a b c d e f
Функции командной оболочки
Это пользователские подпрограммы, для создания которых используется следующий синтаксис:
function имя {
команды
return
}
Где имя - это функция, а команды - пследовательность команд внутри функции.
Команда return в этой строке завершает выполнение функции и возвращает управление в строку, следующую за вызовом функции.
Глобалные переменные существуют и доступны в любой точке программы. Внутри функций иногда желательно использовать локальные переменные.
Локальные переменные доступны толко внутри функции, в которой они определены, и прекращают своё существование по завершении выполнения функции. Для оьявления локальных переменных внутри функций используется служебное слово local, например: local foo - объявление локальной переменной foo.
Использование группировки и подоболочек
Bash поддерживает возможность группировки команд и применение подоболочки:
{ команда1; команда2; [команда3; ...] }
(команда1; команда2; [команда3;...])
Часто и тот и другой способ используется совместно с перенаправлением, например:
{ ls -l; echo "Listing of foo.txt"; cat foo.txt; } > output.txt
Подоболочка выполняет свои команды в дочерней копии текущей командной оболочки. Это означает, что в момент запуска подоболочки создаётся копия текущей оболочки и передаётя новому эземпляру оболочки. Когда подоболочка завешится, её копия окружения уничтожается, соответственно теряются любые изменения в окружении подоболочки (включая значение переменных).
Преодолеть эти ограничения позволяет особая форма подстановки, которая называется подстановкой процессов. Для процессов, отправляющих результаты в стандартный вывод используется следующий синтаксис: <(список). А для процессов, принимащих данные через стандартный ввод: >(список).
Пример:
read < <(echo "foo")
echo $REPLY
Подстановка процессов позволяет интерпретировать вывод подоболочки как обычный файл и осущесвтлять его перенаправление. Т.к. это форма подставноки, всегда можно узнать действительное подставляемое значение:
echo <(echi "foo")
Ловушки
Проектируя сложные сценарии важно предусматривать их реакцию на неожиданный выход пользователя из системы или выключение компьютера во время их выполнения. Если возникают подобные события, всем процессам посылается сигнал. Программы, представляющие эти процессы, могут выплнять некие действия, гарантирующие корректное завершение с сохранением неоьходимых данных. Для этой цели в bash поддерживается механизм, ивестный как ловушка (trap). Эта команда имеет следующий синтаксис:
trap аргумент сигнал [сигнал...]
Где аргумент - это строка, которая будет прочитана и выполнена как команда, а сигнал - идентификатор сигнала, в ответ на который будет выполнена указанная команда.
Пример:
trap "echo 'I am ignoring you.'" SIGINT SIGTERM
for i in {1..5}; do
echo "Iteration $i of 5"
sleep 5
done
Этот сценарий определяет ловушку, которая будет выполнять команду echo в ответ на сигналы SIGINT и SIGTERM, получаемые сценарием во время выполнения. Попытки остановить сценарий нажатием комбинации CTRL+C будут выводить на экран сообщение "I am ignoring you".
Асинхронное выполнение
В bash имеется встроенная команда wait, помогающая управлять асинхронным выполнением, когда запущено множество дочерних процессов и требуется координация действий между ними и родительским процессом. Она приостанавливает выполнение родительского сценария, пока не завершится дочерний сценарий.
Пример:
#Родительский сценарий
echo "Parent: starting..."
echo "Parent: launching child script..."
async-child &
pid=$!
echo "Parent: child (PID= $pid) launched."
echo "Parent: continuing..."
sleep 2
echo "Parent: pausing to wait for child to finish..."
wait $paid
echo "Parent: child is finished. Continuing..."
echo "Parent: parent is done. Exiting."
#Дочерний сценарий:
echo "Child: child is runing..."
sleep 5
echo "Child: child is done. Exiting."
Именованные каналы (named pipe)
Они создают соединения между двумя процессами и могу использоваться как обычные файлы. Такой механизм взаимодействия может испльзуется в клиент/серверной архитектуре. Именованные каналы имеют некоторое сходство с файлами, но на самом деле образуют буферы, действующие по принципу очереди: первым пришёл, первым вышел (First-In, First-OUT, FIFO). Также как в случае с обычными аналами, данные записываются с одного конца канала и извлекаются из другого.
С применнеием именованных каналов можно, нпример, выполнять следующие команды:
процесесс1 > именованный_канал
и
процесс2 < именованный_канал
И такая пара команд будет дейтсвовать подобно конвейеру:
процесс1 | процесс2
Создание именованного канала:
mkfifo pipe1
ls -l pipe1
Чтобы посмотреть как работают имнованные каналы можн открыть два терминала.
В первом запустить команду: ls -l > pipe1
Во втором терминале запустить команду: cat < pipe1
Во втром треминале появится список содержимого каталога, созданный в перво окне, как результат работы команды cat. команда ls первом окне терминала благополучно разблокируется и завершится.
Итого, что мы имеем про Bash скрипты насегодня.
- Арифметические и логические операции
- Операции со строками
- Операторы присваивания
- Логические операторы
- Операторы ветвления
- Обработка стандратного ввода
- Циклы
- Чтение файлов
- Массивы
- Функции
- Асинхронное программирование
- Именованные каналы
Это в общем-то неплохая основа для перехода к более интересным темам программирования. И всё это пока что стандартными средствами Linux. Неплохо.