Bash - основы

Использование Case.sh

#!/bin/bash
# Использование Case
 
case "$variable" in
abc) echo "$variable = abc" ;;
xyz) echo "$variable = xyz" ;;
esac

Ограничение времени ожидания команды read.sh

#!/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

REPLY.sh

#!/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

Цикл в фоне.sh

#!/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

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

#!/bin/bash
while :
do
echo "Бесконечный цикл"
done

Вложенные блоки и перенаправление ввода-вывода.sh

#!/bin/bash
# Чтение строк из файла /etc/fstab.
 
File=/etc/fstab
 
{
read line1
read line2
} < $File
 
echo "Первая строка в $File :"
echo "$line1"
echo
echo "Вторая строка в $File :"
echo "$line2"
 
exit 0

Вставка пустых строк между параграфами в текстовом файле.sh

#!/bin/bash
# paragraph-space.sh
 
# Вставка пустых строк между параграфами в текстовом файле.
# Порядок использования: $0 <FILENAME
 
MINLEN=45 # Возможно потребуется изменить это значение.
# Строки, содержащие количество символов меньшее, чем $MINLEN
#+ принимаются за последнюю строку параграфа.
 
while read line # Построчное чтение файла от начала до конца...
do
echo "$line" # Вывод строки.
 
len=${#line}
if [ "$len" -lt "$MINLEN" ]
then echo # Добавление пустой строки после последней строки параграфа.
fi
done
 
exit 0

Вывод списка аргументов с помощью переменных $* и [email protected]

#!/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

Коды завершения.sh

#!/bin/bash
 
echo hello
echo $? # код возврата = 0, поскольку команда выполнилась успешно.
 
lskdf # Несуществующая команда.
echo $? # Ненулевой код возврата, поскольку команду выполнить не удалось.
 
echo
 
exit 113 # Явное указание кода возврата 113.
# Проверить можно, если набрать в командной строке "echo $?"
# после выполнения этого примера.

логическая инверсии кода возврата.sh

#!/bin/bash
true # встроенная команда "true".
echo "код возврата команды \"true\" = $?" # 0
 
! true
echo "код возврата команды \"! true\" = $?" # 1
# Обратите внимание: символ "!" от команды необходимо отделять пробелом.
# !true вызовет сообщение об ошибке "command not found"

Наибольший общий делитель.sh

#!/bin/bash
# поиск наибольшего общего делителя
# по алгоритму Эвклида
 
# Под "наибольшим общим делителем" (нод) двух целых чисел
#+ понимается наибольшее целое число, которое делит оба делимых без остатка.
 
# Алгоритм Эвклида выполняет последовательное деление.
# В каждом цикле,
#+ делимое <--- делитель
#+ делитель <--- остаток
#+ до тех пор, пока остаток не станет равным нулю (остаток = 0).
#+ The gcd = dividend, on the final pass.
 
# ------------------------------------------------------
# Проверка входных параметров
ARGS=2
E_BADARGS=65
 
if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` первое-число второе-число"
exit $E_BADARGS
fi
# ------------------------------------------------------
 
 
gcd ()
{
 
# Начальное присваивание.
dividend=$1 # В сущности, не имеет значения
divisor=$2 #+ какой из них больше.
# Почему?
 
remainder=1 # Если переменные неинициализировать,
#+ то работа сценария будет прервана по ошибке
#+ в первом же цикле.
 
until [ "$remainder" -eq 0 ]
do
let "remainder = $dividend % $divisor"
dividend=$divisor # Повторить цикл с новыми исходными данными
divisor=$remainder
done # алгоритм Эвклида
 
} # последнее $dividend и есть нод.
 
 
gcd $1 $2
 
echo; echo "НОД чисел $1 и $2 = $dividend"; echo
 
exit 0

Ограничения времени ожидания ввода от пользователя-2.sh

#!/bin/bash
 
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
 
# Каждое нажатие на клавишу вызывает сброс счетчика в начальное состояние.
# Возможно самый простой способ -- использовать опцию -t команды read.
exit 0

Операции сравнения.sh

#!/bin/bash
# сравнение целых чисел
 
#-eq
# равно
if [ "$a" -eq "$b" ]
#-ne
# не равно
if [ "$a" -ne "$b" ]
#-gt
# больше
if [ "$a" -gt "$b" ]
# -ge
# больше или равно
if [ "$a" -ge "$b" ]
# -lt
# меньше
if [ "$a" -lt "$b" ]
#-le
# меньше или равно
if [ "$a" -le "$b" ]
# <
# меньше (внутри двойных круглых скобок )
(("$a" < "$b"))
# <=
# меньше или равно (внутри двойных круглых скобок)
(("$a" <= "$b"))
# >
# больше (внутри двойных круглых скобок)
(("$a" > "$b"))
# >=
# больше или равно (внутри двойных круглых скобок)
(("$a" >= "$b"))

От 1 до 6 пятью различными способами.sh

#!/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
 
exit 0

очистка файла.sh

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

Перебор всех аргументов командной строки.sh

#!/bin/bash
# Использование команды 'shift' с целью перебора всех аргументов командной строки.
 
# Назовите файл с этим сценарием, например "shft",
#+ и вызовите его с набором аргументов, например:
# ./shft a b c def 23 skidoo
 
until [ -z "$1" ] # До тех пор пока не будут разобраны все входные аргументы...
do
echo -n "$1 "
shift
done
 
echo # Дополнительная пустая строка.
 
exit 0

Подстановка параметров и сообщения об ошибках.sh

#!/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 # Сценарий завершит работу не здесь.

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

#!/bin/bash
 
your_id=${USER}-on-${HOSTNAME}
echo "$your_id"
 
echo "Старый \$PATH = $PATH"
PATH=${PATH}:/opt/bin #Добавление /opt/bin в $PATH.
echo "Новый \$PATH = $PATH"

посимвольное ASCI-сравнение.sh

#!/bin/bash
 
veg1=carrots
veg2=tomatoes
 
if [[ "$veg1" < "$veg2" ]]
then
echo "Не смотря на то, что в словаре слово $veg1 предшествует слову $veg2,"
echo "это никак не отражает мои кулинарные предпочтения."
else
echo "Интересно. Каким словарем вы пользуетесь?"
fi

Последовательное выполнение команд.sh

#!/bin/bash
# Последовательное выполнение команд
echo hello; echo there

Построение сложных условий, использующих && и ||.sh

#!/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.)
 
 
if [ "$a" -eq 98 ] || [ "$b" -eq 47 ]
then
echo "Вторая проверка прошла успешно."
else
echo "Вторая проверка не прошла."
fi
 
 
# Опции -a и -o предоставляют
#+ альтернативный механизм проверки условий.
 
 
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

Проверка наличия переданных аргументов.sh

#!/bin/bash
if [ $# -lt "$MINPARAMS" ]
then
echo
echo "Количество аргументов командной строки должно быть не менее $MINPARAMS !"
fi
echo "Программа запущена"
exit 0

Проверка наличия файла.sh

#!/bin/bash
file=/etc/passwd
 
if [[ -e $file ]]
then
echo "Файл паролей найден."
fi
exit 0

проверка условий.sh

#!/bin/bash
 
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

Простой способ обращения к последнему аргументу.sh

#!/bin/bash
args=$# # Количество переданных аргументов.
lastarg=${!args} # Обратите внимание: lastarg=${!$#} неприменимо.

Различные представления числовых констант.sh

#!/bin/bash
# Различные представления числовых констант.
 
# Десятичное: по-умолчанию
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

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

#!/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

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

#!/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

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

#!/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

я root.sh

#!/bin/bash
 
ROOT_UID=0 # $UID root-а всегда равен 0.
 
if [ "$UID" -eq "$ROOT_UID" ] # Настоящий "root"?
then
echo "- root!"
else
echo "простой пользователь!"
fi
 
exit 0

я root2.sh

#!/bin/bash
ROOTUSER_NAME=root
 
username=`id -nu` # Или... username=`whoami`
if [ "$username" = "$ROOTUSER_NAME" ]
then
echo "Вы root!"
else
echo "Вы - обычный юзер."
fi