Просмотр исходного текста страницы Advanced Bash-Scripting Guide

'''bash''' (от англ. '''B'''ourne '''a'''gain '''sh'''ell, каламбур «Born again» shell — «возрождённый» shell) — усовершенствованная и модернизированная вариация командной оболочки Bourne shell. Одна из наиболее популярных современных разновидностей командной оболочки UNIX. Особенно популярна в среде Linux, где она часто используется в качестве предустановленной командной оболочки.

Bash — это командный процессор, работающий, как правило, в интерактивном режиме в текстовом окне. Bash также может читать команды из файла, который называется скриптом (или сценарием). Как и все Unix-оболочки, он поддерживает автодополнение имён файлов и директорий, подстановку вывода результата команд, переменные, контроль за порядком выполнения, операторы ветвления и цикла. Ключевые слова, синтаксис и другие основные особенности языка были заимствованы из sh. Другие функции, например, история, были скопированы из csh и ksh. Bash в основном удовлетворяет стандарту POSIX, но с рядом расширений.

Название «bash» является акронимом от Bourne-again-shell («ещё-одна-командная-оболочка-Борна») и представляет собой игру слов: Bourne-shell — одна из популярных разновидностей командной оболочки для UNIX (sh), автором которой является Стивен Борн (1978), усовершенствована в 1987 году Брайаном Фоксом. Фамилия Bourne (Борн) перекликается с английским словом born, означающим «родившийся», отсюда: рождённая-вновь-командная оболочка.

В сентябре 2014 года в bash была обнаружена широко эксплуатируемая уязвимость Bashdoor.

= Часть первая. Ввведение =
'''Shell''' — это командная оболочка. Но это не просто промежуточное звено между пользователем и операционной системой, это ещё и мощный язык программирования. Программы на языке shell называют сценариями, или скриптами. Фактически, из скриптов доступен полный набор команд, утилит и программ Unix. Если этого недостаточно, то к вашим услугам внутренние команды shell — условные операторы, операторы циклов и пр., которые увеличивают мощь и гибкость сценариев. Shell-скрипты исключительно хороши при программировании задач администрирования системы и др., которые не требуют для своего создания полновесных языков программирования.
== Зачем необходимо знание языка Shell? ==
<br />Знание языка командной оболочки является залогом успешного решения задач администрирования системы. Даже если вы не предполагаете заниматься написанием своих сценариев. Во время загрузки Linux выполняется целый ряд сценариев из /etc/rc.d, которые настраивают конфигурацию операционной системы и запускают различные сервисы, поэтому очень важно четко понимать эти скрипты и иметь достаточно знаний, чтобы вносить в них какие либо изменения. Язык сценариев легок в изучении, в нем не так много специфических операторов и конструкций.
<br />
<br />Синтаксис языка достаточно прост и прямолинеен, он очень напоминает команды, которые приходится вводить в командной строке. Короткие скрипты практически не нуждаются в отладке, и даже отладка больших скриптов отнимает весьма незначительное время.
Shell-скрипты очень хорошо подходят для быстрого создания прототипов сложных приложений, даже не смотря на ограниченный набор языковых конструкций и определенную "медлительность". Такой метод позволяет детально проработать структуру будущего приложения, обнаружить возможные"ловушки" и лишь затем приступить к кодированию на C, C++, Java, или Perl.
<br />
<br />Скрипты возвращают нас к классической философии Unix — "разделяй и властвуй" т.е. разделение сложного проекта на ряд простых подзадач. Многие считают такой подход наилучшим или, по меньшей мере, наиболее эстетичным способом решения возникающих проблем, нежели использование нового поколения языков — "всё-в-одном", таких как Perl.
<span style="color:red">'''''Для каких задач неприменимы скрипты'''''</span>:
* для ресурсоемких задач, особенно когда важна скорость исполнения (поиск, сортировка и т.п.)
* для задач, связанных с выполнением математических вычислений, особенно это касается вычислений с плавающей запятой, вычислений с повышенной точностью, комплексных чисел(для таких задач лучше использовать C++ или FORTRAN)
* для кросс-платформенного программирования (для этого лучше подходит язык C)
* для сложных приложений, когда структурирование является жизненной необходимостью(контроль за типами переменных, прототипами функций и т.п.)
* для целевых задач, от которых может зависеть успех предприятия
* когда во главу угла поставлена безопасность системы, когда необходимо обеспечить целостность системы и защитить её от вторжения, взлома и вандализма
* для проектов, содержащих компоненты, очень тесно взаимодействующие между собой
* для задач, выполняющих огромный объем работ с файлами
* для задач, работающих с многомерными массивами
* когда необходимо работать со структурами данных, такими как связанные списки или деревья
* когда необходимо предоставить графический интерфейс с пользователем (GUI)
* когда необходим прямой доступ к аппаратуре компьютера
* когда необходимо выполнять обмен через порты ввода-вывода или сокеты
* когда необходимо использовать внешние библиотеки
* для проприетарных, "закрытых" программ (скрипты представляют из себя исходные тексты программ, доступные для всеобщего обозрения)
<br />
Если выполняется хотя бы одно из вышеперечисленных условий, то вам лучше обратиться к более мощным скриптовым языкам программирования, например Perl, Tcl, Python, Ruby или к высокоуровневым компилирующим языкам — C, C++ или Java. Но даже в этом случае, создание прототипа приложения на языке shell может существенно облегчить разработку.
Название BASH — это аббревиатура от "Bourne-Again Shell" и игра слов от, ставшего уже классикой,"Bourne Shell" Стефена Бурна (Stephen Bourne). В последние годы BASH достиг такой популярности,что стал стандартной командной оболочкой de facto для многих разновидностей Unix. Большинство принципов программирования на BASH одинаково хорошо применимы и в других командных оболочках, таких как Korn Shell (ksh), от которой Bash позаимствовал некоторые особенности,
и CShell и его производных(Примечательно, что C Shell не рекомендуется к использованию из-за отдельных проблем, отмеченных Томом Кристиансеном (Tom Christiansen) в октябре 1993 года на Usenet post). 
<br />
<br />Далее, в тексте документа вы найдете большое количество примеров скриптов, иллюстрирующихвозможности shell. Все примеры -- работающие. Они были протестированы, причем некоторые из них могут пригодиться в повседневной работе. Уважаемый читатель может "поиграть" с рабочим кодом скриптов, сохраняя их в файлы, с именами scriptname.sh.
<br />
<br />Не забудьте выдать этим файлам право на исполнение (chmod u+rx scriptname.sh), после чего сценарии можно будет запустить на исполнение и проверить результат их работы. Вам следует помнить, что описание некоторых примеров следует после исходного кода этого примера, поэтому, прежде чем запустить сценарий у себя — ознакомьтесь с его описанием. Скрипты были написаны автором книги, если не оговаривается иное.
== Для начала о Sha-Bang ==
<br />В простейшем случае, скрипт — это ни что иное, как простой список команд системы, записанный в файл. Создание скриптов поможет сохранить ваше время и силы, которые тратятся на ввод последовательности команд всякий раз, когда необходимо их выполнить.
<p style="text-align:center"><span style="color:green"> '''Пример. cleanup'''</span>: <span style="color:red">'''''Сценарий очистки лог-файлов в /var/log'''''</span></p>
<source lang="bash">
 # cleanup
 # Для работы сценария требуются права root.
 cd /var/log
 cat /dev/null > messages
 cat /dev/null > wtmp
 echo "Лог-файлы очищены."
</source>

<p style="text-align:center"><span style="color:green"> '''Пример. cleanup'''</span>: <span style="color:red">'''''Расширенная версия предыдущего сценария.'''''</span></p>
<source lang="bash">
#!/bin/bash
# cleanup, version 2
# Для работы сценария требуются права root.
LOG_DIR=/var/log
ROOT_UID=0 # Только пользователь с $UID 0 имеет привилегии root.
LINES=50 # Количество сохраняемых строк по-умолчанию.
E_XCD=66 # Невозможно сменить каталог?
E_NOTROOT=67 # Признак отсутствия root-привилегий.

if [ "$UID" -ne "$ROOT_UID" ]; then 
 echo "Для работы сценария требуются права root." 
exit $E_NOTROOT
fi

if [ -n "$1" ]; then 
# Проверка наличия аргумента командной строки
 lines=$1
else lines=$LINES # Значение по-умолчанию, если число не задано в командной строке
fi

# Stephane Chazelas предложил следующее,
#+ для проверки корректности аргумента, переданного из командной строки,
#+ правда это достаточно сложно для данного руководства.
#
# E_WRONGARGS=65 # Не числовой аргумент
#
# case "$1" in
# "" ) lines=50;;
# *[!0-9]*) echo "Usage: `basename $0` file-to-cleanup"; exit $E_WRONGARGS;;
# * ) lines=$1;;
# esac
#
#* Конец проверки корректности аргумента

cd $LOG_DIR
if [ `pwd` != "$LOG_DIR" ]; then 
# или if [ "$PWD" != "$LOG_DIR" ]
# не в /var/log?
 echo "Невозможно перейти в каталог $LOG_DIR." 
exit $E_XCD
fi # Проверка каталога перед очисткой лог-файлов.
# более эффективный вариант:
#
# cd /var/log || {
# echo "Невозможно перейти в требуемый каталог." >&2# exit $E_XCD;
# }

tail -$lines messages > mesg.temp # Сохранить последние строки в лог-файле.
mv mesg.temp messages
# cat /dev/null > messages
#* Необходимость этой команды отпала, поскольку очистка выполняется выше.
cat /dev/null > wtmp # команды ': > wtmp' и '> wtmp' имеют тот же эффект.
echo "Лог-файлы очищены."
exit 0 # Возвращаемое значение 0
#+ указывает на успешное завершение работы сценария.
</source>
<br />
Если вы не желаете полностью вычищать системные логи, то выше представлена улучшенная версия предыдущего сценария. Здесь сохраняются последние несколько строк (по-умолчанию — 50).
Если файл сценария начинается с последовательности #!, которая в мире Unix называется '''''sha-bang''''', то это указывает системе какой интерпретатор следует использовать для исполнения сценария. Это двухбайтовая последовательность, или — специальный маркер, определяющий тип сценария, в данном случае — сценарий командной оболочки (см. man magic). Более точно, '''''sha-bang''''' определяет интерпретатор, который вызывается для исполнения сценария, это может быть командная оболочка(shell), иной интерпретатор или утилита:
 #!/bin/bash
 #!/usr/bin/perl
 #!/usr/bin/tcl
 #!/bin/sed -f
 #!/usr/awk -f
<br />
Каждая, из приведенных выше сигнатур, приводит к вызову различных интерпретаторов, будь то /bin/sh — командный интерпретатор по-умолчанию (bash для Linux-систем), либо иной. При переносе сценариев с сигнатурой '''''#!/bin/sh''''' на другие Unix системы, где в качестве командного интерпретатора задан другой shell, вы можете лишиться некоторых особенностей, присущих bash. Поэтому такие сценарии должны быть POSIX совместимыми.
<br />
Обратите внимание на то, что сигнатура должна указывать правильный путь к интерпретатору, впротивном случае вы получите сообщение об ошибке -- как правило это "Command not found".
Сигнатура '''''#!''''' может быть опущена, если вы не используете специфичных команд. Во втором примере(см. выше) использование сигнатуры #! обязательно, поскольку сценарий использует специфичную конструкцию присваивания значения переменной '''lines=50'''. Ещё раз замечу, что сигнатура '''''#!/bin/sh''''' вызывает командный интерпретатор по-умолчанию — /bin/bash в Linux-системах.
<br />
В данном руководстве приветствуется модульный подход к построению сценариев. Записывайте, собирайте свою коллекцию участков кода, который может вам встретиться. В конечном итоге вы соберете свою "библиотеку" подпрограмм, которые затем сможете использовать при написании своих сценариев. Например, следующий отрывок сценария проверяет количество аргументов в командной строке:
<source lang="bash">
if [ $# -ne Number_of_expected_args ]; then 
 echo "Usage: `basename $0` whatever" 
 exit $WRONG_ARGS
fi
</source>
=== Запуск сценария ===
Запустить сценарий можно командой '''''sh scriptname''''' или '''''bash scriptname'''''. (Не рекомендуется запуск сценария командой '''sh < scriptname''', поскольку это запрещает использование устройства стандартного ввода '''stdin''' в скрипте). Более удобный вариант — сделать файл скрипта исполняемым, командой [[chmod]].
<br />Это:
 <source lang="bash">chmod 555 scriptname (выдача прав на чтение/исполнение любому пользователю в системе)</source>
или
<br />
 <source lang="bash">chmod +rx scriptname (выдача прав на чтение/исполнение любому пользователю в системе)</source>
 <source lang="bash">chmod u+rx scriptname (выдача прав на чтение/исполнение только "владельцу" скрипта)</source>
<br />
После того, как вы сделаете файл сценария исполняемым, вы можете запустить его примерно такой командой ./scriptname.
Если, при этом, текст сценария начинается с корректной сигнатуры ('''''"sha-bang"'''''), то для его исполнения будет вызван соответствующий интерпретатор.
<br />
И наконец, завершив отладку сценария, вы можете поместить его в каталог '''''/usr/local/bin'''''(естественно, что для этого вы должны обладать правами root), чтобы сделать его доступным для себя и других пользователей системы. После этого сценарий можно вызвать, просто напечатав название файла в командной строке и нажав клавишу '''[ENTER]'''.
=== Упражнения ===
1) Системные администраторы часто создают скрипты для автоматизации своего труда. Подумайте, для выполнения каких задач могут быть написаны сценарии.
<br />
2) Напишите сценарий, который выводит '''''дату''''', '''''время''''', '''''список зарегистрировавшихся пользователей''''', и '''''uptime системы''''' и сохраняет эту информацию в системном журнале.

= Часть вторая. Основы =
== Служебные символы ==
Служебные символы, используемые в текстах сценариев:
<br />
* <big>'''''#'''''</big> — <span style="color:blue">Комментарии</span>. 
<br />Строки, начинающиеся с символа # (за исключением комбинации #!) являются комментариями.
<source lang="bash">
# Эта строка — комментарий.
</source>
Комментарии могут располагаться и в конце строки с исполняемым кодом.
<br />
<source lang="bash">
echo "Далее следует комментарий." # Это комментарий.
</source>
Комментариям могут предшествовать пробелы (пробел, табуляция).
<br />
<source lang="bash">
# Перед комментарием стоит символ табуляции.
</source>
Исполняемые команды не могут следовать за комментарием в той же самой строке. Пока что еще не существует способа отделения комментария от "исполняемого кода", следующего за комментарием в той же строке.
<br />
Само собой разумеется, экранированный символ '''''#''''' в операторе [[echo]] не воспринимается как начало комментария. Более того, он может использоваться в операциях подстановки параметров и в константных числовых выражениях.
 echo "Символ # <span style="color:green">не означает начало комментария.</span>"
 echo 'Символ # <span style="color:green">не означает начало комментария.</span>'
 echo Символ \# <span style="color:green">не означает начало комментария.</span>
 echo А здесь символ # <span style="color:gray">''означает начало комментария.''</span>
 echo ${PATH#*:} # Подстановка — не комментарий.
 echo $(( 2#101011 )) # База системы счисления — не комментарий.

Двойные кавычки('''''"'''''), одинарная кавычка(<nowiki>'</nowiki>) и символ обратного "слеша"('''''\''''') экранируют действие символа '''''#'''''.
В операциях поиска по шаблону символ '''''#''''' так же не воспринимается как начало комментария.
<br />
* <big>''''';'''''</big> — <span style="color:blue">Разделитель команд. '''''[Точка-с-запятой]'''''</span> 
Позволяет записывать две и более команд в одной строке.
<source lang="bash">
echo hello; echo there 
if [ -x "$filename" ]; then # Обратите внимание: "if" И "then" разделены точкой с запятой. 
# Почему? 
echo "Файл $filename найден."; cp $filename $filename.bak
  else echo "Файл $filename не найден."; touch $filename
fi; 
echo "Конец."
</source>
Следует отметить, что символ <big>''''';'''''</big> иногда так же как и <big>'''''#'''''</big> необходимо экранировать.
<br />
* <big>''''';;'''''</big> — <span style="color:blue">Ограничитель в операторе выбора case. '''''[Двойная-точка-с-запятой]'''''</span>
<source lang="bash">
case "$variable" 
in 
abc) echo "$variable = abc" ;;
xyz) echo "$variable = xyz" ;;
esac
</source>
* <big>'''''.'''''</big> — <span style="color:blue">Команда "точка"('''''.''''')</span>
Эквивалент команды '''''source'''''. Это встроенная команда '''''bash'''''. "точка" может являться частью имени файла. Если имя файла начинается с точки, то это "скрытый" файл, т.е. команда [[Ls_—_Команда_печати_содержимого_каталога|ls]] при обычных условиях его не отображает:
[[File:Ls hidden.PNG|center|650px]]
<br />Если подразумевается имя каталога, то одна точка означает текущий каталог и две точки — каталог уровнем выше или родительский каталог:
[[File:Parent dir.PNG|center|400px]]
Символ <big>'''''.'''''</big> ("точка") довольно часто используется для обозначения каталога назначения в операциях копирования/перемещения файлов.
<source lang="bash">
bash$ cp /home/bozo/current_work/junk/* .
</source>
Символ <big>'''''.'''''</big> ("точка") в операциях поиска. При выполнении поиска по шаблону, в регулярных выражениях, символ <big>'''''.'''''</big> ("точка") обозначает одиночный символ.
* <big>'''''"'''''</big> — <span style="color:blue">Двойные кавычки('''''"''''')</span>
В строке "STRING", ограниченной двойными кавычками не выполняется интерпретация большинства служебных символов, которые могут находиться в строке.
* <big>'</big> — <span style="color:blue">Одинарные кавычки(')</span>
Одинарные кавычки  'STRING' экранируют все служебные символы в строке STRING. Это более строгая форма экранирования.
* <big>''''','''''</big> — <span style="color:blue">Запятая(''''',''''')</span>
Оператор запятая(<big>''''','''''</big>) используется для вычисления серии арифметических выражений. Вычисляются все выражения, но возвращается результат последнего выражения.
<source lang="bash">
let "t2 = ((a = 9, 15 / 3))" # Присваивает значение переменной "a" и вычисляет "t2".
</source>
* <big>'''''\'''''</big> — <span style="color:blue">Обратный слэш('''''\''''')</span>
Комбинация \X "экранирует" символ X. Аналогичный эффект имеет комбинация с "одинарными кавычками", т.е. 'X'. Символ \ может использоваться для экранирования кавычек " и '.
* <big>'''''/'''''</big> — <span style="color:blue">Слэш('''''/''''')</span>
Разделитель, используемый в указании пути к каталогам и файлам. Слэш отделяет элементы пути к каталогам и файлам (например, /home/bozo/projects/Makefile).
В арифметических операциях — это оператор деления.
* <big>'''''`'''''</big> — <span style="color:blue">Обратная кавычка('''''`''''')</span>
С помощью символа обратной кавычки(<big>'''''`'''''</big>) осуществляется подстановка команд. Обратные кавычки могут использоваться для записи в переменную команды '''''`command`'''''.
* <big>''''':'''''</big> — <span style="color:blue">Двоеточие(''''':''''')</span>
Пустая команда. Это эквивалент операции "NOP" (no op, нет операции). Может рассматриваться как синоним встроенной команды true. Команда ":" так же является встроенной командой Bash, которая всегда возвращает "true" (0).
<source lang="bash">
:
echo $? # 0
</source>
Бесконечный цикл:
<source lang="bash">
while :
do 
operation-1 
operation-2 
... 
operation-n
done
# То же самое:
# while true
# do
# ...
# done
</source>
Символ-заполнитель в условном операторе if/then:
<source lang="bash">
if condition
then : # Никаких действий не производится и управление передаётся дальше
else 
 take-some-action
fi
</source>
Как символ-заполнитель в операциях, которые предполагают наличие двух операндов:
<source lang="bash">
: ${username=`whoami`}
# ${username=`whoami`} без символа : выдает сообщение об ошибке,
# если "username" не является командой...
</source>
Как символ-заполнитель для оператора вложенного документа.
В операциях с подстановкой параметров:
<source lang="bash">
: ${HOSTNAME?} ${USER?} ${MAIL?}
#Вывод сообщения об ошибке, если одна или более переменных не определены.
</source>
В операциях замены подстроки с подстановкой значений переменных.
В комбинации с оператором > (оператор перенаправления вывода), усекает длину файла до нуля. Если указан несуществующий файл — то он создаётся.
<source lang="bash">
: > data.xxx # Файл "data.xxx" — пуст
# Тот же эффект имеет команда cat /dev/null >data.xxx
# Однако в данном случае не производится создание нового процесса, поскольку ":" является встроенной командой.
</source>
В комбинации с оператором '''''>>''''' — если задано имя существующего файла, то эта комбинация на него никак не влияет (''''': >> target_file'''''). Если задано имя несуществующего файла, то он создаётся.
Вышеизложенное применимо только к обычным файлам и неприменимо к конвейерам, символическим ссылкам и другим специальным файлам. Символ <big>:</big> может использоваться для создания комментариев, хотя и не рекомендуется. Если строка комментария начинается с символа <big>'''''#'''''</big>, то такая строка не проверяется интерпретатором на наличие ошибок. Однако в случае оператора <big>''''':'''''</big> это не так.
<source lang="bash">
: Это комментарий, который генерирует сообщение об ошибке, ( if [ $x -eq 3] ).
</source>
Символ <big>''''':'''''</big> может использоваться как разделитель полей в /etc/passwd и переменной $PATH.
<source lang="bash">
bash$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/sbin:/usr/sbin:/usr/games
</source>
* <big>'''''!'''''</big> — <span style="color:blue">Восклицательный знак('''''!''''')</span>
Инверсия (или логическое отрицание) используемое в условных операторах.
Оператор <big>'''''!'''''</big> инвертирует код завершения команды, к которой он применен. Также используется для логического отрицания в операциях сравнения, например, операция сравнения "равно"(=), при использовании оператора отрицания, преобразуется в операцию сравнения — "не равно" ( != ). Символ <big>'''''!'''''</big> является зарезервированным ключевым словом BASH. В некоторых случаях символ <big>'''''!'''''</big> используется для косвенного обращения к переменным.
Кроме того, из командной строки оператор <big>'''''!'''''</big> запускает механизм историй Bash. Примечательно, что этот механизм недоступен из сценариев(т.е. исключительно из командной строки).
* <big>'''''*'''''</big> — <span style="color:blue">Символ "звёздочка"('''''*''''')</span>
Символ <big>'''''*'''''</big> ("звёздочка") служит "шаблоном" для подстановки в имена файлов. Одиночный символ <big>'''''*'''''</big> означает любое имя файла в заданном каталоге.
<source lang="bash">
bash$ echo *
abs-book.sgml add-drive.sh agram.sh alias.sh
</source>
В регулярных выражениях токен <big>'''''*'''''</big> представляет любое количество (в том числе и 0) символов. В арифметических выражениях символ <big>'''''*'''''</big> обозначает операцию умножения. Двойная звёздочка (два символа звёздочки, следующих подряд друг за другом — <big>'''''**'''''</big>),обозначает операцию возведения в степень.
* <big>'''''?'''''</big> — <span style="color:blue">Вопросительный знак('''''?''''')</span>
Оператор проверки условия. В некоторых выражениях символ <big>'''''?'''''</big> служит для проверки выполнения условия. В конструкциях с двойными скобками, символ <big>'''''?'''''</big> подобен трёхместному оператору языка C. В выражениях с подстановкой параметра, символ <big>'''''?'''''</big> проверяет — установлена ли переменная.
Символ <big>'''''?'''''</big> обозначает одиночный символ при подстановке в имена файлов. В регулярных выражениях служит для обозначения одиночного символа.
* <big>'''''$'''''</big> — <span style="color:blue">Символ доллара('''''$''''')</span>
Символ <big>'''''$'''''</big> предшествующий имени переменной, указывает на то, что будет получено значение переменной:
<source lang="bash">
var1=5
var2=23skidoo
echo $var1 # 5
echo $var2 # 23skidoo
</source>
В регулярных выражениях, символ  <big>'''''$'''''</big> обозначает конец строки.
<big>'''''${ }'''''</big> — подстановка параметра.
<big>'''''$*'''''</big>,<big>'''''$@'''''</big> — параметры командной строки.
<big>'''''$?'''''</big> — Переменная "$?" хранит код завершения последней выполненной команды, функции или сценария.
<big>'''''$$'''''</big> — Переменная "$$" хранит id процесса сценария.
* <big>'''''( )'''''</big> — <span style="color:blue">Круглые скобки('''''()''''')</span>
Команды, заключённые в круглые скобки (<big>'''''( )'''''</big>) исполняются в дочернем процессе — subshell.
<source lang="bash">
(a=hello; echo $a)
</source>
Переменные, создаваемые в дочернем процессе не видны в "родительском" сценарии. Родительский процесс-сценарий, не может обращаться к переменным, создаваемым в дочернем процессе.
<source lang="bash">
a=123
( a=321; )
echo "a = $a" # a = 123
#Переменная "a" в скобках подобна локальной переменной.
</source>
Круглые скобки (<big>'''''()'''''</big>) также используются для инициализации массивов:
<source lang="bash">
Array=(element1 element2 element3)
</source>
<big>'''''(( ))'''''</big> — двойные круглые скобки.Вычисляется целочисленное выражение, заключенное между двойными круглыми скобками <big>'''''(( ))'''''</big>.
* <big>'''''{}'''''</big> — <span style="color:blue">Фигурные скобки('''''{}''''')</span>
Команда интерпретируется как список команд, разделённых точкой с запятой, с вариациями, представленными в фигурных скобках. При интерпретации имён файлов (подстановка) используются параметры, заключённые в фигурные скобки. 
<source lang="bash">
grep Linux file*.{txt,htm*}# Поиск всех вхождений слова "Linux"
# в файлах "fileA.txt", "file2.txt", "fileR.html", "file-87.htm", и пр.
</source>
Использование ''неэкранированных'' или ''неокавыченных'' пробелов внутри фигурных скобок недопустимо!
<source lang="bash">
echo {file1,file2}\ :{\ A," B",' C'}
file1 : A file1 : B file1 : C file2 : A file2 : B file2 : C
</source>
<big>'''''{}'''''</big> — Известен так же как "вложенный блок", эта конструкция, фактически, создаёт анонимную функцию. Однако, в отличии от обычных функций, переменные, создаваемые во вложенных блоках кода, доступны объемлющему сценарию.
<source lang="bash">
bash$ { local a; a=123; }
bash: local: can only be used in a function
</source>
<source lang="bash">
a=123
{ a=321; }
echo "a = $a"
# a = 321 (значение, присвоенное во вложенном блоке кода)
</source>
Код, заключенный в фигурные скобки, может выполнять перенаправление ввода-вывода.

<p style="text-align:center"><span style="color:green"> '''Пример.'''</span>: <span style="color:red">'''''Вложенные блоки и перенаправление ввода-вывода.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Чтение строк из файла /etc/fstab.
File=/etc/fstab
{read line1
read line2
} < $File
echo "Первая строка в $File :"
echo "$line1"
echo
echo "Вторая строка в $File :"
echo "$line2"
exit 0
</source>
<p style="text-align:center"><span style="color:green"> '''Пример.'''</span>: <span style="color:red">'''''Сохранение результата исполнения вложенного блока в файл'''''</span></p>
<source lang="bash">
#!/bin/bash
# rpm-check.sh
# Запрашивает описание rpm-архива, список файлов, и проверяется возможность установки.
# Результат сохраняется в файле.
#
# Этот сценарий иллюстрирует порядок работы со вложенными блоками кода.
SUCCESS=0
E_NOARGS=65
if [ -z "$1" ]; then
 echo "Порядок использования: `basename $0` rpm-file" 
 exit $E_NOARGS
fi
{
   echo 
   echo "Описание архива:" 
   rpm -qpi $1 # Запрос описания.
   echo
   echo "Список файлов:"
   rpm -qpl $1 # Запрос списка.
   echo
   rpm -i --test $1 # Проверка возможности установки.
   if [ "$?" -eq $SUCCESS ]; then
      echo "$1 может быть установлен."
   else
      echo "$1 — установка невозможна!"
   fi
   echo
}> "$1.test" # Перенаправление вывода в файл.
echo "Результаты проверки rpm-архива находятся в файле $1.test"
# За дополнительной информацией по ключам команды rpm см. man rpm.
exit 0
</source>
В отличие от групп команд в (круглых скобках), описаных выше, вложенные блоки кода, заключённые в {фигурные скобки} исполняются в пределах того же процесса, что и сам скрипт (т.е. не вызывают запуск дочернего процесса — subshell)!
<br />
<big>'''''{ } \;'''''</big> — ''pathname'', полное имя файла (т.е. путь к файлу и его имя). Чаще всего используется совместно с командой [[find]].
Обратите внимание на то, что символ <big>''''';'''''</big> , которым завершается ключ ''-exec'' команды [[find]], экранируется обратным слэшем. Это необходимо, чтобы предотвратить его интерпретацию.
* <big>'''''[ ]'''''</big> — <span style="color:blue">Квадратные скобки('''''[ ]''''')</span>
Проверка истинности выражения, заключенного в квадратные скобки <big>'''''[ ]'''''</big>. Примечательно, что <big>'''''['''''</big> является частью встроенной команды ''test'' (и её синонимом), и не имеет никакого отношения к "внешней" утилите /usr/bin/test.
<br />
<big>'''''[[ ]]'''''</big> — Проверка истинности выражения, заключенного между '''[[ ]]''' (зарезервированное слово интерпретатора).
<br />
<big>'''''[ ]'''''</big> — Элемент массива. При работе с массивами в квадратных скобках указывается порядковый номер того элемента массива, к которому производится обращение.
<source lang="bash">
Array[1]=slot_1
echo ${Array[1]}
</source>
<big>'''''[ ]'''''</big> — диапазон символов. В регулярных выражениях, в квадратных скобках задаётся диапазон искомых символов.
* <big>'''''>'''''</big>, <big>'''''&>'''''</big>, <big>'''''>&'''''</big>, <big>'''''>>'''''</big>, <big>'''''<'''''</big> — Перенаправление.
<br />Конструкция <big>''scriptname''</big> '''''>''''' <big>''filename''</big> перенаправляет вывод '''scriptname''' в файл '''filename'''. Если файл '''filename''' уже существовал, то его прежнее содержимое будет утеряно.
<br />Конструкция <big>''command''</big> '''''&>''''' <big>''filename''</big> перенаправляет вывод команды '''command''', как с ''stdout'', так и с ''stderr'', в файл '''filename'''.
<br />Конструкция <big>''command''</big> '''''>&2''''' перенаправляет вывод с ''stdout'' на ''stderr''.
<br />Конструкция <big>''scriptname''</big> '''''>>''''' <big>''filename''</big> добавляет вывод '''scriptname''' к файлу '''filename'''. Если задано имя несуществующего файла, то он создаётся.
<big>'''''<<'''''</big> — Перенаправление ввода на встроенный документ.
<br />
<big>'''''(command)>'''''</big>, <big>'''''<(command)'''''</big> — Подстановка процесса.
В операциях сравнения, символы "<" и ">" обозначают операции сравнения строк. А так же операции сравнения целых чисел.
<big>'''''<'''''</big>, <big>'''''>'''''</big> — Посимвольное ASCII-сравнение.
<source lang="bash">
veg1=carrots
veg2=tomatoes
if [[ "$veg1" < "$veg2" ]]; then
 echo "Не смотря на то, что в словаре слово $veg1 предшествует слову $veg2,"
 echo "это никак не отражает мои кулинарные предпочтения."
else
 echo "Интересно. Каким словарем вы пользуетесь?"
fi
</source>
<big>'''''\<'''''</big>,<big>'''''\>'''''</big> — границы отдельных слов в регулярных выражениях.
<source lang="bash">
bash$ grep '\<the\>' textfile
</source>
* <big>'''''|'''''</big> — Конвейер(pipe).
Передает вывод предыдущей команды на ввод следующей или на вход командного интерпретатора shell. Этот метод часто используется для связывания последовательности команд в единую цепочку.
<source lang="bash">
echo ls -l | sh
# Передаёт вывод "echo ls -l" командному интерпретатору shell,
# тот же результат даёт простая команда "ls -l".
cat *.lst | sort | uniq
# Объединяет все файлы ".lst", сортирует содержимое и удаляет повторяющиеся строки.
</source>
{| class="wikitable"
|-
| Конвейеры (еще их называют каналами) — это классический способ взаимодействия процессов, с помощью которого ''stdout'' одного процесса перенаправляется на ''stdin'' другого. Обычно используется совместно с командами вывода, такими как [[cat]] или [[echo]], от которых поток данных поступает в "фильтр" (команда, которая на входе получает данные, преобразует их и обрабатывает).
<source lang="bash">cat $filename | grep $search_word</source>
|}
В конвейер могут объединяться и сценарии на языке командной оболочки.
<source lang="bash">
#!/bin/bash
# uppercase.sh : Преобразование вводимых символов в верхний регистр.
tr 'a-z' 'A-Z'
# Диапазоны символов должны быть заключены в кавычки
# чтобы предотвратить порождение имен файлов от однобуквенных имен файлов.
exit 0
</source>
А теперь попробуем объединить в конвейер команду [[Ls_—_Команда_печати_содержимого_каталога|ls -l]] с этим сценарием:
[[File:Uppercase_0.PNG|center|600px]]
Выход ''stdout'' каждого процесса в конвейере должен читаться на входе ''stdin'' последующим, в конвейере, процессом. Если этого не делается, то поток данных блокируется, в результате конвейер будет работать не так как ожидается!
<source lang="bash">
cat file1 file2 | ls -l | sort # Вывод команды "cat file1 file2" будет утерян.
</source>
Конвейер исполняется в дочернем процессе, а посему — не имеет доступа к переменным сценария.
<source lang="bash">
variable="initial_value"
echo "new_value" | read variable 
echo "variable = $variable" # variable = initial_value
</source>
Если одна из команд в конвейере завершается аварийно, то это приводит каварийному завершению работы всего конвейера!
<br />
<big>'''''>|'''''</big> — принудительное перенаправление, даже если установлен ключ ''noclobber option''.
* <big>'''''||'''''</big> — <span style="color:blue"> логическая операция OR(логическое ИЛИ).</span>
В опрециях проверки условий, оператор <big>'''''||'''''</big> возвращает 0 ('''success'''), если один из операндов имеет значение ''true'' (ИСТИНА).
* <big>'''''&'''''</big> — <span style="color:blue"> Амперсанд</span>
Выполнение задачи в фоне. Команда, за которой стоит <big>'''''&'''''</big>, будет исполняться в фоновом режиме.
<source lang="bash">
bash$ sleep 10 &
[1] 850
[1]+ Done    sleep 10
</source>
В сценариях команды, и даже циклы могут запускаться в фоновом режиме.
<p style="text-align:center"><span style="color:green"> '''Пример.'''</span>: <span style="color:red">'''''Запуск цикла в фоновом режиме'''''</span></p>
<source lang="bash">
#!/bin/bash
# background-loop.sh
for i in 1 2 3 4 5 6 7 8 9 10 # Первый цикл.
do
 echo -n "$i "
done & # Запуск цикла в фоне.
       # Иногда возможны случаи выполнения этого цикла после второго цикла.
echo # Этот 'echo' иногда не отображается на экране.
for i in 11 12 13 14 15 16 17 18 19 20 # Второй цикл.
do
 echo -n "$i "
done
echo # Этот 'echo' иногда не отображается на экране.
# ======================================================
# Ожидается, что данный сценарий выведет следующую последовательность:
# 1 2 3 4 5 6 7 8 9 10
# 11 12 13 14 15 16 17 18 19 20
# Иногда возможен такой вариант:
# 11 12 13 14 15 16 17 18 19 20
# 1 2 3 4 5 6 7 8 9 10 bozo $
# (Второй 'echo' не был выполнен. Почему?)
# Изредка возможен такой вариант:
# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# (Первый 'echo' не был выполнен. Почему?)
# Крайне редко встречается и такое:
# 11 12 13 1 2 3 4 5 6 7 8 9 10 14 15 16 17 18 19 20
# Второй цикл начал исполняться раньше первого.
exit 0
</source>
Команда, исполняемая в пределах сценария в фоне, может подвесить сценарий, ожидая нажатия клавиши. К счастью, это легко "лечится".
* <big>'''''&&'''''</big> — <span style="color:blue"> логическая операция ''AND'' (логическое И).</span>
В операциях проверки условий, оператор <big>'''''&&'''''</big> возвращает 0 ('''success''') тогда, и только тогда, когда оба операнда имеют значение ''true''(ИСТИНА).
* <big>'''''-'''''</big> — <span style="color:blue"> Знак дефиса (''-'')</span>
Префикс ключа. С этого символа начинаются опциональные ключи команд:
<source lang="bash">
COMMAND -[Option1][Option2][...]
ls -al
sort -dfu $filename
set -- $variable

if [ $file1 -ot $file2 ];then
 echo "Файл $file1 был создан раньше чем $file2."
fi
if [ "$a" -eq "$b" ]; then
 echo "$a равно $b."
fi
if [ "$c" -eq 24 -a "$d" -eq 47 ]; then
 echo "$c равно 24, а $d равно 47."
fi
</source>
<big>'''''-'''''</big> — перенаправление из/в ''stdin'' или ''stdout''.
<source lang="bash">
(cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)
# Перемещение полного дерева файлов и подкаталогов из одной директории в другую
# спасибо Алану Коксу (Alan Cox) <a.cox@swansea.ac.uk>, за небольшие поправки
# 1) cd /source/directory Переход в исходный каталог, содержимое которого будет перемещено
# 2) && "И-список": благодаря этому все последующие команды будут выполнены
# только тогда, когда 'cd' завершится успешно
# 3) tar cf - . ключом 'c' архиватор 'tar' создает новый архив,
# ключом 'f' (file) и последующим '-' задается файл архива -- stdout,
# в архив помещается текущий каталог ('.') с вложенными подкаталогами.
# 4) | конвейер с ...
# 5) ( ... ) subshell-ом (дочерним экземпляром командной оболочки)
# 6) cd /dest/directory Переход в каталог назначения.
# 7) && "И-список", см. выше
# 8) tar xpvf - Разархивирование ('x'), с сохранением атрибутов "владельца" и прав доступа ('p') к файлам,
# с выдачей более подробных сообщений на stdout ('v'),
# файл архива -- stdin ('f' с последующим '-').
#
# Примечательно, что 'x' -- это команда, а 'p', 'v' и 'f' -- ключи
# Во как!
# Более элегантный вариант:
# cd source-directory
# tar cf - . | (cd ../target-directory; tar xzf -)
#
#cp -a /source/directory /dest имеет тот же эффект.

bunzip2 linux-2.4.3.tar.bz2 | tar xvf -
# --разархивирование tar-файла-- | --затем файл передается утилите "tar"--
# Если у вас утилита "tar" не поддерживает работу с "bunzip2",
# тогда придется выполнять работу в два этапа, с использованием конвейера.
# Целью данного примера является разархивирование тарбола (tar.bz2) с исходными текстами ядра.
</source>
Обратите внимание, что в этом контексте <big>'''''-'''''</big> - не самостоятельный оператор Bash, а скорее опция, распознаваемая некоторыми утилитами Unix (такими как [[tar]], [[cat]] и т.п.), которые выводят результаты своей работы в ''stdout''.
<source lang="bash">
bash$ echo "whatever" | cat -
whatever
</source>
В случае, когда ожидается имя файла, тогда <big>'''''-'''''</big> перенаправляет вывод на ''stdout'' (вспомните пример с [[Tar|tar cf]]) или принимает ввод с ''stdin''.
<source lang="bash">
bash$ file
Usage: file [-bciknvzL] [-f namefile] [-m magicfiles] file...
</source>
Сама по себе команда [[file]] без параметров завершается с сообщением об ошибке.
Добавим символ <big>'''''-'''''</big> и получим более полезный результат. Это заставит командный интерпретатор ожидать ввода от пользователя.
<source lang="bash">
bash$ file -
abc
standard input:  ASCII text
bash$ file -
#!/bin/bash
standard input:   Bourne-Again shell script text executable
</source>
Теперь команда принимает ввод пользователя со ''stdin'' и анализирует его.
Используя передачу ''stdout'' по конвейеру другим командам, можно выполнять довольно эффектные трюки, например вставка строк в начало файла.
С помощью команды [[diff]] — находить различия между одним файлом и частью другого:
<source lang="bash"> grep Linux file1 | diff file2 -</source>
И наконец пример использования служебного символа <big>'''''-'''''</big> с командой [[tar]].
<p style="text-align:center"><span style="color:green"> '''Пример.'''</span>: <span style="color:red">'''''Резервное архивирование всех файлов, которые были изменены втечение последних суток'''''</span></p>
<source lang="bash">
#!/bin/bash
# Резервное архивирование (backup) всех файлов в текущем каталоге,
# которые были изменены в течение последних 24 часов
# в тарболл (tarball) (.tar.gz - файл).
BACKUPFILE=backup
archive=${1:-$BACKUPFILE}
# На случай, если имя архива в командной строке не задано,
# т.е. по-умолчанию имя архива -- "backup.tar.gz"
tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
gzip $archive.tar
echo "Каталог $PWD заархивирован в файл \"$archive.tar.gz\"."
# Stephane Chazelas заметил, что вышеприведенный код будет "падать"
# если будет найдено слишком много файлов
# или если имена файлов будут содержать символы пробела.
# Им предложен альтернативный код:
# -------------------------------------------------------------------
# find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"
# используется версия GNU утилиты "find".
# find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
# более универсальный вариант, хотя и более медленный,
# зато может использоваться в других версиях UNIX.
# -------------------------------------------------------------------
exit 0
</source>
<br />Могут возникнуть конфликтные ситуации между опреатором перенаправления <big>'''''-'''''</big>  и именами файлов, начинающимися с символа "-". Поэтому сценарий должен проверять имена файлов и предварять их префиксом пути, например, ''./-FILENAME'', ''$PWD/-FILENAME'' или ''$PATHNAME/-FILENAME''.
Если значение переменной начинается с символа "-", то это тоже может быть причиной появления ошибок.
<source lang="bash">
var="-n"
echo $var
# В данном случае команда приобретет вид "echo -n" и ничего не выведет.
</source>
<big>'''''-'''''</big> — предыдущий рабочий каталог. Команда cd - выполнит переход в предыдущий рабочий каталог, путь к которому хранится в переменной окружения $OLDPWD.
Не путайте оператор "-" (предыдущего рабочего каталога) с оператором <big>'''''-'''''</big> (переназначения). Ещё раз напомню, что интерпретация символа "-" зависит от контекста, в котором он употребляется.
<big>'''''-'''''</big> — Знак минус в арифметических операциях.
* <big>'''''='''''</big> — <span style="color:blue"> Символ равно ('''''=''''').</span>
Символ равно (<big>'''''='''''</big>) выступает в качестве оператора присваивания.
<source lang="bash">
a=28
echo $a # 28
</source>
В зависимости от контекста применения, символ <big>'''''='''''</big> может выступать в качестве оператора сравнения.
* <big>'''''+'''''</big> — <span style="color:blue"> Символ плюс ('''''+''''').</span>
Символ плюс (<big>'''''+'''''</big>) выступает в качестве оператора сложения в арифметических операциях. В зависимости от контекста применения, символ <big>'''''+'''''</big> может выступать как оператор регулярного выражения.
<big>'''''+'''''</big> -  Ключ (опция). Дополнительный флаг для ключей (опций) команд. Отдельные внешние и встроенные команды используют символ "+" для разрешения некоторой опции, а символ "-" — для запрещения.
* <big>'''''%'''''</big> — <span style="color:blue"> Символ процента ('''''%''''').</span>
Модуль (остаток от деления) — арифметическая операция. В зависимости от контекста применения, символ  <big>'''''%'''''</big> может выступать в качестве шаблона.
* <big>'''''~'''''</big> — <span style="color:blue"> Символ тильда ('''''~''''').</span>
Соответствует содержимому внутренней переменной $HOME. ~bozo — домашний каталог пользователя bozo, а команда [[Ls_—_Команда_печати_содержимого_каталога|ls ~bozo]] выведет содержимое его домашнего каталога. '''~/''' — это домашний каталог текущего пользователя, а команда [[Ls_—_Команда_печати_содержимого_каталога|ls ~/]] выведет содержимое домашнего каталога текущего пользователя.
<source lang="bash">
bash$ echo ~bozo
/home/bozo
bash$ echo ~/home/bozo
bash$ echo ~/
/home/bozo/
bash$ echo ~:
/home/bozo:
bash$ echo ~nonexistent-user
~nonexistent-user
</source>
<big>'''''~+'''''</big> — текущий рабочий каталог. Соответствует содержимому внутренней переменной $PWD.
<br />
<big>'''''~-'''''</big> — предыдущий рабочий каталог. Соответствует содержимому внутренней переменной $OLDPWD.
* <big>'''''^'''''</big> — <span style="color:blue"> Символ карет ('''''^''''').</span>
Начало-строки. В регулярных выражениях символ "^" задает начало строки текста. Управляющий символ '''изменяет поведение терминала или управляет выводом текста'''. Управляющий символ набирается с клавиатуры как комбинация '''''CONTROL + <клавиша>'''''.
# '''''Ctrl-B''''' — Курсор — на одну позицию назад (без стирания символа).
# '''''Ctrl-C''''' — Прерывание выполнения процесса.
# '''''Ctrl-D''''' —  Выход из командного интерпретатора (log out) (аналог команды [[exit]])."EOF" (признак конца файла). Этот символ может выступать в качестве завершающего привводе с ''stdin''.
# '''''Ctrl-G''''' — "BEL" (звуковой сигнал -- "звонок").
# '''''Ctrl-H''''' — Backspace ("забой") — удаление предыдущего символа. 
# '''''Ctrl-I''''' — Горизонтальная табуляция.
# '''''Ctrl-J''''' — Перевод строки.
# '''''Ctrl-K''''' — Вертикальная табуляция.
# '''''Ctrl-L''''' — Перевод формата (очистка экрана (окна) терминала). Аналогична команде [[clear]].
# '''''Ctrl-M''''' — Возврат каретки.
# '''''Ctrl-Q''''' — Resume (XON). Эта комбинация "восстанавливает" работу ''stdin'' терминала.
# '''''Ctrl-S''''' — Suspend (XOFF). Эта комбинация "замораживает" ''stdin'' терминала. (Для восстановления "работоспособности" — используйте комбинацию '''''Ctrl-Q''''')
# '''''Ctrl-U''''' — Стирание строки ввода.
# '''''Ctrl-Z''''' — Приостановка процесса.
<source lang="bash">
#!/bin/bash
# Вставка символа Ctl-H в строку.
a="^H^H" # Два символа Ctl-H (backspace).
echo "abcdef"
# abcdef
echo -n "abcdef$a " 
# abcd f
# Пробел в конце ^ ^ двойной шаг назад.
echo -n "abcdef$a" # abcdef
# Пробела в конце нет, backspace не работает (почему?).
# Результаты могут получиться совсем не те, что вы ожидаете.
echo; echo
</source>

<source lang="bash">
 #!/bin/bash
 # Спасибо Lee Maschmeyer, за этот пример.
 read -n 1 -s -p $'Control-M — переводит курсор в начало этой же строки. Нажмите клавишу Enter. \x0d'
 # Разумеется, что, 'x0d' — это # шестнадцатиричный эквивалент  '''''Ctrl-M'''''.
 echo >&2 # Перевод строки 
 read -n 1 -s -p $'Control-J — переводит курсор в начало другой строки. \x0a'
 echo >&2 # Control-J — это перевод строки.
 read -n 1 -s -p $'А Control-K\x0b — вниз.'
 echo >&2 # Control-K — это вертикальная табуляция.
 exit 0
</source>
* <big>''''' '''''</big> — <span style="color:blue"> Символ пробела (''''' ''''').</span>
Пробельный символ используется как разделитель команд или переменных. В качестве пробельного символамогут выступать — собственно пробел (space), символ табуляции, символ перевода строки, символ возврата каретки или комбинация из вышеперечисленных символов. В некоторых случаях, таких как присваивание значений переменным, использование пробельных символов недопустимо. Пустые строки никак не обрабатываются командным интерпретатором и могут свободно использоваться для визуального выделения отдельных блоков сценария. '''''$IFS''''' — переменная специального назначения. Содержит символы-разделители полей, используемые некоторыми командами. По-умолчанию — пробельные символы.

== Переменные и параметры. Введение. ==
Переменные — это одна из основ любого языка программирования. Они участвуют в арифметических операциях, в синтаксическом анализе строк и совершенно необходимы для абстрагирования каких-либо величин с помощью символических имен. Физически переменные представляют собой ни что иное как участки памяти, в которые записана некоторая информация.
=== Подстановка переменных ===
Когда интерпретатор встречает в тексте сценария имя переменной, то он вместо него подставляет значение этой переменной. Поэтому ссылки на переменные называются подстановкой переменных.
* <big>'''''$'''''</big>
<br />
Необходимо всегда помнить о различиях между именем переменной и ее значением. Если variable1 — это имя переменной, то $variable1 — это ссылка на ее значение. "Чистые" имена переменных, без префикса $, могут использоваться только при объявлении переменной, при присваивании переменной некоторого значения, при удалении (сбросе), при экспорте и в особых случаях — когда переменная представляет собой название сигнала. Присваивание может производится с помощью символа = (например: var1=27), инструкцией read и в заголовке цикла (for var2 in 1 2 3).
<br />
Заключение ссылки на переменную в двойные кавычки (" ") никак не сказывается на работе механизма подстановки. Этот случай называется "частичные кавычки", иногда можно встретить название "нестрогие кавычки". Одиночные кавычки (' ') заставляют интерпретатор воспринимать ссылку на переменную как простой набор символов, потому в одинарных кавычках операции подстановки не производятся. Этот случай называется "полные", или "строгие" кавычки.
<br />
Примечательно, что написание $variable фактически является упрощенной формой написания ${variable}. Более строгая форма записи ${variable} может с успехом использоваться в тех случаях, когда применение упрощенной формы записи порождает сообщения о синтаксических ошибках.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Присваивание значений переменным и подстановка значений переменных.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Присваивание значений переменным и подстановка значений переменных
a=375
hello=$a
#-------------------------------------------------------------------------
# Использование пробельных символов
# с обеих сторон символа "=" присваивания недопустимо.
# Если записать "VARIABLE =value",
# то интерпретатор попытается выполнить команду "VARIABLE" с параметром "=value".
# Если записать "VARIABLE= value",
# то интерпретатор попытается установить переменную окружения "VARIABLE" в ""
# и выполнить команду "value".
#-------------------------------------------------------------------------
echo hello # Это не ссылка на переменную, выведет строку "hello".
echo $hello
echo ${hello} # Идентично предыдущей строке.
echo "$hello"
echo "${hello}"
echo
hello="A B  C  D"
echo $hello 
# A B C D
echo "$hello" # A B C D
# Здесь вы сможете наблюдать различия в выводе echo $hello и echo "$hello".
# Заключение ссылки на переменную в кавычки сохраняет пробельные символы.
echo
echo '$hello' # $hello
# Внутри одинарных кавычек не производится подстановка значений переменных,
# т.е. "$" интерпретируется как простой символ.
# Обратите внимание на различия, существующие между этими типами кавычек.
hello= # Запись пустого значения в переменную.
echo "\$hello (пустое значение) = $hello"
# Обратите внимание: запись пустого значения — это не то же самое,
# что сброс переменной, хотя конечный результат — тот же.
# --------------------------------------------------------------
# Допускается присваивание нескольких переменных в одной строке,
# если они отделены пробельными символами.
# Внимание! Это может снизить читабельность сценария и оказаться непереносимым.
var1=variable1 var2=variable2 var3=variable3
echo
echo "var1=$var1 var2=$var2 var3=$var3"
# Могут возникнуть проблемы с устаревшими версиями "sh".
# --------------------------------------------------------------
echo; echo
numbers="один два три"
other_numbers="1 2 3"
# Если в значениях переменных встречаются пробелы,
# то использование кавычек обязательно.
echo "numbers = $numbers"
echo "other_numbers = $other_numbers" # other_numbers = 1 2 3
echo
echo "uninitialized_variable = $uninitialized_variable"
# Неинициализированная переменная содержит "пустое" значение.
uninitialized_variable= # Объявление неинициализированной переменной (то же, что и присваивание пустого значения)
echo "uninitialized_variable = $uninitialized_variable" # Переменная содержит "пустое" значение.
uninitialized_variable=23 # Присваивание.
unset uninitialized_variable # Сброс.
echo "uninitialized_variable = $uninitialized_variable" # Переменная содержит "пустое" значение.
echo
exit 0
</source>
Неинициализированная переменная хранит "пустое" значение - не ноль! Использование неинициализированных переменных может приводить к ошибкам разного рода в процессе исполнения. Не смотря на это в арифметических операциях допускается использовать неинициализированные переменные.
<source lang="bash">
echo "$uninitialized" # (пустая строка)
let "uninitialized += 5" # Прибавить 5.
echo "$uninitialized" # 5
# Заключение:
# Неинициализированные переменные не имеют значения, однако
# в арифметических операциях за значение таких переменных принимается число 0.
# Это недокументированная (и возможно непереносимая) возможность.
</source>
=== Присваивание значений переменным ===
* <big>'''''='''''</big>
<br />
Оператор присваивания (пробельные символы до и после оператора — недопустимы).
Не путайте с операторами сравнения ''='' и ''-eq''!
Обратите внимание: символ <big>'''''='''''</big> может использоваться как в качестве оператора присваивания, так и в качестве оператора сравнения, конкретная интерпретация зависит от контекста применения.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Простое присваивание.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Явные переменные
echo
# Когда перед именем переменной не употребляется символ '$'?
# В операциях присваивания.
# Присваивание
a=879
echo "Значение переменной \"a\" — $a."
# Присваивание с помощью ключевого слова 'let'
let a=16+5
echo "Значение переменной \"a\" теперь стало равным: $a."
echo
# В заголовке цикла 'for' (своего рода неявное присваивание)
echo -n "Значения переменной \"a\" в цикле: "
for a in 7 8 9 11
do
 echo -n "$a "
done
echo
echo
# При использовании инструкции 'read' (тоже одна из разновидностей присваивания)
echo -n "Введите значение переменной \"a\" "
read a
echo "Значение переменной \"a\" теперь стало равным: $a."
echo
exit 0
</source>
<br />
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Присваивание значений переменным простое и замаскированное.'''''</span></p>
<source lang="bash">
#!/bin/bash
a=23 # Простейший случай
echo $a
b=$a
echo $b 
# Теперь немного более сложный вариант (подстановка команд).
a=`echo Hello!` # В переменную 'a' попадает результат работы команды 'echo'
echo $a
# Обратите внимание на восклицательный знак (!) в подстанавливаемой команде
# этот вариант не будет работать при наборе в командной строке,
# поскольку здесь используется механизм "истории команд" BASH
# Однако, в сценариях, механизм истории команд запрещен.
a=`ls -l` # В переменную 'a' записывается результат работы команды 'ls -l'
echo $a # Кавычки отсутствуют, удаляются лишние пробелы и пустые строки.
echo
echo "$a" # Переменная в кавычках, все пробелы и пустые строки сохраняются
exit 0
</source>
<br />
<source lang="bash">
# Взято из /etc/rc.d/rc.local
R=$(cat /etc/redhat-release)
arch=$(uname -m)
</source>

=== Переменные Bash не имеют типа ===
В отличие от большинства других языков программирования, Bash не производит разделения переменных по "типам". По сути, переменные Bash являются строковыми переменными, но, в зависимости от контекста, Bash допускает целочисленную арифметику с переменными. Определяющим фактором здесь служит содержимое переменных.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Целое число или строка?'''''</span></p>
<source lang="bash">
#!/bin/bash
# int-or-string.sh: Целое число или строка?
a=2334 # Целое число.
let "a += 1"
echo "a = $a " # a = 2335
echo # Всё ещё целое число.
b=${a/23/BB} # замена "23" на "BB".
# Происходит трансформация числа в строку.
echo "b = $b" 
# b = BB35
declare -i b # Явное указание типа здесь не поможет.
echo "b = $b" # b = BB35
let "b += 1" # BB35 + 1 =
echo "b = $b" # b = 1
echo
c=BB34
echo "c = $c" # c = BB34
d=${c/BB/23} # замена "BB" на "23". 
# Переменная $d становится целочисленной.
echo "d = $d" # d = 2334
let "d += 1" # 2334 + 1 =
echo "d = $d" # d = 2335echo
echo
# А что происходит с "пустыми" переменными?
e=""
echo "e = $e" # e =
let "e += 1" # Арифметические операции допускают использование "пустых" переменных?
echo "e = $e" # e = 1
echo # "Пустая" переменная становится целочисленной.
# А что происходит с необъявленными переменными?
echo "f = $f" # f =
let "f += 1" # Арифметические операции допустимы?
echo "f = $f" # f = 1
echo # Необъявленная переменная трансформируется в целочисленную.
# Переменные Bash не имеют типов.
exit 0
</source>
<br />
Отсутствие типов — это и благословение и проклятие. С одной стороны — отсутствие типов делает сценарии более гибкими(чтобы повеситься — достаточно иметь веревку!) и облегчает чтение кода. С другой — является источником потенциальных ошибок и поощряет привычку к "неряшливому" программированию.
Бремя отслеживания типа той или иной переменной полностью лежит на плечах программиста. Bash не будет делать это за вас!

=== Специальные типы переменных ===
* <big>'''''локальные переменные'''''</big>
Переменные, область видимости которых ограничена блоком кода или телом функции (см. также локальные переменные в функциях)
<br />
<br />
* <big>'''''переменные окружения'''''</big>
Переменные, которые затрагивают командную оболочку и порядок взаимодействия с пользователем.
 В более общем контексте, каждый процесс имеет некоторое "окружение" (среду исполнения), т.е. набор переменных, к которым процесс может 
 обращаться за получением определенной информации. В этом смысле командная оболочка подобна любому другому процессу.
Каждый раз, когда запускается командный интерпретатор, для него создаются переменные, соответствующие переменным окружения. Изменение переменных или добавление новых переменных окружения заставляет оболочку обновить свои переменные, и все дочерние процессы (и команды, исполняемые ею)наследуют это окружение.
 Пространство, выделяемое под переменные окружения, ограничено. Создание слишком большого количества переменных 
 окружения или одной переменной, которая занимает слишком большое пространство, может привести к возникновению определённых проблем.
<source lang="bash">
bash$ eval "`seq 10000 | sed -e 's/.*/export var&=ZZZZZZZZZZZZZZ/'`"
bash$ du
bash: /usr/bin/du: Argument list too long
</source>
Если сценарий изменяет переменные окружения, то они должны "экспортироваться", т.е. передаваться окружению, локальному по отношению к сценарию. Эта функция возложена на команду ''export''.
 Сценарий может экспортировать переменные только дочернему процессу, т.е.командам и процессам запускаемым из данного сценария. 
 Сценарий, запускаемый из командной строки '''''не может''''' экспортировать переменные "наверх" командной оболочке. Дочерний процесс не может 
 экспортировать переменные родительскому процессу.
* <big>'''''позиционные параметры'''''</big>
Аргументы, передаваемые скрипту из командной строки — $0, $1, $2, $3..., где $0 — это название файла сценария, $1 — это первый аргумент, $2 — второй, $3 — третий и так далее. Аргументы, следующие за $9, должны заключаться в фигурные скобки, например: ${10}, ${11}, ${12}.<br />
Специальные переменные '''''$*''''' и '''''$@''''' содержат все позиционные параметры (аргументы командной строки).
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Позиционные параметры.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Команда вызова сценария должна содержать по меньшей мере 10 параметров, например
# ./scriptname 1 2 3 4 5 6 7 8 9 10
MINPARAMS=10
echo
echo "Имя файла сценария: \"$0\"."
# Для текущего каталога добавит ./
echo "Имя файла сценария: \"`basename $0`\"."
# Добавит путь к имени файла (см. 'basename')
echo
if [ -n "$1" ] # Проверяемая переменная заключена в кавычки.
then
 echo "Параметр #1: $1" # необходимы кавычки для экранирования символа #
fi
if [ -n "$2" ]
then
 echo "Параметр #2: $2"
fi
if [ -n "$3" ]
then
 echo "Параметр #3: $3"
fi
if [ -n "${10}" ] # Параметры, следующие за $9 должны заключаться в фигурные скобки
then 
 echo "Параметр #10: ${10}"
fi
echo "-----------------------------------"
echo "Все аргументы командной строки: "$*""
if [ $# -lt "$MINPARAMS" ]
then
 echo
echo "Количество аргументов командной строки должно быть не менее $MINPARAMS !"
fi
echo
exit 0
</source>
''Скобочная нотация'' позиционных параметров даёт довольно простой способ обращения к последнему аргументу, переданному в сценарий из командной строки. Такой способ подразумевает использование косвенной адресации.
<source lang="bash">
args=$# # Количество переданных аргументов.
lastarg=${!args} # Обратите внимание: lastarg=${!$#} неприменимо.
</source>
В сценарии можно предусмотреть различные варианты развития событий, в зависимости отимени сценария. Для этого сценарий должен проанализировать аргумент $0 -- имя файласценария. Это могут быть и имена символических ссылок на файл сценария.
 Если сценарий ожидает передачи аргументов в командной строке, то при их отсутствии он получит "пустые" переменные, что может вызвать нежелательный
 побочный эффект. Один из способов борьбы с подобными ошибками — добавить дополнительный символ в обеих частях операции присваивания, 
 где используются аргументы командной строки.
<source lang="bash">
variable1_=$1_# Это предотвратит появление ошибок, даже при отсутствии входного аргумента.
critical_argument01=$variable1_
# Дополнительные символы всегда можно "убрать" позднее.
# Это может быть сделано примерно так:
variable1=${variable1_/_/} # Побочный эффект возникает только если имя переменной # $variable1_ будет начинаться с символа "_".
# Здесь используется один из вариантов подстановки параметров, обсуждаемых далее.
# Отсутствие шаблона замены приводит к удалению.
# Более простой способ заключается
# в обычной проверке наличия позиционного параметра.
if [ -z $1 ]; then 
exit $POS_PARAMS_MISSING
fi
</source>

<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''wh, whois выяснение имени домена.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Команда 'whois domain-name' выясняет имя домена на одном из 3 серверов:
# ripe.net, cw.net, radb.net
# Разместите этот скрипт под именем 'wh' в каталоге /usr/local/bin
# Требуемые символические ссылки:
# ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe
# ln -s /usr/local/bin/wh /usr/local/bin/wh-cw
# ln -s /usr/local/bin/wh /usr/local/bin/wh-radb
if [ -z "$1" ]
then
 echo "Порядок использования: `basename $0` [domain-name]"
exit 65
fi
case `basename $0` in
# Проверка имени скрипта и, соответственно, имени сервера
"wh" ) whois $1@whois.ripe.net;;
"wh-ripe") whois $1@whois.ripe.net;;
"wh-radb") whois $1@whois.radb.net;;
"wh-cw" ) whois $1@whois.cw.net;;
* ) echo "Порядок использования: `basename $0` [domain-name]";;
esac
exit 0
</source>
Команда shift "сдвигает" позиционные параметры, в результате чего парметры "сдвигаются" на одну позицию влево.
<br />$1 <--- $2, $2 <--- $3, $3 <--- $4, и т.д.<br />
Прежний аргумент $1 теряется, но аргумент $0 (имя файла сценария) остаётся без изменений. Если вашему сценарию передаётся большое количество входных аргументов, то команда shift позволит вам получить доступ к аргументам, с порядковым номером больше 9, без использования {фигурных скобок}.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Использование команды shift.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Использование команды 'shift' с целью перебора всех аргументов командной строки.
# Назовите файл с этим сценарием, например "shft",
# и вызовите его с набором аргументов, например:
# ./shft a b c def 23 skidoo
until [ -z "$1" ] # До тех пор пока не будут разобраны все входные аргументы...
do
 echo -n "$1 " 
 shift
done
echo # Дополнительная пустая строка.
exit 0
</source>
Команда ''shift'' может применяться и к входным аргументам функций.

== Кавычки ==
Кавычки, ограничивающие строки с обеих сторон, служат для предотвращения интерпретации специальных символов, которые могут находиться в строке. Символ называется "специальным", если он несет дополнительную смысловую нагрузку, например символ шаблона — <big>'''*'''</big>.
<source lang="bash">
bash$ ls -l [Vv]*
-rw-rw-r-- 1 bozo bozo 324 Apr 2 15:05 VIEWDATA.BAT 
-rw-rw-r-- 1 bozo bozo 507 May 4 14:25 vartrace.sh 
-rw-rw-r-- 1 bozo bozo 539 Apr 14 17:11 viewdata.sh
bash$ ls -l '[Vv]*'
ls: [Vv]*: No such file or directory
</source>
Некоторые программы и утилиты могут вызываться с дополнительными параметрами,содержащими специальными символы, поэтому очень важно предотвратить интерпретацию передаваемых параметров командной оболочкой, позволяя сделать это вызываемой программой.
<source lang="bash">
bash$ grep '[Пп]ервая' *.txt
file1.txt:Это первая строка в file1.txt. 
file2.txt:Это Первая строка в file2.txt.
</source>
Примечательно, что "не окавыченный" вариант команды grep [Пп]ервая *.txt будет правильно исполняться в Bash, но не в tcsh.
Вообще, желательно использовать двойные кавычки (<big>" "</big>) при обращении к переменным. Это предотвратит интерпретацию специальных символов, которые могут содержаться в именах переменных, за исключением <big>$</big>, <big>`</big>(обратная кавычка) и <big>\</big> (escape — обратный слэш).
То, что символ <big>$</big> попал в разряд исключений, позволяет выполнять обращение к переменным внутри строк, ограниченных двойными кавычками ("$variable"), т.е. выполнять подстановку значений переменных.
Двойные кавычки могут быть использованы для предотвращения разбиения строки на слова. Заключение строки в кавычки приводит к тому, что она передаётся как один аргумент, даже если она содержит пробельные символы-разделители.
<source lang="bash">
variable1="a variable containing five words"
COMMAND This is $variable1 # Исполнение COMMAND с 7 входными аргументами:
# "This" "is" "a" "variable" "containing" "five" "words"
COMMAND "This is $variable1" 
# Исполнение COMMAND с одним входным аргументом:# "This is a variable containing five words"
variable2="" # Пустая переменная.
COMMAND $variable2 $variable2 $variable2 # Исполнение COMMAND без аргументов.
COMMAND "$variable2" "$variable2" "$variable2" # Исполнение COMMAND с 3 "пустыми" аргументами.
COMMAND "$variable2 $variable2 $variable2" # Исполнение COMMAND с 1 аргументом (и 2 пробелами).
</source>
Заключение в кавычки аргументов команды [[echo]] необходимо только в том случае, когда разбиение на отдельные слова сопряжено с определенными трудностями.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Вывод "причудливых" переменных.'''''</span></p>
<source lang="bash">
#!/bin/bash
# weirdvars.sh: Вывод "причудливых" переменных
var="'(]\\{}\$\""
echo $var # '(]\{}$"
echo "$var" # '(]\{}$" Никаких различий.
echo
IFS='\'
echo $var # '(] {}$" \ символ-разделитель преобразован в пробел.
echo "$var" # '(]\{}$"
# Примеры выше предоставлены S.C.
exit 0
</source>
Одиночные кавычки (<big>' '</big>) схожи по своему действию с двойными кавычками, только не допускают обращение к переменным, поскольку специальный символ "$" внутри одинарных кавычек воспринимается как обычный символ. Внутри одиночных кавычек, любой специальный символ, заисключением ', интерпретируется как простой символ. Одиночные кавычки ("строгие, или полные кавычки") следует рассматривать как более строгий вариант, чем двойные кавычки ("нестрогие, или неполные кавычки").
Поскольку внутри одиночных кавычек даже экранирующий (<big>\</big>) символ воспринимается как обычный символ, попытка вывести одиночную кавычку внутри строки, ограниченной одинарными кавычками, не даст желаемого результата.
<source lang="bash">
echo "Why can't I write 's between single quotes"
echo
# Обходной метод.
echo 'Why can'\''t I write '"'"'s between single quotes'
# |-------| |----------| |-----------------------|
# Три строки, ограниченных одинарными кавычками,
# и экранированные одиночные кавычки между ними.
# Пример любезно предоставлен Stephane Chazelas.
</source>
'''''Экранирование''''' — это способ заключения в кавычки одиночного символа. Экранирующий (escape)символ (<big>\</big>) сообщает интерпретатору, что следующий за ним символ должен восприниматься как обычный символ. С отдельными командами и утилитами, такими как [[echo]] и [[sed]], экранирующий символ может применяться для получения обратного эффекта — когда обычные символы при экранировании приобретают специальное значение.
<p style="text-align:center"><span style="color:black"> '''Специальное назначение некоторых экранированных символов, используемых совместно с [[echo]] и [[sed]]'''</span></p>
* <big>'''\n'''</big> — перевод строки (новая строка)
* <big>'''\r'''</big> — перевод каретки
* <big>'''\t'''</big> — табуляция
* <big>'''\v'''</big> — вертикальная табуляция
* <big>'''\b'''</big> — забой (backspace)
* <big>'''\a'''</big> — "звонок" (сигнал)
* <big>'''\0xx'''</big> — ASCII-символ с кодом 0xx в восьмеричном виде
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Экранированные символы.'''''</span></p>
<source lang="bash">
#!/bin/bash
# escaped.sh: экранированные символы
echo; echo
echo "\v\v\v\v" # Вывод последовательности символов \v\v\v\v.
# Для вывода экранированных символов следует использовать ключ -e.
echo "============="
echo "ВЕРТИКАЛЬНАЯ ТАБУЛЯЦИЯ"
echo -e "\v\v\v\v" # Вывод 4-х вертикальных табуляций.
echo "=============="
echo "КАВЫЧКИ"
echo -e "\042" # Выводит символ " (кавычки с восьмеричным кодом ASCII 42).
echo "=============="
# Конструкция $'\X' делает использование ключа -e необязательным.
echo; echo "НОВАЯ СТРОКА И ЗВОНОК"
echo $'\n' # Перевод строки.
echo $'\a' # Звонок (сигнал).
echo "==============="
echo "КАВЫЧКИ"
# Bash версии 2 и выше допускает использование конструкции $'\nnn'.
# Обратите внимание: здесь под '\nnn' подразумевается восьмеричное значение.
echo $'\t \042 \t' # Кавычки (") окруженные табуляцией.
# В конструкции $'\xhhh' допускается использовать и шестнадцатеричные значения.
echo $'\t \x22 \t' # Кавычки (") окруженные табуляцией.
# Спасибо Greg Keraunen, за это примечание.
# Ранние версии Bash допускали употребление конструкции в виде '\x022'.
echo "==============="
echo
# Запись ASCII-символов в переменную.
# ----------------------------------------
quote=$'\042' # запись символа " в переменную.
echo "$quote Эта часть строки ограничена кавычками, $quote а эта — нет."
echo
# Конкатенация ASCII-символов в переменную.
triple_underline=$'\137\137\137' # 137 — это восьмеричный код символа '_'.
echo "$triple_underline ПОДЧЕРКИВАНИЕ $triple_underline"
echo
ABC=$'\101\102\103\010' # 101, 102, 103 это A, B и C соответственно.
echo $ABC
echo; echo
escape=$'\033' # 033 — восьмеричный код экранирующего символа.
echo "\"escape\" выводится как $escape"
# вывод отсутствует.
echo; echo
exit 0
</source>
* <big>'''\"'''</big> — кавычки
<source lang="bash">
echo "Привет" # Привет
echo "Он сказал: \"Привет\"." # Он сказал: "Привет".
</source>
* <big>'''\$'''</big> — символ доллара (если за комбинацией символов \$ следует имя переменной, то она не будет разыменована)
<source lang="bash">
echo "\$variable01" # выведет $variable01
</source>
* <big>'''\\'''</big> — обратный слэш
<source lang="bash">
echo "\\" # выведет \
# Тогда как...
echo "\" # Приведёт к выводу вторичного приглашения к вводу. 
# В сценариях — порождает сообщение об ошибке.
</source>
Поведение символа <big>\</big> сильно зависит от того экранирован ли он, ограничен ли кавычками или находится внутри конструкции подстановки команды или во вложенном документе.
<source lang="bash">
# Простое экранирование и кавычки
echo \z # z
echo \\z # \z
echo '\z' # \z
echo '\\z' # \\z
echo "\z" # \z
echo "\\z" # \z
# Подстановка команды
echo `echo \z` # z
echo `echo \\z` # z
echo `echo \\\z` # \z
echo `echo \\\\z` # \z
echo `echo \\\\\\z` # \z
echo `echo \\\\\\\z` # \\z
echo `echo "\z"` # \z
echo `echo "\\z"` # \z
# Встроенный документ
cat <<EOF
\z
EOF # \z
cat <<EOF
\\z
EOF # \z
# Эти примеры предоставил Stephane Chazelas.
</source>
Отдельные символы в строке, которая записывается в переменную, могут быть экранированы, исключение составляет сам экранирующий символ.
<source lang="bash">
variable=\
echo "$variable"
# Не работает - дает сообщение об ошибке:
# test.sh: : command not found
# В "чистом" виде экранирующий (escape) символ не может быть записан в переменную.
# Фактически, в данном примере, происходит экранирование символа перевода строки
# в результате получается такая команда: variable=echo "$variable"
# ошибочное присваивание
variable=\
23skidoo
echo "$variable" # 23skidoo
# Здесь все в порядке, поскольку вторая строка 
# является нормальным, с точки зрения присваивания, выражением.
variable=\
# \^ За escape-символом следует пробел
echo "$variable" # пробел
variable=\\  # \
variable=\\\
echo "$variable"
# Не работает - сообщение об ошибке:
# test.sh: \: command not found
#
# Первый escape-символ экранирует второй, а третий оказывается неэкранированным,
# результат тот же, что и в первом примере.
variable=\\\\
echo "$variable" # \\
# Второй и четвертый escape-символы экранированы.
# Это нормально.
</source>
Экранирование пробелов предотвращает разбиение списка аргументов командной строки на отдельные аргументы.
<source lang="bash">
file_list="/bin/cat /bin/gzip /bin/more /usr/bin/less /usr/bin/emacs-20.7"
# Список файлов как аргумент(ы) командной строки.
# Добавить два файла в список и вывести список.
ls -l /usr/X11R6/bin/xsetroot /sbin/dump $file_listecho "-------------------------------------------------------------------------"
# Что произойдет, если экранировать пробелы в списке?
ls -l /usr/X11R6/bin/xsetroot\ /sbin/dump\ $file_list
# Ошибка: первые три файла будут "слиты" воедино
# и переданы команде 'ls -l' как один аргумент
# потому что два пробела, разделяющие аргументы (слова) — экранированы.
</source>
Кроме того, escape-символ позволяет писать многострочные команды. Обычно, каждая команда занимает одну строку, но escape-символ позволяет экранировать символ перевода строки, в результате чего одна команда может занимать несколько строк.
<source lang="bash">
(cd /source/directory && tar cf - . ) | \
(cd /dest/directory && tar xpvf -)
# Команда копирования дерева каталогов.
# Разбита на две строки для большей удобочитаемости.
# Альтернативный вариант:
tar cf - -C /source/directory . |
tar xpvf - -C /dest/directory
# См. примечание ниже.
# (Спасибо Stephane Chazelas.)
</source>
Если строка сценария заканчивается символом создания конвейера <big>|</big>, то необходимость в применении символа <big>\</big>, для экранирования перевода строки, отпадает. Тем не менее, считается хорошим тоном, всегда использовать символ <big>\</big> в конце промежуточных строк многострочных команд.
<source lang="bash">
echo "foo
bar"
#foo
#bar
echo
echo 'foo
bar' # Никаких различий.
echo
echo foo\
bar # Перевод строки экранирован.
#foobar
echo
echo "foo\
bar" # Внутри "нестрогих" кавычек символ "\" интерпретируется как экранирующий.
#foobar
echo
echo 'foo\
bar' # В "строгих" кавычках обратный слэш воспринимается как обычный символ.
#foo\
#bar
# Примеры предложены Stephane Chazelas.
</source>

== Завершение и код завершения ==
<blockquote>
''...эта часть Bourne shell покрыта мраком, тем не менее все пользуются ею''. ©Chet Ramey
</blockquote>
Команда [[exit]] может использоваться для завершения работы сценария, точно так же как и в программах на языке C. Кроме того, она может возвращать некоторое значение, которое может быть проанализировано вызывающим процессом. Каждая команда возвращает ''код завершения'' (иногда код завершения называют ''возвращаемым значением''). В случае успеха команда должна возвращать 0, а в случае ошибки — ненулевое значение, которое, как правило, интерпретируется как код ошибки. Практически все команды и утилиты Unix возвращают 0 в случае успешного завершения, но имеются и исключения из правил.
<br />
Аналогичным образом ведут себя функции, расположенные внутри сценария, и сам сценарий, возвращая код завершения. Код, возвращаемый функцией или сценарием, определяется кодом возврата последней команды. Команде [[exit]] можно явно указать код возврата, в виде: exit ''nnn'', где ''nnn'' — это код возврата (число в диапазоне 0 - 255).
Когда работа сценария завершается командой [[exit]] без параметров, то код возврата сценария определяется кодом завершения последней исполненной команды (не считая саму команду [[exit]]).
<source lang="bash">
#!/bin/bash
COMMAND_1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
exit
</source>
Эквивалентный вариант — ''exit $?'' или можно вообще опустить команду [[exit]].
<source lang="bash">
#!/bin/bash
COMMAND_1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
exit $?

#!/bin/bash
COMMAND1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
</source>
Код возврата последней команды хранится в специальной переменной <big>$?</big>. После исполнения кодафункции, переменная <big>$?</big> хранит код завершения последней команды, исполненной в функции. Таким способом в Bash передаётся "значение, возвращаемое" функцией. После завершения работы сценария, код возврата можно получить, обратившись из командной строки к переменной <big>$?</big>, т.е. это будет код возврата последней команды, исполненной в сценарии.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Завершение / код завершения.'''''</span></p>
<source lang="bash">
#!/bin/bash
echo hello
echo $? # код возврата = 0, поскольку команда выполнилась успешно.
lskdf # Несуществующая команда.
echo $? # Ненулевой код возврата, поскольку команду выполнить не удалось.
echo
exit 113 # Явное указание кода возврата 113.
# Проверить можно, если набрать в командной строке "echo $?"
# после выполнения этого примера.
# В соответствии с соглашениями, 'exit 0' указывает на успешное завершение,
# в то время как ненулевое значение означает ошибку.
</source>
Переменная <big>$?</big> особенно полезна, когда необходимо проверить результат исполнения команды.
Символ <big>!</big>, может выступать как логическое "''НЕ''" для инверсии кода возврата.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Использование символа "!" для логической инверсии кода возврата.'''''</span></p>
<source lang="bash">
#!/bin/bash
true # встроенная команда "true".
echo "код возврата команды \"true\" = $?" # 0
! true
echo "код возврата команды \"! true\" = $?" # 1
# Обратите внимание: символ "!" от команды необходимо отделять пробелом.
# !true вызовет сообщение об ошибке "command not found"
# Спасибо S.C.
</source>
В отдельных случаях коды возврата должны иметь предопределённые значения и не должны задаваться пользователем.

== Проверка условий ==
Практически любой язык программирования включает в себя условные операторы, предназначенные для проверки условий, чтобы выбрать тот или иной путь развития событий в зависимости от этих условий. В Bash, для проверки условий, имеется команда [[test]], различного вида скобочные операторы и условный оператор '''''if/then'''''.
=== Конструкции проверки условий ===
* Оператор '''''if/then''''' проверяет — является ли код завершения списка команд 0 (поскольку 0 означает "успех"!), и если это так, то выполняет одну, или более, команд, следующие за словом '''''then'''''.
* Существует специальная команда — '''''[''''' (левая квадратная скобка). Она является синонимом команды [[test]], и является встроенной командой (т.е. более эффективной, в смысле производительности). Эта команда воспринимает свои аргументы как выражение сравнения или как файловую проверку и возвращает код завершения в соответствии с результатами проверки(0 — истина, 1 — ложь).
* Начиная с версии 2.02, Bash предоставляет в распоряжение программиста конструкцию '''''[[ ... ]]''''', расширенный вариант команды [[test]], которая выполняет сравнение способом более знакомым программистам, пишущим на других языках программирования. Обратите внимание: '''''[[''''' — это зарезервированное слово, а не команда!
Bash исполняет '''''<nowiki>[[ $a -lt $b ]]</nowiki>''''' как один элемент, который имеет код возврата!
<br />Круглые скобки '''''(( ... ))''''' и предложение '''''let ...''''' так же возвращают код 0, если результатом арифметического выражения является ненулевое значение. Таким образом, арифметические выражения могут участвовать в операциях сравнения.
<br />''Предложение let "1<2" возвращает 0 (так как результат сравнения "1<2" — "1", или "истина")(( 0 && 1 )) возвращает 1 (так как результат операции "0 && 1" — "0", или "ложь")''
* Условный оператор ''if'' проверяет код завершения любой команды, а не только результат выражения, заключенного в квадратные скобки.
<source lang="bash">
if cmp a b &> /dev/null # Подавление вывода.
then echo "Файлы a и b идентичны."
else echo "Файлы a и b имеют различия."
fi
if grep -q Bash file
then echo "Файл содержит, как минимум, одно слово Bash."
fi
word=Linux
letter_sequence=inu
if echo "$word" | grep -q "$letter_sequence"
# Подавление вывода ключом "-q" в команде grep.
then
 echo "Последовательность $letter_sequence обнаружена в слове $word"
else
 echo "Последовательность $letter_sequence, в слове $word не найдена"
fi

if COMMAND_WHOSE_EXIT_STATUS_IS_0_UNLESS_ERROR_OCCURRED
then echo "Команда выполнена успешно."
else echo "Обнаружена ошибка при выполнении команды."
fi
</source>
* Оператор ''if/then'' допускает наличие вложенных проверок.
<source lang="bash">
if echo "Следующий *if* находится внутри первого *if*."
 if [[ $comparison = "integer" ]]
   then (( a < b ))
 else
   [[ $a < $b ]]
 fi
then
 echo '$a меньше $b'fi
fi
</source>

'''''Это детальное описание конструкции "if-test" любезно предоставлено Stephane Chazelas.'''''
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Что есть "истина"?'''''</span></p>
<source lang="bash">
#!/bin/bash
echo
echo "Проверяется \"0\""
if [ 0 ] # ноль
then
 echo "0 — это истина."
else
 echo "0 — это ложь."
fi # 0 — это истина.
echo
echo "Проверяется \"1\""
if [ 1 ] # единица
then
 echo "1 — это истина."
else
 echo "1 — это ложь."
fi # 1 — это ложь.
echo
echo "Testing \"-1\""
if [ -1 ] # минус один
then
 echo "-1 — это истина."
else
 echo "-1 — это ложь."
fi # -1 — это истина.
echo
echo "Проверяется \"NULL\""
if [ ] # NULL (пустое условие)
then
 echo "NULL — это истина."
else
 echo "NULL — это ложь."
fi # NULL — это ложь.
echo
echo "Проверяется \"xyz\""
if [ xyz ] # строка
then
 echo "Случайная строка — это истина."
else
 echo "Случайная строка — это ложь."
fi # Случайная строка — это истина.
echo
echo "Проверяется \"\$xyz\""
if [ $xyz ] # Проверка, если $xyz это null, но...
# только для неинициализированных переменных.
then
 echo "Неинициализированная переменная — это истина."
else
 echo "Неинициализированная переменная — это ложь."
fi # Неинициализированная переменная — это ложь.
echo
echo "Проверяется \"-n \$xyz\""
if [ -n "$xyz" ] # Более корректный вариант.
then
 echo "Неинициализированная переменная — это истина."
else
 echo "Неинициализированная переменная — это ложь."
fi # Неинициализированная переменная — это ложь.
echo
xyz= # Инициализирована пустым значением.
echo "Проверяется \"-n \$xyz\""
if [ -n "$xyz" ]
then
 echo "Пустая переменная — это истина."
else
 echo "Пустая переменная — это ложь."
fi # Пустая переменная — это ложь.
echo 
# Когда "ложь" истинна?
echo "Проверяется \"false\""
if [ "false" ] # это обычная строка "false".
then
 echo "\"false\" — это истина." # и она истинна.
else 
echo "\"false\" — это ложь."
fi # "false" — это истина.
echo
echo "Проверяется \"\$false\"" # Опять неинициализированная переменная.
if [ "$false" ]
then
 echo "\"\$false\" — это истина."
else
 echo "\"\$false\" — это ложь."
fi # "$false" — это ложь.
# Теперь мы получили ожидаемый результат.
echo
exit 0
</source>
<p style="text-align:center"><span style="color:red">'''''Упражнение'''''</span></p>
Объясните результаты, полученные в примере ''Что есть "истина"?''
<source lang="bash">
if [ condition-true ]
then 
 command 1
 command 2 
 ...
else # Необязательная ветка (можно опустить, если в ней нет необходимости). 
# Дополнительный блок кода, 
# исполняемый в случае, когда результат проверки — "ложь". 
command 3 command 4 ...
fi
</source>
Когда ''if'' и ''then'' располагаются в одной строке, то конструкция ''if'' должна завершаться точкой с запятой. И ''if'', и ''then'' - это '''''зарезервированные слова'''''. '''''Зарезервированные слова''''' начинают инструкцию, которая должна быть завершена прежде, чем в той же строке появится новая инструкция.
<source lang="bash">
if [ -x "$filename" ]; then
</source>
* Else if и elif
''elif'' — это краткая форма записи конструкции else if. Применяется для построения многоярусных инструкций ''if/then''.
<source lang="bash">
if [ condition1 ]
then
 command1 
 command2
 command3
elif [ condition2 ]
# То же самое, что и else if
then
 command4 
 command5
else
 default-command
fi
</source>
Конструкция ''if test condition-true'' является точным эквивалентом конструкции ''if [ condition-true]'', где левая квадратная скобка ''['' выполняет те же действия, что и команда [[test]]. Закрывающая правая квадратная скобка '']'' не является абсолютно необходимой, однако, более новые версии Bash требуют её наличие.
Команда [[test]] — это встроенная команда Bash, которая выполняет проверки файлов и производит сравнение строк. Таким образом, в Bash-скриптах, команда [[test]] не вызывает внешнюю ('''''/usr/bin/test''''') утилиту, которая является частью пакета sh-utils. Аналогично, ''['' не производит вызов утилиты '''''/usr/bin/[''''', которая является символической ссылкой на '''''/usr/bin/test'''''.
<source lang="bash">
bash$ type test
test is a shell builtin
bash$ type '['
[ is a shell builtin
bash$ type '[['
[[ is a shell keyword
bash$ type ']]'
]] is a shell keyword
bash$ type ']'
bash: type: ]: not found
</source>

<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Эквиваленты команды test — /usr/bin/test, [ ], и /usr/bin/['''''</span></p>
<source lang="bash">
#!/bin/bash
echo
if test -z "$1"
then
 echo "Аргументы командной строки отсутствуют."
else
 echo "Первый аргумент командной строки: $1."
fi
echo
if /usr/bin/test -z "$1" # Даёт тот же результат, что и встроенная команда "test".
then
 echo "Аргументы командной строки отсутствуют."
else
 echo "Первый аргумент командной строки: $1."
fi
echo
if [ -z "$1" ] # Функционально идентично вышеприведенному блоку кода.
# if [ -z "$1" эта конструкция должна работать, но...
# Bash выдает сообщение об отсутствующей закрывающей скобке.
then
 echo "Аргументы командной строки отсутствуют."
else
 echo "Первый аргумент командной строки: $1."
fi
echo
if /usr/bin/[ -z "$1" # Функционально идентично вышеприведенному блоку кода.
# if /usr/bin/[ -z "$1" ] # Работает, но выдает сообщение об ошибке.
then
 echo "Аргументы командной строки отсутствуют."
else
 echo "Первый аргумент командной строки: $1."
fi
echo
exit 0
</source>
Конструкция <big><nowiki>[[ ]]</nowiki></big> более универсальна, по сравнению с <big><nowiki>[ ]</nowiki></big> . Этот расширенный вариант команды [[test]] перекочевал в Bash из ''ksh88''. Внутри этой конструкции не производится никакой дополнительной интерпретации имён файлов и не производится разбиение аргументов на отдельные слова, но допускается подстановка параметров и команд.
<source lang="bash">
file=/etc/passwd
if [[ -e $file ]]
then
 echo "Файл паролей найден."
fi
</source>
Конструкция <big><nowiki>[[...]]</nowiki></big> более предпочтительна, нежели <big><nowiki>[...]</nowiki></big>, поскольку поможет избежать некоторых логических ошибок. Например, операторы '''''&&''''', '''''||''''', '''''<''''' и '''''>''''' внутри <big><nowiki>[[ ]]</nowiki></big> вполне допустимы, в то время как внутри <big><nowiki>[ ]</nowiki></big> порождают сообщения об ошибках!
Строго говоря, после оператора ''if'', ни команда [[test]], ни квадратные скобки ( <big><nowiki>[]</nowiki></big> или <big><nowiki>[[ ]]</nowiki></big> ) не являются обязательными.
<source lang="bash">
dir=/home/bozo
if cd "$dir" 2>/dev/null; then # "2>/dev/null" подавление вывода сообщений об ошибках.
 echo "Переход в каталог $dir выполнен."
else
 echo "Невозможно перейти в каталог $dir."
fi
</source>
Инструкция ''if COMMAND'' возвращает код возврата команды ''COMMAND''. Точно так же, условие, находящееся внутри квадратных скобок может быть проверено без использования оператора ''if''.
<source lang="bash">
var1=20
var2=22
[ "$var1" -ne "$var2" ] && echo "$var1 не равно $var2"
home=/home/bozo
[ -d "$home" ] || echo "каталог $home не найден."
</source>
Внутри <big><nowiki>(())</nowiki></big> производится вычисление арифметического выражения. Если результатом вычислений является ноль, то возвращается 1, или "ложь". Ненулевой результат даёт код возврата 0, или "истина". То есть полная противоположность инструкциям [[test]] и [ ], обсуждавшимся выше.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Арифметические выражения внутри (( ))'''''</span></p>
<source lang="bash">
#!/bin/bash
# Проверка арифметических выражений.
# Инструкция (( ... )) вычисляет арифметические выражения.
# Код возврата противоположен коду возврата инструкции [ ... ] !
(( 0 ))
echo "Код возврата \"(( 0 ))\": $?." # 1(( 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
</source>

=== Операции проверки файлов ===
Возвращает ''true'' если...
* <big>-e</big> — файл существует
* <big>-f</big> — ''обычный'' файл (не каталог и не файл устройства!)
* <big>-s</big> — ненулевой размер файла
* <big>-d</big> — файл является каталогом
* <big>-b</big> — файл является блочным устройством (floppy, cdrom и т.п.)
* <big>-c</big> — файл является символьным устройством (клавиатура, модем, звуковая карта и т.п.)
* <big>-p</big> — файл является каналом
* <big>-h</big> — файл является символической ссылкой
* <big>-L</big> — файл является символической ссылкой
* <big>-S</big> — файл является сокетом
* <big>-t</big> — файл (дескриптор) связан с терминальным устройством
 Этот ключ может использоваться для проверки — является ли файл стандартным устройством ввода ''stdin'' ([ -t 0 ]) или стандартным устройством вывода ''stdout'' ([ -t 1 ]). 
* <big>-r</big> — файл доступен для чтения (пользователю, запустившему сценарий)
* <big>-w</big> — файл доступен для записи (пользователю, запустившему сценарий)
* <big>-x</big> — файл доступен для исполнения (пользователю, запустившему сценарий)
* <big>-g</big> — set-group-id (sgid) флаг для файла или каталога установлен
 Если для каталога установлен флаг sgid, то файлы, создаваемые в таком каталоге, наследуют идентификатор группы каталога, который может не совпадать с идентификатором
 группы, к которой принадлежит пользователь, создавший файл. Это может быть полезно для каталогов, в которых хранятся файлы, общедоступные для группы пользователей.
* <big>-u</big> — set-user-id (suid) флаг для файла установлен
 Установленный флаг suid приводит к изменению привилегий запущенного процесса на привилегии владельца исполняемого файла. Исполняемые файлы, владельцем которых
 является root, с установленным флагом set-user-id запускаются с привилегиями root, даже если их запускает обычный пользователь.
 Это может оказаться полезным для некоторых программ(таких как ''pppd'' и ''cdrecord''), которые осуществляют доступ к аппаратной части компьютера. В случае отсутствия
 флага suid, программы не смогут быть запущены рядовым пользователем, не обладающим привилегиями root.
 ''-rwsr-xr-t 1 root 178236 Oct 2 2000 /usr/sbin/pppd''
 Файл с установленным флагом suid отображается с включенным флагом ''s'' в поле прав доступа.
* <big>-k</big> — флаг sticky bit (бит фиксации) установлен
 Общеизвестно, что флаг "sticky bit" — это специальный тип прав доступа к файлам. Программы сустановленным флагом "sticky bit" остаются в системном кэше после своего
 завершения,обеспечивая тем самым более быстрый запуск программы. Если флаг установлен для каталога, то это приводит к ограничению прав на запись. Установленный флаг
 "sticky bit" отображается в виде символа ''t'' в поле прав доступа.
 ''drwxrwxrwt 7 root 1024 May 19 21:26 tmp/''
 Если пользователь не является владельцем каталога , с установленным "sticky bit", но имеет право на запись в каталог, то он может удалять только те файлы в каталоге,
 владельцем которых он является. Это предотвращает удаление и перезапись "чужих" файлов в общедоступных каталогах, таких как /tmp.
* <big>-O</big> — вы являетесь владельцем файла
* <big>-G</big> — вы принадлежите к той же группе, что и файл
* <big>-N</big> — файл был модифицирован с момента последнего чтения
* <big>f1 -nt f2</big> — файл f1 более новый, чем f2
* <big>f1 -ot f2</big> — файл f1 более старый, чем f2
* <big>f1 -ef f2</big> — файлы f1 и f2 являются "жесткими" ссылками на один и тот же файл
* <big>!</big> — "НЕ" — логическое отрицание (инверсия) результатов всех вышеприведенных проверок(возвращается ''true'' если условие отсутствует).

<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Проверка "битых" ссылок.'''''</span></p>
<source lang="bash">
#!/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
</source>

=== Операции сравнения ===
'''''Сравнение целых чисел''''':
* <big>-eq</big> — равно
 if [ "$a" -eq "$b" ]
* <big>-ne</big> — не равно
 if [ "$a" -ne "$b" ]
* <big>-gt</big> — больше
 if [ "$a" -gt "$b" ]
* <big>-ge</big> — больше или равно
 if [ "$a" -ge "$b" ]
* <big>-lt</big> — меньше
 if [ "$a" -lt "$b" ]
* <big>-le</big> — меньше или равно
 if [ "$a" -le "$b" ]
* <big><</big> — меньше (внутри двойных круглых скобок )
 (("$a" < "$b"))
* <big><=</big> — меньше или равно (внутри двойных круглых скобок)
 (("$a" <= "$b"))
* <big>></big> — больше (внутри двойных круглых скобок )
 (("$a" > "$b"))
* <big>>=</big> — больше или равно(внутри двойных круглых скобок )
 (("$a" >= "$b"))

'''''Cравнение строк''''':
* <big>=</big> — равно
 if [ "$a" = "$b" ]
* <big>==</big> — равно. Синоним оператора =.
 if [ "$a" == "$b" ]
<source lang="bash">
[[ $a == z* ]] # истина, если $a начинается с символа "z" (сравнение по шаблону)
[[ $a == "z*" ]] # истина, если $a равна z*
[ $a == z* ] # имеют место подстановка имён файлов и разбиение на слова
[ "$a" == "z*" ] # истина, если $a равна z*
# Спасибо S.C.
</source> 
* <big>!=</big> — не равно
 if [ "$a" != "$b" ]
 Этот оператор используется при поиске по шаблону внутри [[ ... ]]
* <big><</big> — меньше, в смысле величины ASCII-кодов
 if [[ "$a" < "$b" ]]
 if [ "$a" \< "$b" ]
 Обратите внимание! Символ "<" необходимо экранировать внутри [ ]
* <big>></big> — больше, в смысле величины ASCII-кодов
 if [[ "$a" > "$b" ]]
 if [ "$a" \> "$b" ]
 Обратите внимание! Символ ">" необходимо экранировать внутри [ ]
* <big>-z</big> — строка "пустая", т.е. имеет нулевую длину
* <big>-n</big> — строка не "пустая"
 Оператор ''-n'' требует, чтобы строка была заключена в кавычки внутри квадратных скобок. Как правило, проверка строк, не заключенных в кавычки, оператором ''! -z'', 
 или просто указание строки без кавычек внутри квадратных скобок, проходит нормально, однако это небезопасная, с точки зрения отказоустойчивости, 
 практика. Всегда заключайте проверяемую строку в кавычки.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Операции сравнения.'''''</span></p>
<source lang="bash">
#!/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
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Проверка — является ли строка пустой'''''</span></p>
<source lang="bash">
#!/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"), поскольку...
echo
string1="a = b"
if [ $string1 ] # И снова, попробуем строку без ничего..
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi
# Строка без кавычек даёт неверный результат!
exit 0
# Спасибо Florian Wisser, за предупреждение.
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''zmore'''''</span></p>
<source lang="bash">
#!/bin/bash
#Просмотр gz-файлов с помощью утилиты 'more'
NOARGS=65
NOTFOUND=66
NOTGZIP=67
if [ $# -eq 0 ] # то же, что и: if [ -z "$1" ]
# $1 должен существовать, но может быть пустым: zmore "" 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 | more
# Используется утилита 'more' (очень похожа на 'less').
# Последние версии 'more' могут просматривать сжатые файлы.
# Можно вставить 'more' или 'less', если пожелаете.
exit $? # Сценарий возвращает код возврата, полученный по конвейеру.
# На самом деле команда "exit $?" не является обязательной,
# так как работа скрипта завершится здесь в любом случае.
</source>
'''''Построение сложных условий проверки''''':
* <big>-a</big> —  логическое И (and)
 ''exp1 -a exp2'' возвращает ''true'', если оба выражения, и ''exp1'', и ''exp2'' истинны.
* <big>-o</big> —  логическое ИЛИ (or)
 ''exp1 -o exp2'' возвращает ''true'', если хотябы одно из выражений, ''exp1'' или ''exp2'' истинно.
 Они похожи на операторы Bash '''&&''' и '''||''', употребляемые в двойных квадратных скобках.
 ''<nowiki>[[ condition1 && condition2 ]]</nowiki>''
 Операторы ''-o'' и ''-a'' употребляются совместно с командой [[test]] или внутри одинарных квадратных скобок.
 ''if [ "$exp1" -a "$exp2" ]''

=== Вложенные условные операторы if/then ===
Операторы проверки условий ''if/then'' могут быть вложенными друг в друга. Конечный результат будет таким же как если бы результаты всех проверок были объединены оператором '''&&'''.
<source lang="bash">
if [ condition1 ]
then
 if [ condition2 ]
  then
   do-something # Только если оба условия "condition1" и "condition2" истинны.
 fi
fi 
</source>

=== Проверка степени усвоения материала ===
Для запуска X-сервера может быть использован файл xinitrc. Этот файл содержит некоторое число операторов if/then. Ниже приводится отрывок из этого файла.
<source lang="bash">
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
</source>
Объясните действия условных операторов в вышеприведённом отрывке, затем просмотрите файл /etc/X11/xinit/xinitrc и проанализируйте его. Возможно вам придется обратиться
к разделам, посвящённым [[grep]], [[sed]] и регулярным выражениям.

== Операции и смежные темы ==
=== Операторы ===
* <big>'''Присваивание'''</big> 
''variable assignment''<br />
Инициализация переменной или изменение её значения.
<br />
<big>'''='''</big> — Универсальный оператор присваивания, пригоден как для сравнения целых чисел, так и для сравнения строк.
Пусть вас не смущает, что оператор присваивания ("="), по своему внешнему виду, совпадает с оператором сравнения (=).
<source lang="bash">
# Здесь знак "=" выступает в качестве оператора сравнения
if [ "$string1" = "$string2" ]
# if [ "X$string1" = "X$string2" ] более отказоустойчивый вариант,
# предохраняет от "сваливания" по ошибке в случае, когда одна из переменных пуста.
# (добавленные символы "X" компенсируют друг друга.)
then
 command
fi
</source>
* <big>'''Арифметические операторы'''</big> 
<big>'''+'''</big> — Сложение
<big>'''-'''</big> — Вычитание
<big>'''*'''</big> — Умножение
<big>'''/'''</big> — Деление
<big>'''**'''</big> — Возведение в степень
<source lang="bash">
# В Bash, начиная с версии 2.02, был введен оператор возведения в степень -- "**".
let "z=5**3"
echo "z = $z" # z = 125
</source>
<big>'''%'''</big> — модуль (деление по модулю), возвращает остаток от деления
<source lang="bash">
bash$ echo `expr 5 % 3`
2
</source>
Этот оператор может применяться в алгоритмах генерации псевдослучайных чисел в заданном диапазоне, для форматирования вывода на экран и даже для генерации простых чисел. На удивление часто операцию деления по модулю можно встретить в различных численных алгоритмах.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Наибольший общий делитель.'''''</span></p>
<source lang="bash">
#!/bin/bash
# gcd.sh: поиск наибольшего общего делителя
# по алгоритму Эвклида
# Под "наибольшим общим делителем" (нод) двух целых чисел
# понимается наибольшее целое число, которое делит оба делимых без остатка.
# Алгоритм Эвклида выполняет последовательное деление.
# В каждом цикле,
# делимое <--- делитель
# делитель <--- остаток
# до тех пор, пока остаток не станет равным нулю (остаток = 0).
# The gcd = dividend, on the final pass.
# Замечательное описание алгоритма Эвклида можно найти
# на сайте Jim Loy, http://www.jimloy.com/number/euclids.htm.
# ------------------------------------------------------
# Проверка входных параметров
ARGS=2E_B
ADARGS=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 $2echo; 
echo "НОД чисел $1 и $2 = $dividend"; echo
# Упражнение :
# --------
# Вставьте дополнительную проверку входных аргументов,
# и предусмотрите завершение работы сценария с сообщением об ошибке, если
# входные аргументы не являются целыми числами.
exit 0
</source>
<big>'''+='''</big> — "плюс-равно" (увеличивает значение переменной на заданное число). <source lang="bash">let "var += 5"</source> значение переменной ''var'' будет увеличено на 5.
<big>'''-='''</big> — "минус-равно" (уменьшение значения переменной на заданное число).
<big>'''*='''</big> — "умножить-равно" (умножить значение переменной на заданное число, результат записать в переменную). <source lang="bash">let "var *= 4"</source> значение переменной ''var'' будет увеличено в 4 раза.
<big>'''/='''</big> — "слэш-равно" (уменьшение значения переменной в заданное число раз).
<big>'''%='''</big> — "процент-равно" (найти остаток от деления значения переменной на заданное число, результат записать в переменную).
Арифметические операторы очень часто используются совместно с командами [[expr]] и [[let]].
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Арифметические операции.'''''</span></p>
<source lang="bash">
#!/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
</source>
Целые числа в Bash фактически являются ''длинными целыми'' ('''32-бит''') со знаком, с диапазоном изменений от ''-2147483648'' до ''2147483647''. Если в результате какой либо операции эти пределы будут превышены, то результат получится ошибочным.
<source lang="bash">
#НЕАКТУАЛЕН для версии Bash  4.2!
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
              # ОШИБКА! (выход за границы диапазона)
</source>
'''''Версия Bash 2.05b, поддерживает 64-битные целые числа'''''. Bash ничего не знает о существовании чисел с плавающей запятой. Такие числа, из-за наличия символа десятичной точки, он воспринимает как строки.
<source lang="bash">
a=1.5
let "b = $a + 1.3" # Ошибка.
# -bash: let: b = 1.5 + 1.3: syntax error: invalid arithmetic operator (error token is ".5 + 1.3")
echo "b = $b" # b=1
b=
</source>
Для работы с числами с плавающей запятой в сценариях можно использовать утилиту-калькулятор [[bc]].
* <big>'''Битовые операции'''</big> 
Битовые операции очень редко используются в сценариях командного интерпретатора. Их главное назначение, на мой взгляд, установка и проверка некоторых значений,читаемых из портов ввода-вывода и сокетов. "Битовые операции" гораздо более уместны в компилирующих языках программирования, таких как C и C++.<br />
<big>'''<<'''</big> — сдвигает на 1 бит влево (умножение на 2)<br />
<big>'''<<='''</big> — "сдвиг-влево-равно". <source lang="bash">let "var <<= 2"</source> значение переменной ''var'' сдвигается влево на ''2 бита'' (умножается на 4).<br />
<big>'''>>'''</big> — сдвиг вправо на 1 бит (деление на 2)<br />
<big>'''>>='''</big> — "сдвиг-вправо-равно" (имеет смысл обратный <<=)<br />
<big>'''&'''</big> — по-битовое И (AND)<br />
<big>'''&='''</big> — по-битовое И-равно<br />
<big>'''|'''</big> — по-битовое ИЛИ (OR)<br />
<big>'''|='''</big> — по-битовое ИЛИ-равно<br />
<big>'''~'''</big> — по-битовая инверсия<br />
<big>'''!'''</big> — по-битовое отрицание<br />
<big>'''^'''</big> — по-битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)<br />
<big>'''^='''</big> — по-битовое ИСКЛЮЧАЮЩЕЕ-ИЛИ-равно<br />
* <big>'''Логические операции'''</big> <br />
<big>'''&&'''</big> — логическое И (and)<br />
<source lang="bash">
if [ $condition1 ] && [ $condition2 ]
# То же самое, что: if [ $condition1 -a $condition2 ]
# Возвращает true, если оба операнда condition1 и condition2 истинны...\
if [[ $condition1 && $condition2 ]] # То же верно
# Обратите внимание: оператор && не должен использоваться внутри [ ... ]!
</source>
Оператор <big>'''&&'''</big>, в зависимости от контекста, может так же использоваться в "И"-списках для построения составных команд.<br />
<big>'''||'''</big> — логическое ИЛИ (or)<br />
<source lang="bash">
if [ $condition1 ] || [ $condition2 ]
# То же самое, что: if [ $condition1 -o $condition2 ]
# Возвращает true, если хотя бы один из операндов истинен...
if [[ $condition1 || $condition2 ]] # Also works.
# Обратите внимание: оператор || не должен использоваться внутри [ ... ].
</source>
Bash производит проверку кода возврата КАЖДОГО из операндов в логических выражениях.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Построение сложных условий, использующих && и ||.'''''</span></p>
<source lang="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
</source>
Операторы <big>&&</big> и <big>||</big> могут использоваться и в арифметических вычислениях.
<source lang="bash">
bash$ echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0))
1 0 1 0
</source>
* <big>'''Прочие операции'''</big> <br />
<big>''','''</big> — запятая<br />
С помощью оператора запятая можно связать несколько арифметических в одну последовательность. При разборе таких последовательностей, командный интерпретатор вычисляет все выражения (которые могут иметь побочные эффекты) в последовательности и возвращает результат последнего.
<source lang="bash">
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
</source>
Оператор запятая чаще всего находит применение в циклах ''for''.

=== Числовые константы ===
Интерпретатор командной оболочки воспринимает числа как десятичные, в противном случае числу должен предшествовать специальный префикс, либо число должно быть записано в особой нотации. Числа, начинающиеся с символа 0, считаются восьмеричными. если числу предшествует префикс 0x, то число считается шестнадцатеричным. Число, в записи которого присутствует символ #, расценивается как запись числа с указанием основы счисления в виде ''ОСНОВА#ЧИСЛО''.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Различные представления числовых констант.'''''</span></p>
<source lang="bash">
#!/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, за разъяснения.
</source>

= Часть третья. Углублённый материал =
== К вопросу о переменных ==
Правильное использование переменных может придать сценариям дополнительную мощь и гибкость, а для этого необходимо изучить все тонкости и нюансы.
=== Внутренние переменные ===
* ''Встроенные переменные''
'''''$BASH''''' — путь к исполняемому файлу Bash
<source lang="bash">
bash$ echo $BASH
/bin/bash
</source>
'''''$BASH_VERSINFO[n]''''' — это массив, состоящий из 6 элементов, и содержащий информацию о версии Bash. Очень похожа на переменную ''$BASH_VERSION'', описываемую ниже.
<source lang="bash">
#!/bin/bash
# Информация о версии 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).
</source>
'''''$BASH_VERSINFO''''' — версия Bash, установленного в системе
<source lang="bash">
bash$ echo $BASH_VERSION
2.04.12(1)-release

tcsh% echo $BASH_VERSION
BASH_VERSION: Undefined variable.
</source>
Проверка переменной ''$BASH_VERSION'' — неплохой метод проверки типа командной оболочки, под которой исполняется скрипт. Переменная ''$SHELL'' не всегда даёт правильный ответ.<br />
'''''$DIRSTACK''''' — содержимое вершины стека каталогов (который управляется командами pushd и popd)
Эта переменная соответствует команде [[dirs]], за исключением того, что [[dirs]] показывает полное содержимое всего стека каталогов.<br />
'''''$EDITOR''''' — заданный по-умолчанию редактор, вызываемый скриптом, обычно '''vi''' или '''emacs'''<br />
'''''$EUID''''' — "эффективный" идентификационный номер пользователя (Effective User ID)
Идентификационный номер пользователя, права которого были получены, возможно с помощью команды [[su]]. Значение переменной ''$EUID'' необязательно должно совпадать с содержимым переменной ''$UID''.<br />
'''''$FUNCNAME''''' — имя текущей функции
<source lang="bash">
xyz23 ()
{
 echo "Исполняется функция $FUNCNAME." # Исполняется функция xyz23.
}
xyz23
echo "FUNCNAME = $FUNCNAME" # FUNCNAME =
                            # Пустое (Null) значение за пределами функций.
</source>
'''''$GLOBIGNORE''''' — Перечень шаблонных символов, которые будут проигнорированы при выполнении подстановки имён файлов (globbing)<br />
'''''$GROUPS''''' — группы, к которым принадлежит текущий пользователь
Это список групп (массив) идентификационных номеров групп для текущего пользователя, какэо записано в /etc/passwd.
<source lang="bash">
root# echo $GROUPS
0
root# echo ${GROUPS[1]}
1
root# echo ${GROUPS[5]}
6
</source>
'''''$HOME''''' — домашний каталог пользователя, как правило это /home/username<br />
'''''$HOSTNAME''''' — Сетевое имя хоста устанавливается командой hostname во время исполнения инициализирующих сценариев при загрузке системы. Внутренняя переменная ''$HOSTNAME'' Bash получает своё значение посредством вызова функции gethostname().<br />
'''''$HOSTTYPE''''' — тип машины
Подобно ''$MACHTYPE'', идентифицирует аппаратную архитектуру.
<source lang="bash">
bash$ echo $HOSTTYPE
i686
</source>
'''''$IFS''''' — разделитель полей во вводимой строке (IFS — Internal Field Separator)
Эта переменная управляет порядком выделения полей (задаёт символы-разделители) приразборе строки символов. По-умолчанию — пробельный символ (пробел, табуляция и перевод строки), но может быть изменён, например, для разбора строк, в которых отдельные поля разделены запятыми. Обратите внимание: при составлении содержимого переменной ''$*'', Bash использует первый символ из ''$IFS'' для разделения аргументов. 
<source lang="bash">
bash$ echo $IFS | cat -vte
$
bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"'
w:x:y:z
</source>
При всём при том следует помнить, что при использовании ''$IFS'' пробельные символы обрабатываются несколько иначе, чем все остальные.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''$IFS и пробельные символы.'''''</span></p>
<source lang="bash">
#!/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
#(Спасибо S. C., за разъяснения и примеры.)
</source>
'''''$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''. <br />
'''''$LC_CTYPE''''' — Эта внутренняя переменная определяет кодировку символов. Используется в операциях подстановки и поиске по шаблону.<br />
'''''$LINENO''''' — Номер строки исполняемого сценария. Эта переменная имеет смысл только внутри исполняемого сценария и чаще всего применяется в отладочных целях.
<source lang="bash">
# *** BEGIN DEBUG BLOCK ***
last_cmd_arg=$_ # Запомнить.
echo "Строка $LINENO: переменная \"v1\" = $v1"
echo "Последний аргумент командной строки = $last_cmd_arg"
# *** END DEBUG BLOCK ***
</source>
'''''$MACHTYPE''''' — аппаратная архитектура. Идентификатор аппаратной архитектуры.
<source lang="bash">
bash$ echo $MACHTYPE
i686
</source>
'''''$OLDPWD''''' — прежний рабочий каталог ("OLD-Print-Working-Directory")
'''''$OSTYPE''''' — тип операционной системы
<source lang="bash">
bash$ echo $OSTYPE
linux
</source>
'''''$PATH''''' — путь поиска, как правило включает в себя каталоги ''/usr/bin/'', ''/usr/X11R6/bin/'', ''/usr/local/bin'',и т.д.
Когда командный интерпретатор получает команду, то он автоматически пытается отыскать соответствующий исполняемый файл в указанном списке каталогов (в переменной ''$PATH''). Каталоги, в указанном списке, должны отделяться друг от друга двоеточиями. Обычно,переменная ''$PATH'' инициализируется в ''/etc/profile'' и/или в ''~/.bashrc''.
<source lang="bash">
bash$ echo $PATH
/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin
</source>
Инструкция ''PATH=${PATH}:/opt/bin'' добавляет каталог ''/opt/bin'' в конец текущего пути поиска.
Иногда может оказаться целесообразным, внутри сценария, временно добавить какой-либо каталог к пути поиска. По завершении работы скрипта, эти изменения будут утеряны(вспомните о том, что невозможно изменить переменные окружения вызывающего процесса). Текущий "рабочий каталог", ./, обычно не включается в $PATH из соображений безопасности.<br />
'''''$PIPESTATUS''''' — Код возврата канала (конвейера). Интересно, что это не то же самое, что код возврата последней исполненной команды.
<source lang="bash">
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
</source>
Переменная ''$PIPESTATUS'' может давать неверные значения при вызове из командной строки.
<source lang="bash">
tcsh% bash
bash$ who | grep nobody | sort
bash$ echo ${PIPESTATUS[*]}
0
</source>
Если поместить эти строки в сценарий и исполнить его, то будут выведены верные значения 0 1 0. Спасибо Wayne Pollock за замечания и предоставленный пример.<br />
'''''$PPID''''' — Переменная ''$PPID'' хранит PID (идентификатор) родительского процесса. Сравните с командой [[pidof]].<br />
'''''$PROMPT_COMMAND''''' — Переменная хранит команду, которая используется непосредственно для вывода первичного приглашения к вводу — ''$PS1''.<br />
'''''$PS1''''' — prompt, приглашение командной строки.<br />
'''''$PS2''''' — Вторичное приглашение командной строки, выводится тогда, когда от пользователя ожидается дополнительный ввод. Отображается как ">".<br />
'''''$PS3''''' — Третичное приглашение (prompt), выводится тогда, когда пользователь должен сделать выбор в операторе ''select''.<br />
'''''$PS4''''' — Приглашение (prompt) четвёртого уровня, выводится в начале каждой строки вывода тогда, когда сценарий вызывается с ключом ''-x''. Отображается как "+".<br />
'''''$PWD''''' — рабочий (текущий) каталог
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Аналог встроенной команды pwd.'''''</span></p>
<source lang="bash">
#!/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
</source>
'''''$REPLY''''' — переменная по-умолчанию, куда записывается ввод пользователя, выполненный с помощью команды ''read'', если явно не задана другая переменная. Так же может использоваться в операторе ''select'', для построения меню выбора.
<source lang="bash">
#!/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
</source>
'''''$SECONDS''''' — Время паботы сценария в секундах
<source lang="bash">
#!/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
</source>
'''''$SHELLOPTS''''' — список допустимых опций интерпретатора ''shell''. Переменная доступна только для чтения.
<source lang="bash">
bash$ echo $SHELLOPTS
braceexpand:hashall:histexpand:monitor:history:interactive-comments:emacs
</source>
'''''$SHLVL''''' — Уровень вложенности ''shell''. Если в командной строке ''echo $SHLVL'' даёт 1, то в сценарии значение этой переменной будет больше на 1, т.е. 2.<br />
'''''$TMOUT''''' — Если переменная окружения ''$TMOUT'' содержит ненулевое значение, то интерпретатор будет ожидать ввод не более чем заданное число секунд, что, в первичном приглашении (см.описание PS1 выше), может привести к автоматическому завершению сеанса работы. Начиная с версии 2.05b Bash, стало возможным использование $TMOUT в сценариях в комбинации с ''read''.
<source lang="bash">
# Работает только в сценариях Bash, начиная с версии 2.05b.
TMOUT=3 # Ожидание ввода не более трех секунд.
echo "Ваша любимая песня?"
echo "Вводите быстрее, у Вас только $TMOUT секунды на обдумывание!"
read song
if [ -z "$song" ]
then 
 song="(ответ не получен)" 
 # По-умолчанию.
fi
echo "Вам нравится $song."
</source>
Возможны и более сложные варианты организации организации ограничения времени ожидания ввода. Как один из вариантов, можно предложить организовать прерывание цикла ожидания по сигналу. Но это потребует написание функции обработки сигналов командой ''trap''.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Ограничения времени ожидания ввода.'''''</span></p>
<source lang="bash">
#!/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
</source>
В качестве альтернативы можно использовать stty.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Ещё один пример ограничения времени ожидания ввода от пользователя'''''</span></p>
<source lang="bash">
#!/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
</source>
Возможно самый простой способ — использовать опцию -t команды ''read''.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Ограничение времени ожидания команды read'''''</span></p>
<source lang="bash">
#!/bin/bash
# t-out.sh
TIMELIMIT=4 # 4 секунды
read -t $TIMELIMIT variable <&1
echo
if [ -z "$variable" ]
then
 echo "Время ожидания истекло."
else
 echo "variable = $variable"
fi
exit 0
</source>
'''''$UID''''' — user id number, UID (идентификатор) текущего пользователя, в соответствии с /etc/passwd
Это реальный UID текущего пользователя, даже если он временно приобрёл права другого пользователя с помощью su. Переменная $UID доступна только для чтения.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Я — root?'''''</span></p>
<source lang="bash">
#!/bin/bash
# am-i-root.sh: Root я, или не root?
ROOT_UID=0 # $UID root-а всегда равен 0.
if [ "$UID" -eq "$ROOT_UID" ] # Настоящий "root"?
then
 echo "- root!"
else
 echo "простой пользователь (но мамочка вас тоже любит)!"
fi
exit 0
# ============================================================= #
# Код, приведённый ниже, никогда не отработает,
# поскольку работа сценария уже завершилась выше
# Еще один способ отличить root-а от не root-а:
ROOTUSER_NAME=root
username=`id -nu` # Или... username=`whoami`
if [ "$username" = "$ROOTUSER_NAME" ]
then
 echo "Рутти-тутти. - root!"
else
 echo "Вы - лишь обычный юзер."
fi
</source>
Переменные ''$ENV'', ''$LOGNAME'', ''$MAIL'', ''$TERM'', ''$USER'' и ''$USERNAME'', не являются встроенными переменными Bash. Тем не менее, они часто инициализируются как переменные окружения в одном из стартовых файлов Bash. Переменная ''$SHELL'', командная оболочка пользователя, может задаваться в ''/etc/passwd'' или в сценарии "init" и она тоже не является встроенной переменной Bash!
<source lang="bash">
tcsh% echo $LOGNAME
bozo
tcsh% echo $SHELL
/bin/tcsh
tcsh% echo $TERM
rxvt
bash$ echo $LOGNAME
bozo
bash$ echo $SHELL
/bin/tcsh
bash$ echo $TERM
rxvt
</source>
* ''Позиционные параметры (аргументы)''
'''''$0''''', '''''$1''''', '''''$2''''' и т.д. — аргументы передаются... из командной строки в сценарий, функциям или команде set<br />
'''''$#''''' — Количество аргументов командной строки, или позиционных параметров<br />
'''''$*''''' — Все аргументы (позиционные параметры), в виде одной строки (слова)
"$*" — необходимо заключать в кавычки.<br />
'''''$@''''' — То же самое, что и "$*", но при этом каждый параметр представлен как отдельная строка(слово), т.е. параметры не подвергаются какой-либо интерпретации.
"$@" -- необходимо заключать в кавычки.<br />
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Я — root?'''''</span></p>
<source lang="bash">
#!/bin/bash
# Вызовите сценарий с несколькими аргументами, например: "один два три".
E_BADARGS=65
if [ ! -n "$1" ]
then
 echo "Порядок использования: `basename $0` argument1 argument2 и т.д."
exit $E_BADARGS
fi
echo
index=1
echo "Список аргументов в переменной \"\$*\":"
for arg in "$*" # Работает некорректно, если "$*" не ограничена кавычками.
do
 echo "Аргумент #$index = $arg"
 let "index+=1"
done # $* воспринимает все аргументы как одну строку.
echo "Полный список аргументов выглядит как одна строка."
echo
index=1
echo "Список аргументов в переменной \"\$@\":"
for arg in "$@"
do
echo "Аргумент #$index = $arg"
let "index+=1"
done # $@ воспринимает аргументы как отдельные строки (слова).
echo "Список аргументов выглядит как набор различных строк (слов)."
echo
exit 0
</source>
После команды ''shift'' (сдвиг), первый аргумент, в переменной "$@", теряется, а остальные сдвигаются на одну позицию "вниз" (или "влево", если хотите).
<source lang="bash">
#!/bin/bash
# Вызовите сценарий в таком виде: ./scriptname 1 2 3 4 5
echo "$@" # 1 2 3 4 5
shift
echo "$@" # 2 3 4 5
shift
echo "$@" # 3 4 5
# Каждая из команд "shift" приводит к потере аргумента $1,
# но остальные аргументы остаются в "$@".
</source>
Специальная переменная $@ может быть использована для выбора типа ввода в сценария. Команда cat "$@" позволяет выполнять ввод как со стандартного устройства ввода ''stdin'', так ииз файла, имя которого передаётся сценарию из командной строки. Переменные '''''$*''''' и '''''$@''''', в отдельных случаях, могут содержать противоречивую информацию! Это зависит от содержимого переменной '''''$IFS'''''.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Противоречия в переменных $* и $@'''''</span></p>
<source lang="bash">
#!/bin/bash
# Демонстрация противоречивости содержимого внутренних переменных "$*" и "$@",
# которая проявляется при изменении порядка заключения параметров в кавычки.
# Демонстрация противоречивости, проявляющейся при изменении
# содержимого переменной IFS.
set -- "Первый один" "второй" "третий:один" "" "Пятый: :один"
# Установка аргументов $1, $2, и т.д.
echo
echo 'IFS по-умолчанию, переменная "$*"'
c=0
for i in "$*" # в кавычках
do echo "$((c+=1)): [$i]" # Эта строка остается без изменений во всех циклах.
                          # Вывод аргументов.
done
echo ---
echo 'IFS по-умолчанию, переменная $*'
c=0
for i in $* # без кавычек
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS по-умолчанию, переменная "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS по-умолчанию, переменная $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---
IFS=:
echo 'IFS=":", переменная "$*"'
c=0
for i in "$*"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $*'
c=0
for i in $*
do echo "$((c+=1)): [$i]"
done
echo ---
var=$*
echo 'IFS=":", переменная "$var" (var=$*)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $var (var=$*)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
var="$*"
echo 'IFS=":", переменная $var (var="$*")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$var" (var="$*")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---
var=$@
echo 'IFS=":", переменная $var (var=$@)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$var" (var=$@)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
var="$@"
echo 'IFS=":", переменная "$var" (var="$@")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $var (var="$@")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo# Попробуйте запустить этот сценарий под ksh или zsh -y.
exit 0
# Это сценарий написан Stephane Chazelas,
# Незначительные изменения внесены автором документа.
</source>
'''''Различия между $@ и $* наблюдаются только тогда, когда они помещаются в двойные кавычки!'''''
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Содержимое $* и $@, когда переменная $IFS — пуста'''''</span></p>
<source lang="bash">
#!/bin/bash
# Если переменная $IFS инициализирована "пустым" значением,
# то "$*" и "$@" содержат аргументы не в том виде, в каком ожидается.
mecho () # Вывод аргументов.
{
 echo "$1,$2,$3";
}
IFS="" # Инициализация "пустым" значением.
set a b c # Установка аргументов.
mecho "$*" # abc,,
mecho $* # a,b,c
mecho $@ # a,b,c
mecho "$@" # a,b,c
# Поведение переменных $* и $@, при "пустой" $IFS, зависит
# от версии командной оболочки, Bash или sh.
# Поэтому, было бы неразумным пользоваться этой "фичей" в своих сценариях.
# Спасибо S.C.
exit 0
</source>
* ''Прочие специальные переменные''
'''''$-''''' — Список флагов, переданных сценарию (командой ''set'')
Эта конструкция изначально была введена в ksh, откуда перекочевала в Bash и, похоже, работает в Bash не совсем надежно. Единственное возможное применение — проверка запущен ли сценарий в интерактивном режиме.<br />
'''''$!''''' — PID последнего, запущенного в фоне, процесса
<source lang="bash">
LOG=$0.log
COMMAND1="sleep 100"
echo "Запись в лог всех PID фоновых процессов, запущенных из сценария: $0" >> "$LOG"
# Таким образом возможен мониторинг и удаление процессов по мере необходимости.
echo >> "$LOG"
# Команды записи в лог.
echo -n "PID of \"$COMMAND1\": " >> "$LOG"
${COMMAND1} &
echo $! >> "$LOG"
# PID процесса "sleep 100": 1506
# Спасибо Jacques Lederer за предложенный пример.
</source>
'''''$_''''' — Специальная переменная, содержит последний аргумент предыдущей команды.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Переменная "подчеркивание"'''''</span></p>
<source lang="bash">
#!/bin/bash
echo $_ # /bin/bash
        # Для запуска сценария был вызван /bin/bash.
du >/dev/null # Подавление вывода.
echo $_ # du
ls -al >/dev/null # Подавление вывода.
echo $_ # -al (последний аргумент)
:
echo $_ # :
</source>
'''''$?''''' — Код возврата команды, функции или скрипта<br />
'''''$$''''' — PID самого процесса-сценария. Переменная ''$$'' часто используется при генерации "уникальных" имён для временных файлов. Обычно это проще, чем вызов [[mktemp]].

=== Работа со строками ===
Bash поддерживает на удивление большое количество операций над строками. К сожалению, этот раздел Bash испытывает недостаток унификации. Одни операции являются подмножеством операций подстановки параметров, а другие — совпадают с функциональностью команды Unix — expr. Это приводит к противоречиям в синтаксисе команд и перекрытию функциональных возможностей, не говоря уже о возникающей путанице.

<big>'''Длина строки:'''</big>
<source lang="bash">
${#string}
expr length $string
expr "$string" : '.*'
stringZ=abcABC123ABCabcecho ${#stringZ} # 15
echo `expr length $stringZ` # 15
echo `expr "$stringZ" : '.*'`
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Вставка пустых строк между параграфами в текстовом файле.'''''</span></p>
<source lang="bash">
#!/bin/bash
# paragraph-space.sh
# Вставка пустых строк между параграфами в текстовом файле.
MINLEN=45 # Возможно потребуется изменить это значение.
# Строки, содержащие количество символов меньшее, чем $MINLEN
# принимаются за последнюю строку параграфа.
while read line # Построчное чтение файла от начала до конца...
do
 echo "$line" # Вывод строки.
 len=${#line}
 if [ "$len" -lt "$MINLEN" ]
  then echo # Добавление пустой строки после последней строки параграфа.
 fi
done
exit 0
</source>
<big>'''Длина подстроки в строке (подсчёт совпадающих символов ведётся с начала строки):'''</big><br />
<big>''expr match "$string" '$substring' ''</big>, где $substring — регулярное выражение.<br />
<big>''expr "$string" : '$substring' ''</big>, где $substring — регулярное выражение.<br />
<source lang="bash">
stringZ=abcABC123ABCabc
#       |------|
echo `expr match "$stringZ" 'abc[A-Z]*.2'` # 8
echo `expr "$stringZ" : 'abc[A-Z]*.2'` # 8
</source>
<big>'''Index:'''</big>
<br />Номер позиции первого совпадения в ''$string'' c первым символом в ''$substring'':<br />
<big>''expr index $string $substring''</big><br />
<source lang="bash">
stringZ=abcABC123ABCabc
echo `expr index "$stringZ" C12` # 6
                                 # позиция символа C.
echo `expr index "$stringZ" 1c` # 3
# символ 'c' (в #3 позиции) совпал раньше, чем '1'.
</source>
Эта функция довольно близка к функции strchr() в языке C.<br />
<big>'''Извлечение подстроки:'''</big><br />
<big>''${string:position}''</big><br />
Извлекает подстроку из ''$string'', начиная с позиции ''$position''.<br />
Если строка ''$string'' — "<big>'''*'''</big>" или "<big>'''@'''</big>", то извлекается позиционный параметр (аргумент), с номером ''$position''.<br />
<big>''${string:position:length}''</big><br />
Извлекает ''$length'' символов из ''$string'', начиная с позиции ''$position''.
<source lang="bash">
stringZ=abcABC123ABCabc
# 0123456789.....
# Индексация начинается с 0.
echo ${stringZ:0} # abcABC123ABCabc
echo ${stringZ:1} # bcABC123ABCabc
echo ${stringZ:7} # 23ABCabc
echo ${stringZ:7:3} # 23A
                    # Извлекает 3 символа.
# Возможна ли индексация с "правой" стороны строки?
echo ${stringZ:-4} # abcABC123ABCabc
# По-умолчанию выводится полная строка.
# Однако ...
echo ${stringZ:(-4)} # Cabc
echo ${stringZ: -4} # Cabc
# Теперь выводится правильно.
# Круглые скобки или дополнительный пробел "экранируют" параметр позиции.
# Спасибо Dan Jacobson, за разъяснения.
</source>
Если $string — "<big>'''*'''</big>" или "<big>'''@'''</big>", то извлекается до ''$length'' позиционных параметров (аргументов), начиная с ''$position''.
<source lang="bash">
echo ${*:2} # Вывод 2-го и последующих аргументов.
echo ${@:2} # То же самое.
echo ${*:2:3} # Вывод 3-х аргументов, начиная со 2-го.
</source><br />
<big>''expr substr $string $position $length''</big><br />
Извлекает ''$length'' символов из ''$string'', начиная с позиции ''$position''.
<source lang="bash">
stringZ=abcABC123ABCabc # 123456789......# Индексация начинается с 1.
echo `expr substr $stringZ 1 2` # ab
echo `expr substr $stringZ 4 3` # ABC
</source><br />
<big>''expr match "$string" '\($substring\)' ''</big><br />
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение.<br />
<big>''expr "$string" : '\($substring\)' ''</big><br />
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение.
<source lang="bash">
stringZ=abcABC123ABCabc
# =======
echo `expr match "$stringZ" '\(.[b-c]*[A-Z]..[0-9]\)'` # abcABC1
echo `expr "$stringZ" : '\(.[b-c]*[A-Z]..[0-9]\)'` # abcABC1
echo `expr "$stringZ" : '\(.......\)'` # abcABC1
# Все вышеприведённые операции дают один и тот же результат.
</source>
<big>''expr match "$string" '.*\($substring\)' ''</big><br />
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение. Поиск начинается с конца ''$string''.<br />
<big>''expr "$string" : '.*\($substring\)' ''</big><br />
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение. Поиск начинается с конца ''$string''.<br />
<source lang="bash">
stringZ=abcABC123ABCabc# ======
echo `expr match "$stringZ" '.*\([A-C][A-C][A-C][a-c]*\)'` # ABCabc
echo `expr "$stringZ" : '.*\(......\)'` # ABCabc
</source>
<big>'''Удаление части строки:'''</big><br />
<big>''${string#substring}''</big><br />
Удаление самой короткой, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с начала строки.<br />
<big>''${string##substring}''</big><br />
Удаление самой длинной, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся сначала строки.<br />
<source lang="bash">
stringZ=abcABC123ABCabc
#       |----|
#       |----------|
echo ${stringZ#a*C} # 123ABCabc
# Удаление самой короткой подстроки.
echo ${stringZ##a*C} # abc
# Удаление самой длинной подстроки.
</source>
<big>''${string%substring}''</big><br />
Удаление самой короткой, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с конца строки.<br />
<big>''${string%%substring}''</big><br />
Удаление самой длинной, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с конца строки.
<source lang="bash">
stringZ=abcABC123ABCabc
                     #||
#         |------------|
echo ${stringZ%b*c} # abcABC123ABCa
# Удаляется самое короткое совпадение. Поиск ведётся с конца $stringZ.
echo ${stringZ%%b*c} # a
# Удаляется самое длинное совпадение. Поиск ведётся с конца $stringZ.
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Преобразование графических файлов из одного формата в другой, с изменением имени файла.'''''</span></p>
<source lang="bash">
#!/bin/bash
# cvt.sh:
# Преобразование всех файлов в заданном каталоге,
# из графического формата MacPaint, в формат "pbm".
# Используется утилита "macptopbm", входящая в состав пакета "netpbm",
# который сопровождается Brian Henderson (bryanh@giraffe-data.com).
# Netpbm — стандартный пакет для большинства дистрибутивов Linux.
OPERATION=macptopbm
SUFFIX=pbm # Новое расширение файла.
if [ -n "$1" ]
then
 directory=$1 # Если каталог задан в командной строке при вызове сценария
else
 directory=$PWD # Иначе просматривается текущий каталог.
fi
# Все файлы в каталоге, имеющие расширение ".mac", считаются файлами
# формата MacPaint.
for file in $directory/* # Подстановка имен файлов.
do
 filename=${file%.*c} # Удалить расширение ".mac" из имени файла
                      # ( с шаблоном '.*c' совпадают все подстроки
                      # начинающиеся с '.' и заканчивающиеся 'c',
 $OPERATION $file > "$filename.$SUFFIX"
                      # Преобразование с перенаправлением в файл с новым именем
 rm -f $file          # Удаление оригинального файла после преобразования.
 echo "$filename.$SUFFIX" # Вывод на stdout.
done
exit 0
# Упражнение:
# --------
# Сейчас этот сценарий конвертирует *все* файлы в каталоге
# Измените его так, чтобы он конвертировал *только* те файлы,
# которые имеют расширение ".mac".
</source>
<big>'''Замена подстроки:'''</big><br />
<big>''${string/substring/replacement}''</big><br />
Замещает первое вхождение ''$substring'' строкой ''$replacement''.<br />
<big>''${string//substring/replacement}''</big><br />
Замещает все вхождения ''$substring'' строкой ''$replacement''.<br />
<source lang="bash">
stringZ=abcABC123ABCabc
echo ${stringZ/abc/xyz}  # xyzABC123ABCabc
                         # Замена первой подстроки 'abc' строкой 'xyz'.
echo ${stringZ//abc/xyz} # xyzABC123ABCxyz
                         # Замена всех подстрок 'abc' строкой 'xyz'.
</source>
<big>''${string/#substring/replacement}''</big><br />
Подстановка строки ''$replacement'' вместо ''$substring'', если строка ''$string'' начинается найденным соответствием. Поиск ведётся с начала строки ''$string''.<br />
<big>''${string/%substring/replacement}''</big><br />
Подстановка строки ''$replacement'' вместо ''$substring'', если строка ''$string'' заканчивается найденным соответствием. Поиск ведётся с конца строки ''$string''.
<source lang="bash">
stringZ=abcABC123ABCabc
echo ${stringZ/#abc/XYZ} # XYZABC123ABCabc
                         # Поиск ведется с начала строки
echo ${stringZ/%abc/XYZ} # abcABC123ABCXYZ
                         # Поиск ведется с конца строки
</source>
<big>'''Использование awk при работе со строками:'''</big><br />
В качестве альтернативы, Bash-скрипты могут использовать средства [[awk]] при работе со строками.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Альтернативный способ извлечения подстрок.'''''</span></p>
<source lang="bash">
#!/bin/bash
# substring-extraction.sh
String=23skidoo1
# 012345678 Bash
# 123456789 awk
# Обратите внимание на различия в индексации:
# Bash начинает индексацию с '0'.
# Awk начинает индексацию с '1'.
echo ${String:2:4} # с 3 позиции (0-1-2), 4 символа
                   # skid
# В эквивалент в awk: substr(string,pos,length).
echo | awk '
{ print substr("'"${String}"'",3,4) }' # skid
# Передача пустого "echo" по каналу в awk, означает фиктивный ввод,
# делая, тем самым, ненужным предоставление имени файла.
exit 0
</source>

=== Подстановка параметров ===
<big>'''Работа с переменными и/или подстановка их значений'''</big>
<br /><big><span style="color:red">'''''${parameter}'''''</span></big>
<br />То же самое, что и '''''$parameter''''', т.е. значение переменной ''parameter''. В отдельных случаях, при возникновении неоднозначности интерпретации, корректно будет работать только такая форма записи: '''''${parameter}'''''. Может использоваться для конкатенации (слияния) строковых переменных.
<source lang="bash">
your_id=${USER}-on-${HOSTNAME}
echo "$your_id"
#
echo "Старый \$PATH = $PATH"
PATH=${PATH}:/opt/bin #Добавление /opt/bin в $PATH.
echo "Новый \$PATH = $PATH"
</source>
<br /><big><span style="color:red">'''''${parameter-default}, ${parameter:-default}'''''</span></big>
<br />Если параметр отсутствует, то используется значение по-умолчанию.
<source lang="bash">
echo ${username-`whoami`}
# Вывод результата работы команды `whoami`, если переменная $username не установлена.
</source>
Формы записи '''''${parameter-default}''''' и '''''${parameter:-default}''''' в большинстве случаев можно считать эквивалентными. Дополнительный символ : имеет значение только тогда, когда ''parameter'' определён, но имеет "пустое" (null)значение.
<source lang="bash">
#!/bin/bash
username0=
# переменная username0 объявлена, но инициализирована "пустым" значением.
echo "username0 = ${username0-`whoami`}"
# Вывод после символа "=" отсутствует.
echo "username1 = ${username1-`whoami`}"
# Переменная username1 не была объявлена.
# Выводится имя пользователя, выданное командой `whoami`.
username2=
# переменная username2 объявлена, но инициализирована "пустым" значением.
echo "username2 = ${username2:-`whoami`}"
# Выводится имя пользователя, выданное командой `whoami`, поскольку
# здесь употребляется конструкция ":-" , а не "-".
exit 0
</source>
''Параметры по-умолчанию'' очень часто находят применение в случаях, когда сценарию необходимы какие-либо входные аргументы, передаваемые из командной строки, но такие аргументы не были переданы.
<source lang="bash">
DEFAULT_FILENAME=generic.data
filename=${1:-$DEFAULT_FILENAME}
# Если имя файла не задано явно, то последующие операторы будут работать
# с файлом "generic.data".
</source>

<br /><big><span style="color:red">'''''${parameter=default},${parameter:=default}'''''</span></big>
<br />Если значения параметров не заданы явно, то они принимают значения по-умолчанию. Оба метода задания значений по-умолчанию до определенной степени идентичны. Символ '':'' имеет значение только когда ''$parameter'' был инициализирован "пустым" (null) значением, как показано выше.
<source lang="bash">
echo ${username=`whoami`}
# Переменная "username" принимает значение, возвращаемое командой `whoami`.
</source>
<br /><big><span style="color:red">'''''${parameter+alt_value},${parameter:+alt_value}'''''</span></big>
<br />Если параметр имеет какое-либо значение, то используется ''alt_value'', иначе — null ("пустая" строка).
Оба варианта до определенной степени идентичны. Символ '':'' имеет значение только если ''parameter'' объявлен и "пустой".
<source lang="bash">
echo "###### \${parameter+alt_value} ########"
echo
a=${param1+xyz}
echo "a = $a" # a =
param2=
a=${param2+xyz}
echo "a = $a" # a = xyz
param3=123
a=${param3+xyz}
echo "a = $a" # a = xyz
echo
echo "###### \${parameter:+alt_value} ########"
echo
a=${param4:+xyz}
echo "a = $a" # a =
param5=
a=${param5:+xyz}
echo "a = $a" # a =
# Вывод отличается от a=${param5+xyz}
param6=123
a=${param6+xyz}
echo "a = $a" # a = xyz
</source>
<br /><big><span style="color:red">'''''${parameter?err_msg},${parameter:?err_msg}'''''</span></big>
<br />Если ''parameter'' инициализирован, то используется его значение, в противном случае — выводится ''err_msg''.
Обе формы записи можно, до определенной степени, считать идентичными. Символ '':'' имеет значение только когда ''parameter'' инициализирован "пустым" значением.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Подстановка параметров и сообщения об ошибках.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Проверка отдельных переменных окружения.
# Если переменная, к примеру $USER, не установлена,
# то выводится сообщение об ошибке.
: ${HOSTNAME?} ${USER?} ${HOME?} ${MAIL?}
echo
echo "Имя машины: $HOSTNAME."
echo "Ваше имя: $USER."
echo "Ваш домашний каталог: $HOME."
echo "Ваш почтовый ящик: $MAIL."
echo
echo "Если перед Вами появилось это сообщение,"
echo "то это значит, что все критические переменные окружения установлены."
echo
echo
# ------------------------------------------------------
# Конструкция ${variablename?} так же выполняет проверку
# наличия переменной в сценарии.
ThisVariable=Value-of-ThisVariable
# Обратите внимание, в строковые переменные могут быть записаны
# символы, которые запрещено использовать в именах переменных.
: ${ThisVariable?}
echo "Value of ThisVariable is $ThisVariable".
echo
echo
: ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
# Если ZZXy23AB не инициализирована,
# то сценарий завершается с сообщением об ошибке.
# Текст сообщения об ошибке можно задать свой.
# : ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
# То же самое: dummy_variable=${ZZXy23AB?}
#              dummy_variable=${ZZXy23AB?"Переменная ZXy23AB не инициализирована."}
#              echo ${ZZXy23AB?} >/dev/null
echo "Это сообщение не будет напечатано, поскольку сценарий завершится раньше."
HERE=0
exit $HERE # Сценарий завершит работу не здесь.
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Подстановка параметров и сообщение о "порядке использования".'''''</span></p>
<source lang="bash">
#!/bin/bash
# usage-message.sh
: ${1?"Порядок использования: $0 ARGUMENT"}
# Сценарий завершит свою работу здесь, если входные аргументы отсутствуют,
# со следующим сообщением.
# usage-message.sh: 1: Порядок использования: usage-message.sh ARGUMENT
echo "Эти две строки появятся, только когда задан аргумент в командной строке."
echo "Входной аргумент командной строки = \"$1\""
exit 0 # Точка выхода находится здесь, только когда задан аргумент командной строки.
# Проверьте код возврата в обеих случаях, с и без аргумента командной строки.
# Если аргумент задан, то код возврата будет равен 0.
# Иначе — 1.
</source>

<big>'''Подстановка параметров и/или экспансия.'''</big>
<br />Следующие выражения могут служить дополнениями оператора ''match'' команды ''expr'', применяемой к строкам. Как правило, они используются при разборе имён файлов и каталогов.
<br /><big>'''Длина переменной/Удаление подстроки.'''</big>
<br /><big><span style="color:red">'''''${#var}'''''</span></big>
<br />''String length'' (число символов в переменной ''$var''). В случае массивов, команда ''${#array}'' возвращает длину первого элемента массива.
<br />'''''Исключения:'''''<br />
* '''${#*}''' и '''${#@}''' возвращает количество аргументов (позиционных параметров).
* Для массивов, '''${#array[*]}''' и '''${#array[@]}''' возвращает количество элементов в массиве.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Длина переменной.'''''</span></p>
<source lang="bash">
#!/bin/bash
# length.sh
E_NO_ARGS=65if [ $# -eq 0 ] # Для работы скрипта необходим хотя бы один входной параметр.
then
 echo "Вызовите сценарий с одним или более параметром командной строки."
 exit $E_NO_ARGS
fi
var01=abcdEFGH28ij
echo "var01 = ${var01}"
echo "Length of var01 = ${#var01}"
echo "Количество входных параметров = ${#@}"
echo "Количество входных параметров = ${#*}"
exit 0
</source>
<br /><big><span style="color:red">'''''${var#Pattern},${var##Pattern}'''''</span></big>
<br />
Удаляет из переменной ''$var'' наименьшую/наибольшую подстроку, совпадающую с шаблоном ''$Pattern''. Поиск ведётся с начала строки ''$var''.
<source lang="bash">
# Функция из сценария "days-between.sh".
95
# Удаляет нули, стоящие в начале аргумента-строки.
strip_leading_zero () # Ведущие нули, которые могут находиться в номере дня/месяца, лучше удалить
{                     # В противном случае Bash будет интерпретировать числа как восьмеричные 
return=${1#0}         # "1" — это аргумент "$1".
}                     # "0" — это то, что удаляется из "$1" — ведущие нули.
</source>
'''Manfred Schwarb''' предложил более сложный вариант вышеприведенного кода:
<source lang="bash">
strip_leading_zero2 () # Удалить ведущие нули.
{
shopt -s extglob               # Переход в режим расширенной подстановки.
local val=${1##+(0)}           # Поиск самой длинной последовательности нулей.
shopt -u extglob               # выход из режима расширенной подстановки.
_strip_leading_zero2=${val:-0}
                               # Если был введен 0, то возвращается 0, а не "".
}
</source>
Другой пример:
<source lang="bash">
echo `basename $PWD`   # Имя текущего рабочего каталога.
echo "${PWD##*/}"      # Имя текущего рабочего каталога.
echo
echo `basename $0`     # Имя файла-сценария.
echo $0                # Имя файла-сценария.
echo "${0##*/}"        # Имя файла-сценария.
echo
filename=test.data
echo "${filename##*.}" # data
                       # Расширение файла.
</source>
<br /><big><span style="color:red">'''''${var%Pattern},${var%%Pattern}'''''</span></big>
<br />Удаляет из переменной ''$var'' наименьшую/наибольшую подстроку, совпадающую с шаблоном ''$Pattern''. Поиск ведётся с конца строки ''$var''.Bash версии 2 имеет ряд дополнительных возможностей.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Поиск по шаблону в подстановке параметров.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Поиск по шаблону в операциях подстановки параметров # ## % %%.
var1=abcd12345abc6789
pattern1=a*c # * (символ шаблона), означает любые символы между a и c.
echo
echo "var1 = $var1" # abcd12345abc6789
echo "var1 = ${var1}" # abcd12345abc6789 (альтернативный вариант)
echo "Число символов в ${var1} = ${#var1}"
echo "pattern1 = $pattern1" # a*c (между 'a' и 'c' могут быть любые символы)
echo
echo '${var1#$pattern1} =' "${var1#$pattern1}" # d12345abc6789
# Наименьшая подстрока, удаляются первые 3 символа abcd12345abc6789
                                  ^^^^^^           |-|
echo '${var1##$pattern1} =' "${var1##$pattern1}" # 6789
# Наибольшая подстрока, удаляются первые 12 символов abcd12345abc6789
#                                           ^^^^^^   |----------|
echo; echo
pattern2=b*9 # все, что между 'b' и '9'
echo "var1 = $var1" # abcd12345abc6789
echo "pattern2 = $pattern2"
echo
echo '${var1%pattern2} =' "${var1%$pattern2}" # abcd12345a
# Наименьшая подстрока, удаляются последние 6 символов abcd12345abc6789
#                                 ^^^^^^^^^                      |----|
echo '${var1%%pattern2} =' "${var1%%$pattern2}" # a
# Наибольшая подстрока, удаляются последние 12 символов abcd12345abc6789
#                                 ^^^^^^^^^              |-------------|
# Запомните, # и ## используются для поиска с начала строки,
# % и %% используются для поиска с конца строки.
echo
exit 0
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Изменение расширений в именах файлов.'''''</span></p>
<source lang="bash">
#!/bin/bash
# rfe
# ---
# Изменение расширений в именах файлов.
#
# rfe old_extension new_extension
# Пример:
# Изменить все расширения *.gif в именах файлов на *.jpg, в текущем каталоге
# rfe gif jpg
ARGS=2
E_BADARGS=65
if [ $# -ne "$ARGS" ]
then
 echo "Порядок использования: `basename $0` old_file_suffix new_file_suffix"
 exit $E_BADARGS
fi
for filename in *.$1
# Цикл прохода по списку имен файлов, имеющих расширение равное первому аргументу.
do
mv $filename ${filename%$1}$2
# Удалить первое расширение и добавить второе,
done
exit 0
</source>
<br /><big>'''Подстановка значений переменных / Замена подстроки'''</big>
<br />Эти конструкции перекочевали в Bash из ksh.
<br /><big><span style="color:red">'''''${var:pos}'''''</span></big>
<br />Подставляется значение переменной ''var'', начиная с позиции ''pos''.
<br /><big><span style="color:red">'''''${var:pos:len}'''''</span></big>
<br />Подставляется значение переменной ''var'', начиная с позиции ''pos'', не более ''len'' символов.
<br /><big><span style="color:red">'''''${var/Pattern/Replacement}'''''</span></big>
<br />Первое совпадение с шаблоном ''Pattern'', в переменной ''var'' замещается подстрокой ''Replacement''. Если подстрока ''Replacement'' отсутствует, то найденное совпадение будет удалено.
<br /><big><span style="color:red">'''''${var//Pattern/Replacement}'''''</span></big>
<br />'''Глобальная замена'''. Все найденные совпадения с шаблоном ''Pattern'', в переменной ''var'', будут замещены подстрокой ''Replacement''. Как и в первом случае, если подстрока ''Replacement'' отсутствует, то все найденные совпадения будут удалены.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Поиск по шаблону при анализе произвольных строк.'''''</span></p>
<source lang="bash">
#!/bin/bash
var1=abcd-1234-defg
echo "var1 = $var1"
t=${var1#*-*}
echo "var1 (все, от начала строки по первый символ \"-\", включительно, удаляется) = $t"
# t=${var1#*-} то же самое,
# поскольку оператор # ищет кратчайшее совпадение,
# а * соответствует любым предшествующим символам, включая пустую строку.
# (Спасибо S. C. за разъяснения.)
t=${var1##*-*}
echo "Если var1 содержит \"-\", то возвращается пустая строка... var1 = $t"
t=${var1%*-*}
echo "var1 (все, начиная с последнего \"-\" удаляется) = $t"
echo
# -------------------------------------------
path_name=/home/bozo/ideas/thoughts.for.today
# -------------------------------------------
echo "path_name = $path_name"
t=${path_name##/*/}
echo "Из path_name удален путь к файлу = $t"
# В данном случае, тот эе эффект можно получить так: t=`basename $path_name`
# t=${path_name%/}; t=${t##*/} более общее решение,
# но имеет некоторые ограничения.
# Если $path_name заканчивается символом перевода строки, то `basename $path_name` не будет работать,
# но для данного случая вполне применимо.
# (Спасибо S.C.)
t=${path_name%/*.*}
# Тот же эффект дает t=`dirname $path_name`
echo "Из path_name удалено имя файла = $t"
# Этот вариант будет терпеть неудачу в случаях: "../", "/foo////", # "foo/", "/".
# Удаление имени файла, особенно когда его нет,
# использование dirname имеет свои особенности.
# (Спасибо S.C.)
echo
t=${path_name:11}
echo "Из $path_name удалены первые 11 символов = $t"
t=${path_name:11:5}
echo "Из $path_name удалены первые 11 символов, выводится 5 символов = $t"
echo
t=${path_name/bozo/clown}
echo "В $path_name подстрока \"bozo\" заменена на \"clown\" = $t"
t=${path_name/today/}
echo "В $path_name подстрока \"today\" удалена = $t"
t=${path_name//o/O}
echo "В $path_name все символы \"o\" переведены в верхний регистр, = $t"
t=${path_name//o/}
echo "Из $path_name удалены все символы \"o\" = $t"
exit 0
</source>
<br /><big><span style="color:red">'''''${var/#Pattern/Replacement}'''''</span></big>
<br />Если в переменной ''var'' найдено совпадение с ''Pattern'', причём совпадающая подстрока расположена в начале строки (префикс), то оно заменяется на ''Replacement''. Поиск ведётся сначала строки.
<br /><big><span style="color:red">'''''${var/%Pattern/Replacement}'''''</span></big>
<br />Если в переменной ''var'' найдено совпадение с ''Pattern'', причём совпадающая подстрока расположена в конце строки (суффикс), то оно заменяется на ''Replacement''. Поиск ведётся с конца строки.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Поиск префиксов и суффиксов с заменой по шаблону.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Поиск с заменой по шаблону.
v0=abc1234zip1234abc # Начальное значение переменной.
echo "v0 = $v0"      # abc1234zip1234abc
echo
# Поиск совпадения с начала строки.
v1=${v0/#abc/ABCDEF} # abc1234zip1234abc
                     # |-|
echo "v1 = $v1"      # ABCDE1234zip1234abc
                     # |---|
# Поиск совпадения с конца строки.
v2=${v0/%abc/ABCDEF} # abc1234zip123abc
#                                   |-|
echo "v2 = $v2"      # abc1234zip1234ABCDEF
#                                    |----|
echo
# ----------------------------------------------------
# Если совпадение находится не с начала/конца строки,
# то замена не производится.
# ----------------------------------------------------
v3=${v0/#123/000}    # Совпадение есть, но не в начале строки.
echo "v3 = $v3"      # abc1234zip1234abc
                     # ЗАМЕНА НЕ ПРОИЗВОДИТСЯ!
v4=${v0/%123/000}    # Совпадение есть, но не в конце строки.
echo "v4 = $v4"      # abc1234zip1234abc
                     # ЗАМЕНА НЕ ПРОИЗВОДИТСЯ!
exit 0
</source>
<br /><big><span style="color:red">'''''${!varprefix*},${!varprefix@}'''''</span></big>
<br />Поиск по шаблону всех, ранее объявленных переменных, имена которых начинаются с ''varprefix''.
<source lang="bash">
xyz23=whatever
xyz24=
a=${!xyz*}         # Подстановка имен объявленных переменных, которые начинаются с "xyz".
echo "a = $a"      # a = xyz23 xyz24
a=${!xyz@}         # То же самое.
echo "a = $a"      # a = xyz23 xyz24
# Эта возможность была добавлена в Bash, в версии 2.04.
</source>

=== Объявление переменных: declare и typeset ===
Инструкции '''declare''' и '''typeset''' являются встроенными инструкциями (они абсолютно идентичны друг другу и являются синонимами) и предназначена для наложения ограничений на переменные. Это очень слабая попытка контроля над типами, которая имеется во многих языках программирования. Инструкция '''declare''' появилась в Bash, начиная с версии 2. Кроме того, инструкция '''typeset''' может использоваться и в ksh-сценариях.
<big>'''Ключи инструкций declare/typeset'''</big>
<br /><big><span style="color:red">'''''<big>-r</big> readonly (только для чтения)'''''</span></big>
<br />'''''declare -r var1'''''
<br />(declare -r var1 аналогично объявлению readonly var1). 
<br />Это грубый эквивалент констант (''const'') в языке C. Попытка изменения таких переменных завершается сообщением об ошибке.
<br /><big><span style="color:red">'''''<big>-i</big> integer'''''</span></big>
<br />'''''declare -i number'''''
 # Сценарий интерпретирует переменную "number" как целое число.
 number=3
 echo "number = $number"  # number = 3
 number=three
 echo "number = $number"  # number = 0
 # Строка "three" интерпретируется как целое число.
Допускается выполнение некоторых арифметических операций над переменными, объявленными как integer, не прибегая к инструкциям ''expr'' или ''let''.
 n=6/3
 echo "n = $n" # n = 6/3
 declare -i n
 n=6/3
 echo "n = $n" # n = 2
<big><span style="color:red">'''''<big>-a</big> array'''''</span></big>
<br />'''''declare -a indices'''''
<br />Переменная ''indices'' объявляется массивом.
<br /><big><span style="color:red">'''''<big>-f</big> functions'''''</span></big>
<br />'''''declare -f'''''
<br />Инструкция ''declare -f'', без аргументов, приводит к выводу списка ранее объявленных функций в сценарии.
<br />'''''declare -f function_name'''''
<br />Инструкция ''declare -f function_name'' выводит имя функции ''function_name'', если она была объявлена ранее.
<br /><big><span style="color:red">'''''<big>-x</big> export'''''</span></big>
<br />'''''declare -x var3'''''
<br />Эта инструкция объявляет переменную, как доступную для экспорта.
<br /><big><span style="color:red">'''''<big>-x</big> var=$value'''''</span></big>
<br />'''''declare -x var3=373'''''
<br />Инструкция ''declare'' допускает совмещение объявления и присваивания значения переменной одновременно.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Объявление переменных с помощью инструкции declare.'''''</span></p>
<source lang="bash">
#!/bin/bash
func1 ()
{
echo Это функция.
}
declare -f               # Список функций, объявленных выше.
echo
declare -i var1          # var1 — целочисленная переменная.
var1=2367
echo "переменная var1 объявлена как $var1"
var1=var1+1              # Допустимая арифметическая операция над целочисленными переменными.
echo "переменная var1 увеличена на 1 = $var1."
                         # Допустимая операция для целочисленных переменных
echo "Возможно ли записать дробное число 2367.1 в var1?"
var1=2367.1              # Сообщение об ошибке, переменная не изменяется.
echo "значение переменной var1 осталось прежним = $var1"
echo
declare -r var2=13.36    # инструкция 'declare' допускает установку свойств переменной
                         # и одновременно присваивать значение.
echo "var2 declared as $var2" # Допускается ли изменять значение readonly переменных?
var2=13.37               # Сообщение об ошибке и завершение работы сценария.
echo "значение переменной var2 осталось прежним $var2" # Эта строка никогда не будет выполнена.
exit 0                   # Сценарий завершит работу выше.
</source>

=== Косвенные ссылки на переменные ===
Предположим, что значение одной переменной — есть имя второй переменной. Возможно ли получить значение второй переменной через обращение к первой?<br /> Например, пусть ''a=letter_of_alphabet'' и ''letter_of_alphabet=z'', тогда вопрос будет звучать так:<br />"Возможно ли получить значение ''z'', обратившись к переменной ''a''?". <br />В действительности это возможно и это называется ''косвенной ссылкой''. Для этого необходимо прибегнуть к несколько необычной нотации ''eval var1=\$$var2''.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Косвенные ссылки.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Косвенные ссылки на переменные.
a=letter_of_alphabet
letter_of_alphabet=z
echo
# Прямое обращение к переменной.
echo "a = $a"
# Косвенное обращение к переменной.
eval a=\$$a
echo "А теперь a = $a"
echo
# Теперь попробуем изменить переменную, на которую делается ссылка.
t=table_cell_3
table_cell_3=24
echo "\"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# В данном, простом, случае,
# eval t=\$$t; echo "\"t\" = $t"
# даёт тот же результат (почему?).
echo
t=table_cell_3
NEW_VAL=387
table_cell_3=$NEW_VAL
echo "Значение переменной \"table_cell_3\" изменено на $NEW_VAL."
echo "Теперь \"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# инструкция "eval" принимает два аргумента "echo" и "\$$t" (назначает равным $table_cell_3)
echo
# (Спасибо S.C. за разъяснения.)
# Ещё один способ — нотация ${!t}, будет обсуждаться в разделе "Bash, версия 2".
exit 0
</source>

<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Передача косвенных ссылок в awk.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Другая версия сценария "column totaler"
# который суммирует заданную колонку (чисел) в заданном файле.
# Здесь используются косвенные ссылки.
ARGS=2
E_WRONGARGS=65
if [ $# -ne "$ARGS" ] # Проверка количества входных аргументов.
then
 echo "Порядок использования: `basename $0` filename column-number"
 exit $E_WRONGARGS
fi
filename=$1
column_number=$2
#===== До этой строки идентично первоначальному варианту сценария =====#
# Многострочные скрипты awk вызываются конструкцией awk ' ..... '
# Начало awk-сценария.
# ------------------------------------------------
awk "
{ total += \$${column_number} # косвенная ссылка
}
END {  
      print total
    }
   " "$filename"
# ------------------------------------------------
# Конец awk-сценария.
# Косвенные ссылки делают возможным бесконфликтное
# обращение к переменным shell внутри вложенных сценариев awk.
# Спасибо Stephane Chazelas.
exit 0
</source>
Такой метод обращения к переменным имеет свои особенности. Если переменная, на которую делается ссылка, меняет свое значение, то переменная которая ссылается, должна быть должным образом разыменована, т.е. должна быть выполнена операция получения ссылки, как это делается в примере выше. К счастью, нотация ''${!variable}'', введённая в Bash, начиная с версии 2 позволяет выполнять косвенные ссылки более интуитивно понятным образом.

=== $RANDOM: генерация псевдослучайных целых чисел ===
'''$RANDOM''' — внутренняя функция Bash (не константа), которая возвращает ''псевдослучайные целые числа'' в диапазоне 0—32767. Функция '''$RANDOM''' ''не должна'' использоваться для генерации ключей шифрования.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Генерация случайных чисел.'''''</span></p>
<source lang="bash">
#!/bin/bash
# $RANDOM возвращает различные случайные числа при каждом обращении к ней.
# Диапазон изменения: 0—32767 (16-битовое целое со знаком).
MAXCOUNT=10
count=1
echo
echo "$MAXCOUNT случайных чисел:"
echo "-----------------"
while [ "$count" -le $MAXCOUNT ] # Генерация 10 ($MAXCOUNT) случайных чисел.
do
 number=$RANDOM
 echo $number
 let "count += 1" # Нарастить счетчик.
done
echo "-----------------"
# Если вам нужны случайные числа не превышающие определенного числа,
# воспользуйтесь оператором деления по модулю (остаток от деления).
RANGE=500
echo
number=$RANDOM
let "number %= $RANGE"
echo "Случайное число меньше $RANGE —— $number"
echo
# Если вы желаете ограничить диапазон "снизу",
# то просто производите генерацию псевдослучайных чисел в цикле до тех пор,
# пока не получите число большее нижней границы.
FLOOR=200
number=0 # инициализация
while [ "$number" -le $FLOOR ]
do
 number=$RANDOM
done
echo "Случайное число, большее $FLOOR —— $number"
echo
# Эти два способа могут быть скомбинированы.
number=0 #initialize
while [ "$number" -le $FLOOR ]
do
 number=$RANDOM
 let "number %= $RANGE" # Ограничение "сверху" числом $RANGE.
done
echo "Случайное число в диапазоне от $FLOOR до $RANGE —— $number"
echo
# Генерация случайных "true" и "false" значений.
BINARY=2
number=$RANDOMT=1
let "number %= $BINARY"
# let "number >>= 14" даёт более равномерное распределение
# (сдвиг вправо смещает старший бит на нулевую позицию, остальные биты
обнуляются).
if [ "$number" -eq $T ]
then
 echo "TRUE"
else
 echo "FALSE"
fi
echo
# Можно имитировать бросание 2-х игровых кубиков.
SPOTS=7 # остаток от деления на 7 дает диапазон 0 - 6.
ZERO=0
die1=0
die2=0
# Кубики "выбрасываются" раздельно.
while [ "$die1" -eq $ZERO ] # Пока на "кубике" ноль.
do
 let "die1 = $RANDOM % $SPOTS" # Имитировать бросок первого кубика.
done
while [ "$die2" -eq $ZERO ]
do
 let "die2 = $RANDOM % $SPOTS" # Имитировать бросок второго кубика.
done
let "throw = $die1 + $die2"
echo "Результат броска кубиков = $throw"
echo
exit 0
</source>
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Выбор случайной карты из колоды.'''''</span></p>
<source lang="bash">
#!/bin/bash
# pick-card.sh
# Пример выбора случайного элемента массива.
# Выбор случайной карты из колоды.
Suites="Треф 
Бубей 
Червей 
Пик"
Denominations="2
3
4
5
6
7
8
9
10
Валет
Дама
Король
Туз"
# Инициализация массивов.
suite=($Suites) 
denomination=($Denominations)
num_suites=${#suite[*]} # Количество элементов массивов.
num_denominations=${#denomination[*]}
echo -n "${denomination[$((RANDOM%num_denominations))]} "
echo ${suite[$((RANDOM%num_suites))]}
# $bozo sh pick-cards.sh
# Валет Треф
# Спасибо "jipe," за пояснения по работе с $RANDOM.
exit 0
</source>
'''''Jipe''''' подсказал ещё один способ генерации случайных чисел из заданного диапазона.
<source lang="bash">
# Генерация случайных чисел в диапазоне 6—30.
rnumber=$((RANDOM%25+6))
# Генерируется случайное число из диапазона 6—30,
# но при этом число должно делиться на 3 без остатка.
rnumber=$(((RANDOM%30/3+1)*3))
# Примечательно, если $RANDOM возвращает 0
# то это приводит к возникновению ошибки.
# Упражнение: Попробуйте разобраться с выражением самостоятельно.
</source>
'''''Bill Gradwohl''''' предложил усовершенствованную формулу генерации положительных псевдослучайных чисел в заданном диапазоне.
<source lang="bash">
rnumber=$(((RANDOM%(max-min+divisibleBy))/divisibleBy*divisibleBy+min))
</source>
В сценарии ниже, '''''Bill''''' представил универсальную функцию, которая возвращает псевдослучайное число из заданного диапазона.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Псевдослучайное число из заданного диапазона.'''''</span></p>
<source lang="bash">
#!/bin/bash
# random-between.sh
# Псевдослучайное число из заданного диапазона.
# Автор: Bill Gradwohl,
# незначительные изменения внесены автором документа.
# Используется с разрешения автора сценария.
randomBetween() {
# Генерация положительных и отрицательных псевдослучайных чисел,
# в диапазоне от $min до $max,
# которые кратны числу $divisibleBy.
#
# Bill Gradwohl — Oct 1, 2003
syntax() {
# Вложенная функция.
echo
echo "Порядок вызова: randomBetween [min] [max] [multiple]"
echo
echo "Функция ожидает до 3-х входных аргументов, но они не являются обязательными."
echo "min — нижняя граница диапазона"
echo "max — верхняя граница диапазона"
echo "multiple — делитель, на который должен делиться результат без остатка."
echo
echo "Если какой либо из параметров отсутствует, по-умолчанию принимаются значения: 0 32767 1"
echo "В случае успеха функция возвращает 0, иначе — 1"
echo "и это сообщение о порядке вызова."
echo "Результат возвращается в глобальной переменной randomBetweenAnswer"
echo "Входные параметры, имеющие отрицательные значения, обрабатываются корректно."
}
local min=${1:-0}
local max=${2:-32767}
local divisibleBy=${3:-1}
# При отсутствии какого-либо из входных параметров, они принимают значения по-умолчанию.
local x
local spread
# Делитель должен быть положительным числом.
[ ${divisibleBy} -lt 0 ] && divisibleBy=$((0-divisibleBy))
# Проверка корректности входных параметров.
if [ $# -gt 3 -o ${divisibleBy} -eq 0 -o ${min} -eq ${max} ]; then
 syntax
 return 1
fi
# Если min больше чем max, то поменять их местами.
if [ ${min} -gt ${max} ]; then
 # Поменять местами.
 x=${min}
 min=${max}
 max=${x}
fi
# Если min не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((min/divisibleBy*divisibleBy)) -ne ${min} ]; then
 if [ ${min} -lt 0 ]; then
  min=$((min/divisibleBy*divisibleBy))
 else
  min=$((((min/divisibleBy)+1)*divisibleBy))
 fi
fi
# Если max не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((max/divisibleBy*divisibleBy)) -ne ${max} ]; then
 if [ ${max} -lt 0 ]; then
  max=$((((max/divisibleBy)-1)*divisibleBy))
 else
  max=$((max/divisibleBy*divisibleBy))
 fi
fi
# ---------------------------------------------------------------------
# А теперь собственно нахождение псевдослучайного числа.
# Обратите внимание: чтобы получить псевдослучайное число в конце диапазона
# необходимо рассматривать диапазон от 0 до
# abs(max-min)+divisibleBy, а не abs(max-min)+1.
# Этим превышением верхней границы диапазона можно пренебречь
# поскольку эта новая граница никогда не будет достигнута.

# Если использовать при вычислении формулу abs(max-min)+1,
# то будут получаться вполне корректные значения, но при этом,
# возвращаемые значения будут значительно ниже
# верхней границы диапазона.
# ---------------------------------------------------------------------
spread=$((max-min))
[ ${spread} -lt 0 ] && spread=$((0-spread))
let spread+=divisibleBy
randomBetweenAnswer=$(((RANDOM%spread)/divisibleBy*divisibleBy+min))
return 0
}
# Проверка функции.
min=-14
max=20
divisibleBy=3
# Создадим массив, который будет содержать счетчики встречаемости каждого из чисел
# в заданном диапазоне.
declare -a answer
minimum=${min}
maximum=${max}
if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then
 if [ ${minimum} -lt 0 ]; then
  minimum=$((minimum/divisibleBy*divisibleBy))
 else
  minimum=$((((minimum/divisibleBy)+1)*divisibleBy))
 fi
fi

# Если max не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then
 if [ ${maximum} -lt 0 ]; then
  maximum=$((((maximum/divisibleBy)-1)*divisibleBy))
 else
  maximum=$((maximum/divisibleBy*divisibleBy))
 fi
fi

# Необходимое условие при работе с массивами —
# индекс массива должен быть положительным числом,
# поэтому введена дополнительная переменная displacement, которая
# гарантирует положительность индексов.
displacement=$((0-minimum))
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
 answer[i+displacement]=0
done
# Цикл с большим количеством итераций, чтобы посмотреть - что мы получаем.
loopIt=1000 # Автор сценария предложил 100000 итераций,
            # но в этом случае цикл работает чересчур долго.
for ((i=0; i<${loopIt}; ++i)); do
# Обратите внимание: числа min и max передаются функции в обратном порядке,
# чтобы продемонстрировать, что функция обрабатывает их корректно.
 randomBetween ${max} ${min} ${divisibleBy}
# Вывод сообщения об ошибке, если функция вернула некорректное значение.
 [ ${randomBetweenAnswer} -lt ${min} -o ${randomBetweenAnswer} -gt ${max} ] && echo Выход за границы диапазона MIN .. MAX - ${randomBetweenAnswer}!
 [ $((randomBetweenAnswer%${divisibleBy})) -ne 0 ] && echo Число не делится на заданный делитель без остатка - ${randomBetweenAnswer}!
# Записать полученное число в массив.
 answer[randomBetweenAnswer+displacement]=$((answer[randomBetweenAnswer+displacement]+1))
done
# Проверим полученные результаты
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
 [ ${answer[i+displacement]} -eq 0 ] && echo "Число $i не было получено ни разу." || echo "Число ${i} встречено ${answer[i+displacement]} раз."
done
exit 0
</source>
Насколько случайны числа, возвращаемые функцией $RANDOM? Лучший способ оценить"случайность" генерируемых чисел — это написать сценарий, который будет имитировать бросание игрального кубика достаточно большое число раз, а затем выведет количество выпадений каждой из граней...
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Имитация бросания кубика с помощью RANDOM.'''''</span></p>
<source lang="bash">
#!/bin/bash
# Случайные ли числа возвращает RANDOM?
RANDOM=$$ # Инициализация генератора случайных чисел числом PID процесса-сценария.
PIPS=6 # Кубик имеет 6 граней.
MAXTHROWS=600 # Можете увеличить, если не знаете куда девать свое время.
throw=0 # Счётчик бросков.
zeroes=0 # Обнулить счётчики выпадения отдельных граней.
ones=0 # т.к. неинициализированные переменные - "пустые", и не равны нулю!.
twos=0
threes=0
fours=0
fives=0
sixes=0

print_result ()
{
 echo
 echo "единиц = $ones"
 echo "двоек = $twos"
 echo "троек = $threes"
 echo "четвёрок = $fours"
 echo "пятёрок = $fives"
 echo "шестёрок = $sixes"
 echo
}

update_count()
{
 case "$1" in
  0) let "ones += 1";; # 0 соответствует грани "1".
  1) let "twos += 1";; # 1 соответствует грани "2", и так далее
  2) let "threes += 1";;
  3) let "fours += 1";;
  4) let "fives += 1";;
  5) let "sixes += 1";;
 esac
}

echo

while [ "$throw" -lt "$MAXTHROWS" ]
do
 let "die1 = RANDOM % $PIPS"
 update_count $die1
 let "throw += 1"
done

print_result
# Количество выпадений каждой из граней должно быть примерно одинаковым, если считать RANDOM достаточно случайным.
# Для $MAXTHROWS = 600, каждая грань должна выпасть примерно 100 раз (плюс-минус 20).
#
# Имейте ввиду, что RANDOM - это генератор ПСЕВДОСЛУЧАЙНЫХ чисел,
# Упражнение:
# ---------------
# Перепишите этот сценарий так, чтобы он имитировал 1000 бросков монеты.
# Перепишите этот сценарий так, чтобы он имитировал 1000 бросков монеты.
# На каждом броске возможен один из двух вариантов выпадения — "ОРЁЛ" или "РЕШКА".
exit 0
</source>
Как видно из последнего примера, неплохо было бы производить переустановку начального числа генератора случайных чисел RANDOM перед тем, как начать работу с ним. Если используется одно и тоже начальное число, то генератор RANDOM будет выдавать одну и ту же последовательность чисел.(Это совпадает с поведением функции random() в языке C.)
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Переустановка RANDOM.'''''</span></p>
<source lang="bash">
#!/bin/bash
# seeding-random.sh: Переустановка переменной RANDOM.
MAXCOUNT=25 # Длина генерируемой последовательности чисел.

random_numbers ()
{
 count=0
 while [ "$count" -lt "$MAXCOUNT" ]
 do
  number=$RANDOM
  echo -n "$number "
  let "count += 1"
 done
}

echo; echo
RANDOM=1 # Переустановка начального числа генератора случайных чисел RANDOM.
random_numbers
echo; echo
RANDOM=1 # То же самое начальное число...
random_numbers # ...в результате получается та же последовательность чисел.
               # В каких случаях может оказаться полезной генерация совпадающих серий?
echo; echo
RANDOM=2 # Ещё одна попытка, но с другим начальным числом...
random_numbers # получим другую последовательность.
echo; echo
# RANDOM=$$ в качестве начального числа выбирается PID процесса-сценария.
# Вполне допустимо взять в качестве начального числа результат работы команд 'time' или 'date'.
# Немного воображения...
SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')
# Псевдослучайное число забирается
# из системного генератора псевдослучайных чисел /dev/urandom,
# затем конвертируется в восьмеричное число командой "od",
# и наконец "awk" возвращает единственное число для переменной SEED.
RANDOM=$SEED
random_numbers
echo; echo
exit 0
</source>
Системный генератор ''/dev/urandom'' даёт последовательность псевдослучайных чисел с более равномерным распределением, чем $RANDOM. Команда ''[[dd]] if=/dev/urandom of=targetfile bs=1count=XX'' создаёт файл, содержащий последовательность псевдослучайных чисел. Однако, эти числа требуют дополнительной обработки, например с помощью команды [[od]] (этот приём используется в примере выше) или [[dd]]. Есть и другие способы генерации псевдослучайных последовательностей в сценариях. [[Awk]] имеет для этого достаточно удобные средства.
<p style="text-align:center"><span style="color:green"> '''Пример'''</span>: <span style="color:red">'''''Получение псевдослучайных чисел с помощью awk.'''''</span></p>
<source lang="bash">
#!/bin/bash
# random2.sh: Генерация псевдослучайных чисел в диапазоне 0 - 1.
# Используется функция rand() из awk.
AWKSCRIPT=' { srand(); print rand() } '
# Команды/параметры, передаваемые awk
# Обратите внимание, функция srand() переустанавливает начальное число генератора случайных чисел
echo -n "Случайное число в диапазоне от 0 до 1 = "
echo | awk "$AWKSCRIPT"
exit 0
# Упражнения:
# ---------
# 1) С помощью оператора цикла выведите 10 различных случайных чисел.
# (Подсказка: вам потребуется вызвать функцию "srand()"
# в каждом цикле с разными начальными числами.
# Что произойдет, если этого не сделать?)
# 2) Заставьте сценарий генерировать случайные числа в диапазоне 10 - 100
# используя целочисленный множитель, как коэффициент масштабирования
# 3) То же самое, что и во втором упражнении,
# но на этот раз случайные числа должны быть целыми.
</source>
Кроме того, команда [[date]] так же может использоваться для генерации ''псевдослучайных целых чисел''.

=== Двойные круглые скобки ===

== Циклы и ветвления ==
=== Циклы ===
=== Вложенные циклы ===
=== Управление ходом выполнения цикла ===
=== Операторы выбора ===
== Внутренние команды ==
=== Команды управления заданиями ===
== Внешние команды, программы и утилиты ==
=== Базовые команды ===
=== Более сложные команды ===
=== Команды для работы с датой и временем ===
=== Команды обработки текста ===
=== Команды для работы с файлами и архивами ===
=== Команды для работы с сетью ===
=== Команды управления терминалом ===
=== Команды выполнения математических операций ===
=== Прочие команды ===
== Команды системного администрирования ==
== Подстановка команд ==
== Арифметические подстановки ==
== Перенаправление ввода/вывода ==
=== С помощью команды exec ===
=== Перенаправление для блоков кода ===
=== Область применения ===
== Встроенные документы ==
= Часть четвёртая. Материал повышенной сложности =
== Регулярные выражения ==
=== Краткое введение в регулярные выражения ===
=== Globbing -- Подстановка имен файлов ===
== Подоболочки или Subshells ==
== Ограниченный режим командной оболочки ==
== Подстановка процессов ==
== Функции ==
=== Сложные функции и сложности с функциями ===
=== Локальные переменные ===
=== Рекурсия без локальных переменных ===
== Псевдонимы ==
== Списки команд ==
== Массивы ==
== Файлы ==
== /dev и /proc ==
=== /dev ===
=== /proc ===
== /dev/zero и /dev/null ==
== Отладка сценариев ==
== Необязательные параметры(ключи) ==
== Широко распространенные ошибки ==
== Стиль программирования ==
=== Неофициальные рекомендации по оформлению сценариев ===
== Разное ==
=== Интерактивный и неинтерактивный режим работы ===
=== Сценарии-обертки ===
=== Операции сравнения: Альтернативные решения ===
=== Рекурсия ===
=== "Цветные" сценарии ===
=== Оптимизация ===
=== Разные советы ===
=== Проблемы безопасности ===
=== Проблемы переносимости ===
=== Сценарии командной оболочки под Windows ===
== Bash, версия 2 ==
= Замечания и дополнения =
== От автора ==
== Об авторе ==
== Куда обращаться за помощью ==
== Инструменты, использовавшиеся при создании книги ==
=== Аппаратура ===
=== Программное обеспечение ===
== Благодарности ==
= Библиография =
== Дополнительные примеры сценариев ==
== Справочная информация ==
== Маленький учебник по Sed и Awk ==
=== Sed ===
=== Awk ===
== Коды завершения, имеющие предопределённый смысл ==
== Подробное введение в операции ввода-вывода и перенаправление ввода-вывода ==
== Системные каталоги ==
== Локализация ==
== История команд ==
== Пример файла .bashrc ==
== Преобразование пакетных (*.bat) файлов DOS в сценарии командной оболочки ==
== Упражнения ==
=== Анализ сценариев ===
=== Создание сценариев ===
== Хронология ==
== Авторские права ==