Полное руководство по Bash: от основ к продвинутым темам

Введение

Bash (Bourne Again SHell) — это одна из самых популярных Unix-оболочек, широко используемая для запуска команд и написания скриптов в Linux и macOS. Скрипты Bash позволяют автоматизировать рутинные задачи, объединять команды в программы и управлять системой через командную строку. Данное руководство последовательно познакомит вас с основами Bash (синтаксис, переменные, условия, циклы и т.д.), а затем перейдет к продвинутым возможностям (таким как настройка strict mode, использование trap-обработчиков, планирование задач через cron и др.). Мы рассмотрим практические примеры скриптов, сопровождая их поясняющими комментариями, чтобы у вас сложилось цельное понимание создания надежных Bash-скриптов.

t.me/linuxkalii – мой тг канал, где я объяcняю сложные концепции и код с помощью короткий видео и картинок:

Замечание о примерах: Во всех примерах ниже предполагается, что вы работаете в среде Unix/Linux и используете Bash. Убедитесь, что скриптам присвоены права на выполнение (chmod +x script.sh), а в первой строке указан shebang (#!/bin/bash), указывающий систему, какой интерпретатор использовать для запуска скрипта. Например:

#!/bin/bash
# Простой пример Bash-скрипта
echo "Привет, мир!"

Теперь перейдем к изучению Bash более подробно — от базового синтаксиса до тонкостей написания устойчивых и эффективных скриптов.

Базовые команды и синтаксис Bash

Структура команд. В Bash каждая команда имеет формат: команда [опции] [аргументы]. Команды вводятся либо по одной в строке, либо могут быть разделены точкой с запятой ;. Для объединения команд по логике выполнения используются операторы && (выполнить следующую команду только если предыдущая завершилась успешно) и || (выполнить следующую команду только если предыдущая не удалась).

Например:

mkdir /tmp/test && echo "Каталог создан" || echo "Ошибка создания каталога"

В примере выше сообщение об успешном создании выведется только если mkdir отработал без ошибок, а сообщение об ошибке – если каталог создать не удалось.

Комментарии. Все, что следует после символа #, воспринимается как комментарий и игнорируется интерпретатором. Используйте комментарии, чтобы пояснять сложные части скрипта и делать код понятным.

Регистр и специальные символы. Bash чувствителен к регистру: VAR и var — разные имена. Многие специальные символы имеют особое значение в Bash (|, >, <, *, & и т.д.), их использование обсудим далее. Если нужно передать такой символ как обычный текст, его следует экранировать обратным слешем \ или заключить в кавычки.

Основные команды shell. Прежде чем писать скрипты, важно уверенно чувствовать себя с базовыми командами CLI, так как скрипт часто просто автоматизирует вызов этих утилит. Вот несколько часто используемых команд и их назначения:

• ls – список файлов в директории (опции -l для подробного вывода, -a для показа скрытых файлов и т.д.).
• cd – смена текущей директории (например, cd /home/user).
• pwd – вывод текущего пути (рабочей директории).
• cp – копирование файлов или каталогов (cp источник назначение), mv – перемещение или переименование, rm – удаление.
• cat – вывод содержимого файла, less/more – постраничный просмотр текста.
• echo – вывод текста/значения переменной в консоль.
• man – показ справки (мануала) по команде, например man ls откроет руководство по команде ls.

Эти команды можно свободно комбинировать в скриптах. Например, следующая строка выведет число строк в файле messages.log:

wc -l messages.log

Команда wc -l подсчитывает количество строк во входных данных, а мы передали ей файл, указав его имя.

Используя эти основы синтаксиса и команд, можно создавать простые однострочные скрипты. Далее мы рассмотрим, как усложнять логику скриптов с помощью переменных, условий и других конструкций.

Объявление и использование переменных

Создание переменных. В Bash переменная создается присваиванием: ИМЯ=значение. Например:

name="Виктор"
greeting="Привет, $name!"

Знак $ используется для получения значения переменной. В примере во вторую переменную greeting будет сохранена строка “Привет, Виктор!”. Обратите внимание: вокруг знака равенства = нельзя ставить пробелы – иначе Bash воспримет это не как присваивание, а как попытку запуска программы с именем ИМЯ.

Виды кавычек. Если значение содержит пробелы или специальные символы, его нужно брать в кавычки.

• Двойные кавычки " " позволяют подставлять переменные и интерпретируют спецсимволы (\n как перевод строки и т.д.).
• Одинарные кавычки ' ' берут текст как есть (любой текст внутри них не будет интерпретирован, переменные в одинарных кавычках не подставляются).

Например, path="$HOME/Documents" подставит значение переменной $HOME, а 'User $HOME' останется буквальным текстом User $HOME.

Всегда старайтесь заключать переменные в кавычки при использовании, если только не требуется другое поведение. Кавычки защитят содержимое переменной от расщепления на слова по пробелам и от интерпретации спецсимволовrus-linux.net. Например, без кавычек строка $var1 $var2 может быть разбита на множество аргументов, а в кавычках "${var1} ${var2}" это будет единый аргумент (включающий пробел).

Использование переменных. Для доступа к значению переменной перед ее именем ставится $. Можно также обрамлять имя в фигурные скобки ${VAR}, что бывает необходимо для отделения имени от последующего текста. Например, если X=5, то echo "$Xfiles" не сработает (попытается вывести переменную Xfiles), а echo "${X}files" выведет 5files.

Переменные окружения. По умолчанию переменные, созданные в скрипте, видны только самому этому скрипту (и его дочерним процессам). Чтобы сделать переменную переменной окружения (глобальной для всех подпроцессов), используют команду export. Экспортированная переменная будет доступна дочерним процессам скрипта (другим запущенным из него программам или скриптам)baeldung.com. Например:

export API_TOKEN="abc123"   # делаем API_TOKEN доступной внешним программам

Теперь любая программа, запущенная из этого скрипта, сможет читать переменную API_TOKEN из своего окружения. Многие системные переменные, такие как PATH (пути поиска программ), HOME (домашний каталог) или USER (имя пользователя), являются переменными окружения, доступными в любой сессии Bash.

Специальные переменные Bash. Bash предоставляет ряд встроенных специальных переменных:

• $? — код выхода последней выполненной команды (0 означает успех, любое ненулевое значение – ошибка).
• $0 — имя текущего скрипта.
• $1, $2, … $N — позиционные параметры, переданные скрипту (подробнее в следующем разделе).
• $# — количество переданных скрипту аргументов.
• $@ — все аргументы скрипта списком (каждый отдельно).
• $* — все аргументы как единая строка. Различия между $@ и $* проявляются при использовании в кавычках.

Эти переменные помогают в обработке аргументов, состояния выполнения команд и другой информации в скрипте.

Ниже мы рассмотрим, как применять позиционные параметры $1, $2 и другие для обработки входных аргументов скрипта.

Работа с аргументами и флагами

Скрипты Bash могут принимать аргументы из командной строки. Например, если запустить ./myscript.sh input.txt output.txt, то внутри скрипта $1 будет равен input.txt, а $2 – output.txt. Число аргументов доступно через $#.

Обработка позиционных параметров. Простейший способ использовать аргументы – обращаться к $1, $2 и т.д. напрямую. Например:

#!/bin/bash
# simple_args.sh - пример использования аргументов
if [[ $# -lt 2 ]]; then
  echo "Использование: $0 <файл-источник> <файл-назначение>"
  exit 1
fi

src_file="$1"
dst_file="$2"
cp "$src_file" "$dst_file"
echo "Скопирован $src_file в $dst_file"

Здесь мы проверяем, что передано как минимум 2 аргумента ($# -lt 2), иначе выводим подсказку использования ($0 – имя скрипта) и выходим. Затем используем $1 и $2 для получения пути исходного и целевого файла и копируем их. Так реализуется простой копирующий скрипт.

Циклическая обработка аргументов. Если количество аргументов заранее неизвестно, можно пройтись по ним в цикле. Специальные переменные $@ (или эквивалентно "$@" в кавычках, что предпочтительнее) содержат все аргументы как отдельные слова. Например:

for arg in "$@"; do
    echo "Аргумент: $arg"
done

Этот цикл выведет все аргументы по очереди. Конструкция shift позволяет сдвигать позиционные параметры влево (то есть $2 становится $1 и так далее), что удобно для последовательной обработки неизвестного числа аргументов.

Флаги (опции) и getopts. Позиционные параметры подходят для обязательных аргументов, но для опциональных флагов (например, -h для помощи или -v для verbose-режима) лучше использовать встроенный механизм getopts. Команда getopts упрощает разбор флагов и опций скрипта, автоматически разбирая короткие опции. Она последовательно перебирает указанные опции и задает переменные для их значений.

getopts является встроенной командой Bash, которая облегчает обработку коротких опций, проводит валидацию ввода и автоматически присваивает значения специальной переменной $OPTARG (для аргумента опции)zerotomastery.io. В отличие от внешней утилиты getopt, встроенный getopts гарантирует одинаковое поведение на разных системах, что делает скрипты более портируемыми.

Ниже приведен небольшой пример использования getopts для разбора опций -u <user> и -p <password>:

#!/bin/bash
# Пример: разбор опций -u и -p с помощью getopts
user=""
pass=""
while getopts "u:p:h" opt; do
  case $opt in
    u) user="$OPTARG" ;;      # сохранили аргумент опции -u
    p) pass="$OPTARG" ;;      # сохранили аргумент опции -p
    h) echo "Использование: $0 -u <имя> -p <пароль>"; exit 0 ;;
    \?) echo "Неизвестная опция: -$OPTARG"; exit 1 ;;
  esac
done

echo "Пользователь: $user"
echo "Пароль: $pass"

В строке while getopts "u:p:h" opt; do определена опция -u с требованием аргумента (u:), опция -p с аргументом (p:) и опция -h без аргумента (обычно для вывода help). Внутри case мы обрабатываем каждую опцию: для -h сразу выводим подсказку и выходим. Переменная $OPTARG содержит значение аргумента для текущей опции (если предусмотрено двоеточием в строке опций). После завершения getopts переменная $user будет заполнена, если был указан -u, и аналогично $pass для -p.

Такой подход делает скрипт более гибким и удобным для пользователя, позволяя передавать параметры в любом порядке с понятными флагами. Если же требуется поддержка длинных опций (например --help), придется использовать внешнюю команду getopt или разбирать аргументы вручную, поскольку встроенный getopts работает только с односимвольными флагами.

После разбора аргументов можно переходить к выполнению основной логики скрипта, используя полученные значения. Далее мы рассмотрим конструкции, позволяющие управлять потоком выполнения: условные операторы и циклы.

Условные конструкции и циклы

Условные операторы (if, case). Bash предоставляет классический if-then-else для ветвления исполнения. Синтаксис следующий:

if условие; then
    # команды если условие истинно
elif другое_условие; then
    # команды если первое ложно, а это истинно
else
    # команды если все вышеперечисленные условия ложны
fi

Пример условного оператора: допустим, скрипт проверяет существование файла:

if [[ -f "$1" ]]; then
    echo "Файл $1 существует."
elif [[ -d "$1" ]]; then
    echo "$1 является директорией."
else
    echo "Объект $1 не найден."
fi

Здесь [[ -f "$1" ]] проверяет, является ли первый аргумент именем существующего файла, -d — существующей директорией. В зависимости от результата выводится разное сообщение. Мы использовали двойные квадратные скобки [[ ... ]], которые в Bash предпочтительнее одинарных [ ... ] (команда test), поскольку позволяют более гибкие проверки (например, шаблоны == *.txt) и безопаснее обрабатывают строки с пробелами и спецсимволами.

Проверки в условиях. Условие в if обычно представляет собой команду. Возвратный код команды (0 или не 0) определяет истинность: 0 считается «истинно», ненулевой код — «ложно». Часто используется команда test (она же [ ... ]) или встроенный [[ ... ]]. Основные проверки:

• Файловые: -f FILE (файл существует и это не директория), -d FILE (директория существует), -e FILE (существует), -s FILE (не пустой файл), -r/-w/-x FILE (файл доступен на чтение/запись/исполнение).
• Строковые: STR1 = STR2 (строки равны), STR1 != STR2 (не равны), -z STR (строка пустая), -n STR (строка не пустая).
• Целочисленные: INT1 -eq INT2 (равны), -ne (не равны), -lt / -le (меньше / меньше или равно), -gt / -ge (больше / больше или равно).
• Логические операторы: && (И) и || (ИЛИ) для объединения нескольких условий (внутри [[ ... ]] можно писать cond1 && cond2), а также унарный ! для отрицания условия.

Можно также использовать конструкцию if COMMAND; then ... напрямую с любой командой: тогда условие считается истинным, если команда завершилась успешно (код 0). Например, if grep -q "ERROR" logfile; then echo "Есть ошибки"; fi – выполнит echo только если grep нашел совпадение (флаг -q подавляет вывод, интересен лишь код возврата grep).

Многопутевой выбор (case). Для проверки значения переменной на несколько возможных шаблонов удобно использовать case. Синтаксис:

case "$VAR" in
  шаблон1) 
    # команды, если $VAR соответствует шаблон1
    ;;
  шаблон2|другой_шаблон) 
    # команды для шаблон2 *или* другого_шаблона
    ;;
  *) 
    # команды по умолчанию (если ни один шаблон не совпал)
    ;;
esac

Шаблоны могут включать символы подстановки (*, ?). Например:

case "$1" in
  start)   echo "Запуск службы...";;
  stop)    echo "Остановка службы...";;
  status)  echo "Статус службы: активен.";;
  *)       echo "Использование: $0 {start|stop|status}"; exit 1;;
esac

Если скрипт получить первым аргументом start, выполнится соответствующая ветка, если что-то другое — выводится инструкция по использованию.

Циклы (for, while, until). Циклы позволяют повторять группу команд.

• for используется для перебора списка значений. Простейший пример: for user in alice bob charlie; do echo "Отправляем письмо пользователю $user" done Этот цикл трижды выполнит тело, подставляя в $user поочередно alice, bob, charlie. Обычно список задается явно, генерируется с помощью {..} или получается из результатов команды. Например, for f in *.txt; do echo "Текстовый файл: $f"; done переберет все файлы с расширением .txt в директории.
• while выполняет команды, пока условие истинно. Например, простой счетчик: counter=5 while [[ $counter -gt 0 ]]; do echo "Обратный отсчет: $counter" ((counter--)) # уменьшаем counter на 1 done echo "Старт!" Здесь цикл выполняется, пока переменная counter больше 0. В теле мы выводим значение и уменьшаем его. Как только counter станет 0, условие [[ $counter -gt 0 ]] станет ложным, и цикл завершится. Конструкция ((counter--)) — это арифметическое сокращение для уменьшения значения (аналогично counter=$((counter-1))).
• until похож на while, но выполняется, пока условие ложно. То есть until CONDITION; do ...; done эквивалентен while ! CONDITION; do .... Используется редко, можно обойтись while ! ....

В циклах можно использовать операторы break (выйти из цикла досрочно) и continue (пропустить оставшиеся команды в теле и перейти к следующей итерации).

Пример: пусть у нас список файлов, и мы хотим найти первый файл больше 1 МБ:

for file in *; do
    if [[ -f "$file" && $(stat -c%s "$file") -gt 1000000 ]]; then
        echo "Найден большой файл: $file"
        break    # выходим, т.к. нашли первый подходящий
    fi
done

Здесь stat -c%s выводит размер файла в байтах, мы сравниваем с 1_000_000. Когда условие выполняется, используем break для выхода из цикла.

Объединяя условия и циклы, можно выразить практически любую логику: от простых проверок до сложных последовательностей операций. Чтобы не дублировать код и сделать скрипт модульным, Bash позволяет определять функции, чему посвящен следующий раздел.

Функции и структурирование скриптов

Для организации кода в Bash-скриптах используются функции. Функция — это именованный блок кода, который можно вызывать по имени так же, как вызвали бы команду. Благодаря функциям скрипт можно разбить на логические части, избежать повторения кода и улучшить читаемость.

Определение функций. Синтаксис объявления функции:

имя_функции() {
    # тело функции
    # можно использовать команды, условия, циклы
}

После определения, функцию можно вызвать по имени: имя_функции аргументы. Пример:

#!/bin/bash
# Пример определения и вызова функции

# Функция для приветствия
greet() {
    local person="$1"    # локальная переменная person, первая аргумент-функции
    echo "Здравствуйте, $person!"
}

greet "Алиса"            # Вызов функции с параметром "Алиса"
greet "Боб"              # Вызов функции с другим параметром

Вывод скрипта будет:

Здравствуйте, Алиса!
Здравствуйте, Боб!

Обратите внимание: мы использовали local person="$1". По умолчанию все переменные в Bash глобальные, т.е. видимы во всем скрипте (и даже в вызываемых из него функциях). Ключевое слово local ограничивает область видимости переменной рамками функции. Это хорошая практика – объявлять внутри функции свои переменные через local, чтобы избежать конфликтов имен с остальным скриптом.

Аргументы функций. Функция получает свои аргументы так же, как скрипт – через $1, $2, …, а $0 внутри функции все равно указывает на имя всего скрипта. Вызвав greet "Алиса", внутри greet $1 будет “Алиса”. Внешние позиционные параметры скрипта при этом не теряются. Если нужно передать все аргументы из функции дальше, можно использовать $@ внутри функции, который развернется в список ее аргументов.

Возврат значения. Функция может возвращать код выхода (число от 0 до 255) с помощью команды return. По умолчанию код выхода функции — это код выхода последней выполненной в ней команды. Но return удобен, чтобы явно указать успешность/ошибку. Например, return 0 для успеха, return 1 для ошибки. Этот код можно проверить после вызова функции через $?. Важно: return не предназначен для возвращения вычисленного результата (например, строки или числа). Чтобы “вернуть” вычисленное значение из функции, обычно используют вывод: например, echo внутри функции, а в месте вызова используют подстановку команд result=$(имя_функции). Либо присваивают глобальной переменной внутри функции.

Пример возвращения результата через вывод:

# Функция вычисления квадрата числа
square() {
    local num=$1
    echo $(( num * num ))
}
result=$(square 5)
echo "5^2 = $result"

Здесь функция square печатает результат, а в строке вызова мы заключили вызов в $( ), поэтому stdout функции попадает в переменную result.

Структура скрипта. В больших скриптах принято оформлять код структурированно:

• Сначала идут настройки (например, включение опций, о которых далее, и экспорт переменных окружения, если нужно).
• Затем определения функций (они должны быть объявлены до первого использования).
• В конце – основной код скрипта, который может вызвать нужные функции. Часто последняя часть оформляется как функция main() для удобства.

Например, структура может выглядеть так:

#!/bin/bash
set -euo pipefail            # строгий режим (пояснение ниже)

# Конфигурация
SOURCE_DIR="/important/data"
BACKUP_DIR="/backups"

# Функции
log() {
    echo "$(date '+%F %T') | $*"
}
do_backup() {
    local fname="backup-$(date '+%Y%m%d-%H%M%S').tar.gz"
    tar -czf "$BACKUP_DIR/$fname" "$SOURCE_DIR"
}

# Основная логика
log "Начало резервного копирования"
if do_backup; then
    log "Бэкап успешно создан."
else
    log "Ошибка при создании бэкапа!"
fi

Здесь:

• Мы включили строгий режим set -euo pipefail (о нем далее).
• Объявили несколько глобальных переменных с настройками.
• Определили функцию log для протоколирования (печатает сообщение с меткой времени) и функцию do_backup для выполнения бэкапа (создание tar.gz архива).
• В основной части вызываем функции и используем условие, чтобы вывести разное сообщение в зависимости от успеха операции.

Подобное разбиение делает скрипт чище и удобнее для сопровождения: настройки, функции и выполняемый код отделены логически. В следующем разделе мы рассмотрим, как обрабатывать ошибки и отлаживать скрипты, чтобы наши функции и основной код работали надёжно.

Обработка ошибок и отладка

Скрипты Bash склонны продолжать выполнение даже при возникновении ошибок, что может приводить к непредвиденным последствиям. Рассмотрим, как сделать скрипты более надежными, своевременно обнаруживать и обрабатывать ошибки, а также как проводить отладку.

Коды выхода и проверка ошибок. Каждая команда в Unix возвращает код выхода (exit status). По соглашению 0 означает успех, а любое ненулевое значение – код ошибки. В Bash код последней выполненной команды хранится в $?. Например:

cp /source/file /dest/dir
status=$?
if [[ $status -ne 0 ]]; then
    echo "Ошибка: не удалось копировать файл (код $status)" >&2
    exit 1
fi

Здесь мы вручную проверяем код $?. Однако Bash предлагает более лаконичный способ: использовать if прямо с командой или логические операторы. Пример эквивалентной записи:

if ! cp /source/file /dest/dir; then
    echo "Ошибка: не удалось копировать файл" >&2
    exit 1
fi

Условие if ! командa сработает, если команда завершилась неуспешно (оператор ! инвертирует статус). Также можно записать через || (OR):

cp /source/file /dest/dir || { echo "Ошибка копирования" >&2; exit 1; }

Это прочитается как: “выполнить cp, или если он вернул ошибку – выполнить блок в фигурных скобках”. Такой однострочник часто применяется для простых проверок.

Опция set -e (exit on error). Постоянно писать ручные проверки утомительно. Для критичных сценариев есть механизм строгого режима. Команда set -e велит Bash автоматически прерывать выполнение скрипта, если любая команда завершилась с ошибкой. Это не распространяется на команды внутри условных выражений, в правой части &&/|| и некоторых других случаев, но в целом значительно повышает отказоустойчивость скрипта, предотвращая дальнейшее выполнение после ошибкиdigitalocean.com. Добавьте set -e в начало скрипта, чтобы включить этот режим по умолчанию.

Однако, будьте внимательны: set -e выйдет из скрипта при первой же неудачной команде. Иногда ошибки ожидаемы и не фатальны – тогда либо отключайте временно set +e, либо обрабатывайте конкретные команды через условие/||, чтобы Bash не соч считал их “непойманной” ошибкой.

Опция set -u. Еще один флаг: set -u (или полная форма set -o nounset) заставляет Bash генерировать ошибку при обращении к неопределенной переменной. Без этой опции опечатка в имени переменной приведет к подстановке пустой строки и может остаться незамеченной, а с -u скрипт сразу прекратится с ошибкой. Это помогает отлавливать опечатки и случаи, когда вы забыли инициализировать переменную. Обычно -u включают вместе с -e в “строгом режиме”.

Опция set -o pipefail. По умолчанию в конвейерах (cmd1 | cmd2 | cmd3) кодом выхода всего пайпа считается код последней команды (cmd3), даже если cmd1 или cmd2 ошиблись. Опция set -o pipefail меняет это поведение: кодом выхода конвейера станет ненулевой код первой неуспешной команды в пайпе (или 0, если все успешно). Это важно, чтобы не пропустить ошибку в середине пайплайна. Обычно также включается в строгом режиме. Итоговая комбинация в начале скрипта часто выглядит так:

set -euo pipefail

Эта одна строка сразу активирует три важных проверки: выход при ошибке, выход при неопределенной переменной, корректную обработку ошибок в конвейерах. Использование подобного “строгого режима” рекомендуется для большинства скриптовdigitalocean.com.

Обработка с помощью trap. Команда trap позволяет задать обработчики на различные сигналы или события, такие как выход скрипта. Например, можно выполнить определенные команды при получении сигнала прерывания (SIGINT, Ctrl+C) или перед завершением скрипта по любой причине (EXIT). Эта техника полезна для корректной очистки ресурсов: удаление временных файлов, разблокировка ресурсов и т.д. Например:

temp_file="/tmp/myapp.$$"   # временный файл ($$ – PID текущего процесса)
trap 'rm -f "$temp_file"' EXIT   # удалить временный файл при выходе

Здесь мы устанавливаем ловушку на событие EXIT — когда скрипт закончится (нормально или из-за ошибки), выполнится команда rm -f "$temp_file". Таким образом, мы гарантированно приберем временный файлdigitalocean.com. Можно повесить обработчики и на конкретные сигналы, например:

trap 'echo "Прервано Ctrl+C"; exit 1' SIGINT

Теперь при нажатии Ctrl+C вместо мгновенного убийства скрипта, он выведет сообщение и выйдет аккуратно с кодом 1.

Вывод ошибок в stderr. По соглашению, скрипт должен разделять обычный вывод и сообщения об ошибках. Обычные результаты идут в стандартный поток вывода (stdout), а ошибки – в стандартный поток ошибок (stderr). Чтобы вывести текст в stderr, можно использовать echo с перенаправлением >&2:

echo "Ошибка: что-то пошло не так" >&2

Это важно, потому что stderr не перенаправляется в пайплайнах по умолчанию и позволяет отделить логи ошибок от данных. В дальнейших примерах мы использовали >&2 для сообщений об ошибках.

Отладка скриптов. Даже опытные авторы скриптов сталкиваются с непредвиденным поведением. Для отладки Bash предоставляет несколько возможностей:

• Trace mode (set -x). Если включить set -x, Bash начнет печатать в терминал каждую выполняемую команду с подставленными значениями аргументов. Это очень помогает понять, на каком месте скрипта что-то пошло не так. Обычно эту опцию включают временно перед подозрительным участком, а потом отключают set +x, чтобы не засорять вывод лишним. Например: set -x # включаем трассировку # ... ряд команд ... set +x # отключаем трассировку Когда set -x активно, вы будете видеть строки вида + cmd arg1 arg2 перед выполнением каждой командыdigitalocean.com.
• Проверка синтаксиса. Перед запуском сложного скрипта полезно выполнить bash -n script.sh – это проверит синтаксическую корректность без выполнения. Если есть пропущенная fi или неверная конструкция, Bash об этом сообщит.
• Интерактивная отладка. Можно запускать скрипт пошагово с выводом строк с помощью bash -x -v script.sh. Ключ -v заставит печатать строки скрипта перед выполнением (a -x — команды после подстановки переменных). В сочетании дают подробный лог.
• Отладочные сообщения. Вручную добавляйте временные echo в сложных местах, выводя значения переменных: echo "DEBUG: var=$var" >&2. Это поможет понять, какие данные проходят через скрипт. Позже такие строки можно убрать или закомментировать.
• Использование линтера. Существует утилита shellcheck, которая автоматически находит распространенные ошибки, потенциальные баги (например, забытые кавычки или опечатки). Запустите shellcheck script.sh для анализа скрипта – она выдаст предупреждения и рекомендации.

Комбинируя эти приемы, вы сможете быстро диагностировать проблемы. Например, если скрипт неожиданно прерывается, стоит включить set -x и set -e вместе, чтобы увидеть последнюю выполненную команду перед аварийным выходом. Или если результат не тот, можно напечатать ключевые переменные.

Подведем итог по надежности: Всегда проверяйте ошибки команд (вручную или через set -e), давайте ясные сообщения об ошибках, убирайте за собой временные ресурсы (trap на EXIT), и тщательно тестируйте скрипты, включая граничные случаи. В следующих разделах рассмотрим работу с файлами и текстом, а также важнейшие механизмы ввода-вывода в Bash – перенаправления и конвейеры.

Работа с файлами и текстом

Одно из самых полезных применений Bash-скриптов – автоматизация работы с файлами и обработка текстовых данных (логи, конфигурации, отчеты и т.д.). Рассмотрим распространенные приемы:

Создание, чтение и запись файлов. Bash позволяет выполнять операции с файлами как через команды оболочки, так и используя утилиты:

• Создать пустой файл: > filename (путем перенаправления пустого вывода) или команда touch filename.
• Записать текст в файл: echo "Hello" > file.txt (перезапишет файл) или echo "World" >> file.txt (добавит в конец файла).
• Прочитать файл целиком: cat file.txt выведет содержимое.
• Построчное чтение в скрипте: можно использовать комбинацию while и команды read. Например: i=1 while IFS= read -r line; do echo "Строка $i: $line" ((i++)) done < file.txt Эта конструкция читает файл file.txt построчно (в переменную line). IFS= и -r нужны, чтобы корректно обрабатывать пробелы и бэкслэши соответственно.

Проверка существования и свойств файлов. Как упоминалось в разделе про условия, Bash предоставляет оператор test (или [ ]) для файловых проверок:

• -e file – существует ли файл (любого типа).
• -f file – существует ли обычный файл.
• -d dir – существует ли директория.
• -s file – размер файла > 0 (не пустой).
• -x file – исполняемый ли файл (есть права на запуск).
• и др. (полный список в man test).

Эти проверки часто используются перед попыткой читать/записать файл, чтобы убедиться, что он доступен. Пример:

if [[ ! -f "$config" ]]; then
    echo "Ошибка: файл конфигурации $config не найден." >&2
    exit 1
fi

Команды обработки текста. Unix славится мощными текстовыми утилитами. В Bash-скриптах можно активно использовать:

• grep – поиск строк по шаблону (позволяет использовать регулярные выражения). Например: grep "ERROR" app.log выведет все строки, содержащие “ERROR”. С флагом -c можно получить количество строк (grep -c "ERROR" app.log).
• sed – потоковый редактор, часто применяется для замены текста по шаблону. Пример: sed -i 's/oldtext/newtext/g' file.txt заменит в самом файле все вхождения “oldtext” на “newtext” (-i означает “редактировать на месте”). Без -i sed выведет результат в stdout, не меняя файл.
• awk – мощный язык обработки текстовых данных. Позволяет разбить строку на поля и выполнять различные действия. Пример: awk '{print $1,$3}' data.txt выведет первый и третий столбец каждой строки файла (столбцы по умолчанию разделены пробелами). awk поддерживает сложные условия и вычисления, вплоть до написания самостоятельных скриптов внутри себя.
• cut – вырезает столбцы или диапазоны символов. Пример: cut -d':' -f1 /etc/passwd выведет первую часть каждой строки файла /etc/passwd (до двоеточия). Полезно для разбора простых файлов с разделителями.
• sort – сортировка; uniq – удаление дубликатов (часто используется вместе с sort); head/tail – вывод начала или конца файла (например, head -n 10 file – первые 10 строк); wc – подсчет слов/строк/байт (с флагом -l только строки).
• tr – замена или удаление символов, например tr ',' '\n' < file заменит все запятые на переводы строк, разбив текст на строки.

Эти инструменты можно комбинировать через пайпы для сложной обработки. Например, чтобы найти 5 наиболее частых IP-адресов в лог-файле доступа веб-сервера, можно использовать командную комбинацию:

grep -oE '^[0-9\.]+' access.log | sort | uniq -c | sort -nr | head -5

Здесь grep -oE '^[0-9\.]+' вытаскивает IP (начало строки до пробела), затем sort сортирует, uniq -c подсчитывает повторения, второй sort -nr сортирует по частоте по убыванию, и head -5 берет топ-5. Такие конвейеры можно оформить и внутри скрипта, присваивая результат переменной или выводя напрямую.

Для более сложных манипуляций текстом (например, парсинг JSON, XML) часто используют специализированные утилиты (jq для JSON, xmllint для XML и т.п.), но это выходит за рамки данного обзора.

Важно отметить, что Bash сам по себе не обладает богатым набором строковых операций (есть параметрическое расширение, но синтаксис сложный для сложных задач). Поэтому разумно делегировать обработки текстов вышеперечисленным утилитам.

Пример: допустим, нужно вытащить все уникальные слова из файла и сохранить в другой файл, отсортированные в алфавитном порядке:

tr -c 'A-Za-zА-Яа-я0-9' '[\n*]' < input.txt | sed '/^$/d' | sort -u > words.txt

Разберем: tr -c 'A-Za-zА-Яа-я0-9' '[\n*]' заменяет все символы, кроме букв и цифр, на переводы строки (т.е. разбивает текст на слова по любым неалфанумерным разделителям). Затем sed '/^$/d' удаляет пустые строки (лишние переводы строки от повторяющихся разделителей). sort -u сортирует слова и отсекает дубликаты (-u). Результат перенаправляем в words.txt.

Этот однострочник мог бы быть частью скрипта для анализа текста. Понимая, как применять grep/sed/awk и прочие утилиты, вы можете обрабатывать данные в скриптах Bash очень гибко.

Теперь, освоив манипуляции с файлами и текстовыми потоками, перейдем к фундаментальным механизмам ввода-вывода Bash — перенаправлениям, конвейерам и подстановкам.

Перенаправления, пайпы и подстановки

Bash (как и другие shell) предоставляет мощные средства перенаправления потоков ввода/вывода, а также различные виды подстановок для вложения одних команд в другие.

Стандартные потоки. Напомним, у процесса есть стандартный ввод (stdin), стандартный вывод (stdout) и стандартный поток ошибок (stderr). В Bash им соответствуют файловые дескрипторы с номерами 0, 1, 2 соответственно.

Перенаправления ввода/вывода

Перенаправление позволяет отправить выходной поток команды в файл или на вход другой команды, и наоборот, взять ввод команды из файла вместо клавиатуры.

• > – перенаправить stdout в файл (создаст файл или перетрёт, если существует).
  Пример: ls > files.txt запишет список файлов в files.txt (не выводя на экран).
• >> – перенаправить stdout в конец файла (append, без удаления существующего содержимого).
  Пример: echo "новая запись" >> log.txt добавит строку в конец log.txt.
• < – перенаправить файл в stdin команды.
  Пример: sort < unsorted.txt > sorted.txt возьмет данные из unsorted.txt как ввод для sort и выведет результат в sorted.txt.
• 2> – перенаправить stderr в файл. Например, gcc program.c 2> errors.txt сохранит все ошибки компиляции в файл, не трогая стандартный вывод.
• &> – сократанная форма (в Bash) для перенаправления обоих stdout и stderr в указанный файл. Например, ./script.sh &> output.log запишет и нормальный вывод, и ошибки скрипта в output.log. Эквивалентно > output.log 2>&1.
• 2>&1 – конструкция для объединения потоков: отправляет stderr (2) туда же, куда уже идет stdout (1). Чаще используется, чем &>, для совместимости с sh. Например: command >output.txt 2>&1 – и stdout, и stderr команды попадут в output.txt. В этой записи важно, что 2>&1 должно идти после перенаправления stdout.
• <& или >& – дупликация потоков ввода/вывода, менее частые конструкции. Например, exec 3>&1 создает дубликат текущего stdout в дескриптор 3 (чтобы потом можно было восстановить stdout).

Пример сочетания перенаправлений:

command >> output.log 2>&1

запускает command, добавляет ее стандартный вывод в конец output.log, а 2>&1 объединяет стандартный поток ошибок с выводом (так что ошибки тоже пойдут в этот же файл).

Если нужно полностью подавить какой-то вывод, перенаправьте его в специальное устройство /dev/null (черная дыра). Например, command > /dev/null отбросит обычный вывод, а command 2> /dev/null отбросит сообщения об ошибках. Иногда пишут >/dev/null 2>&1 чтобы подавить вообще весь вывод команды.

Здесь-документы (heredoc). Это способ передать блок текста как ввод команды. Синтаксис:

command <<EOF
строка1
строка2 $variable и подстановки будут выполняться
...
EOF

Текст между <<EOF и строкой с EOF подается в команду как стандартный ввод. Например:

cat <<END
Лог отчет:
Дата: $(date)
Пользователь: $USER
END

Команда cat в этом примере просто выведет переданный ей блок текста, в котором подставятся текущие дата и имя пользователя. Here-doc удобно использовать для генерации многострочных конфигураций или сообщений прямо из скрипта.

Если нужно вставить текст без подстановки переменных, используйте кавычки после <<, например <<'EOF', тогда весь блок будет взят буквально.

Here-string. Похожий механизм — <<<, который подает строковый литерал в качестве ввода. Пример: grep "root" <<< "$line" — это эквивалентно echo "$line" | grep "root", то есть передаст содержимое переменной как ввод для grep.

Конвейеры (пайпы)

Pipeline (конвейер, пайп) — это способ передать вывод одной команды напрямую на вход другой. Оператор | между командами создает такой конвейер. Например:

grep "ERROR" app.log | wc -l

Здесь вывод grep (все строки с “ERROR”) сразу поступает на вход wc -l, который посчитает количество строк. Не нужно создавать промежуточный файл — данные передаются через пайплайн.

Таким образом, пайп (|) соединяет команды, отправляя stdout первой команды в stdin второй. Это позволяет строить цепочки обработок.

Важно: по умолчанию в пайпе только стандартный вывод первой команды идет в стандартный ввод второй. Ошибки (stderr) по умолчанию не идут через пайп. Если нужно и ошибки прогонять по пайпу, можно использовать оператор |& (в Bash, эквивалент 2>&1 |). То есть cmd1 |& cmd2 объединяет stderr с stdout cmd1 и передает все вместе в cmd2.

Отличие пайпа от перенаправления. Пайплайн связывает две программы, а перенаправление связывает программу и файл/устройство. Грубо говоря, пайп отправляет вывод программе, а редирект отправляет вывод в файл. Как метко сказано: Pipe is used to pass output to another program or utility. Redirect is used to pass output to a file or streamaskubuntu.com.

Иногда можно достичь того же результата через промежуточный файл, но пайпы удобнее и эффективнее. Например, cmd1 | cmd2 делает то же, что cmd1 > temp && cmd2 < temp (но без создания temp на диске).

Можно выстраивать цепочку из нескольких команд: cmd1 | cmd2 | cmd3 | cmd4. Здесь выход cmd1 идет в cmd2, выход cmd2 – в cmd3 и т.д. Bash запускает все команды в пайплайне параллельно (конвейер работает, пока все программы читают/пишут). Кодом возврата всего пайпа считается код последней команды, но благодаря set -o pipefail (упомянуто выше) можно сделать так, чтобы ошибка в любой стадии не осталась незамеченной.

Подстановки команд и арифметики

Подстановка команд. Это способ выполнить команду внутри другой команды или присвоения, вставив ее вывод. Синтаксис: $(команда) или устаревший формат `команда` (обратные апострофы). Рекомендуется использовать $() из-за лучшей читаемости и возможности вкладывать.

Пример:

files_count=$(ls | wc -l)
echo "В текущей директории файлов: $files_count"

Здесь сначала выполняется подкоманда ls | wc -l, которая выдаст количество строк (файлов). Это значение подставится вместо $(...), и потом echo выведет итоговое сообщение. Этот прием очень распространен для получения результата от одной команды и использования его в другой команде или переменной.

Другой пример: current_date=$(date +"%Y-%m-%d") сохранит текущую дату в формате ГГГГ-ММ-ДД в переменную. Вставка команды date с нужными опциями происходит прямо в строке присваивания.

Арифметическая подстановка. Bash поддерживает простейшую арифметику через конструкцию $(( выражение )). Внутри можно использовать переменные (без $) и стандартные операторы + – * / %. Результат вычисления подставляется как строка. Например:

a=5
b=3
echo "$((a + b))"   # выведет 8

Аналогично, можно присваивать: c=$((a * 2)) запишет в c значение 10. Арифметическая подстановка понимает инкремент/декремент: ((i++)) увеличит i на 1, ((i+=5)) прибавит 5 и т.д., но в контексте if или цикла возвращает статус 0 всегда, поэтому для условий лучше сравнения явно.

Расширение фигурных скобок. (Brace expansion) – это тоже вид подстановки, хотя и не связан с выполнением команд. Позволяет генерировать списки строк по шаблону. Например, file_{1..3}.txt развернется Bash-ем в список file_1.txt file_2.txt file_3.txt. Или {яблоко,груша,слива}.txt даст яблоко.txt груша.txt слива.txt. Это происходит еще до выполнения команды, на этапе разбиения аргументов. Очень удобно для циклов: for i in {1..5}; do echo $i; done переберет 1 2 3 4 5. Можно задавать шаг: {1..10..2} -> 1 3 5 7 9.

Параметрическое расширение. Это тема обширная, но упомянем пару полезных примеров использования ${...} для операций над переменными:

• ${VAR:-default} – если VAR не задан или пуст, подставит "default", иначе подставит значение VAR. Удобно для значений по умолчанию.
• ${VAR^^} – в Bash 4+ переведет значение VAR в верхний регистр (а ${VAR,,} в нижний).
• ${#VAR} – дает длину строки в переменной VAR.
• ${VAR%suffix} – убирает указанный суффикс из конца переменной (можно с шаблонами *), а ${VAR#prefix} – убирает префикс с начала. Двойные %% или ## уберут самое длинное совпадение. Например, file="report.txt"; echo "${file%.txt}" выведет report (удалили суффикс .txt).

Эти расширения выполняются без вызова внешних программ, силами Bash, что часто эффективно. Например, проверяя существование переменной и задавая ей значение по умолчанию, часто пишут: : "${VAR:=default}" – это задаст VAR=default если она пустая, или оставит как есть если задана.

Мы лишь кратко коснулись расширений; подробности можно найти в “Bash Parameter Expansion” справочниках. Для ежедневных задач достаточно помнить про ${VAR:-default} и ${#VAR}.

Резюмируя: перенаправления позволяют управлять тем, куда идут данные (в файл, на вход команды или в никуда), пайпы позволяют строить цепочки обработки между командами, а подстановки – вкладывать выполнение одних команд внутрь других или работать с содержимым переменных. Владение этими механизмами – ключ к написанию мощных однострочных команд и эффективных скриптов.

Далее рассмотрим, как можно автоматизировать запуск скриптов по расписанию с помощью cron, а также некоторые дополнительные продвинутые приемы Bash.

Работа с cron и автоматизация задач

Одно дело написать скрипт, но часто требуется запускать его регулярно (например, каждый день ночью) или по расписанию. Для этого в Unix есть планировщик заданий cron.

Демон cron и crontab. Cron – это фоновый сервис (демон), который каждую минуту проверяет, не пора ли выполнить запланированные задачи. Задачи cron (cron jobs) определяются в специальной таблице – crontab. У каждого пользователя может быть свой crontab. Правка расписания осуществляется командой crontab -e.

Формат crontab. Каждая запись состоит из 6 полей: пять полей времени запуска и команда для исполнения. Общий формат строки crontab:

минуты часы день_месяца месяц день_недели команда

Поле “день недели” задается цифрами 0–6 (0 обычно воскресенье) или сокращенными именами (Mon, Tue, …). Месяц – 1–12 или Jan, Feb, … День месяца – 1–31, часы – 0–23, минуты – 0–59. Вместо конкретного числа можно ставить * (звездочка) – означает “любое значение”. Также можно указывать через запятую несколько значений или диапазоны через дефис. Шаг через */N означает “каждые N единиц”. Например:

# Запуск скрипта backup.sh каждый день в 2:30 ночи
30 2 * * * /home/user/backup.sh

Разберем: 30 – минута, 2 – час, остальные три * значат “каждый день месяца”, “каждый месяц”, “каждый день недели”. То есть когда часы=2 и минуты=30, неважно какой день – выполняй команду. Другой пример:

0 */6 * * Mon-Fri /home/user/cleanup.sh

Это выполнит /home/user/cleanup.sh каждые 6 часов по будням (Mon-Fri) в ноль минут каждого шестого часа (то есть 0:00, 6:00, 12:00, 18:00 с понедельника по пятницу)cronitor.io.

При редактировании crontab -e откроется редактор, куда нужно построчно добавить задания. После сохранения файла новые задания вступят в силу.

Специальные строки. В crontab есть сокращения: @daily (раз в день в полночь), @hourly, @reboot (один раз при загрузке системы) и т.д. Например: @reboot /home/user/startup.sh – выполнить скрипт при каждом запуске ОС.

Окружение cron. Важно понимать, что задачи cron запускаются неинтерактивно. Это означает:

• Ваши профили и rc-файлы (~/.bashrc, ~/.profile) обычно не загружаются. Переменные окружения, которые вы видите в обычной сессии, могут отсутствовать. Например, переменная $USER или $PATH могут иметь минимальное значение по умолчанию. Cron не читает ~/.bashrc, поэтому, если вашему скрипту нужны определенные переменные или настройки окружения, задайте их явно в скрипте или в crontab. Например, можно в crontab на строке выше задания прописать PATH=/usr/local/bin:/usr/bin:/bin чтобы задать PATH для последующих задач.
• Текущая директория по умолчанию – домашняя (~), если не указано иное. Лучше в скриптах использовать полные пути к файлам.
• Вывод скрипта. По умолчанию stdout и stderr выполняемых cron-задач будут отправлены вам на почту (локальную почту пользователя) по завершении задачи. Если почтового демона нет или почта не настроена, вы этот вывод не увидите. Поэтому обычно перенаправляют вывод в файлы логов или в /dev/null, либо настраивают MAILTO. Если хотите отладить cron-задачу, временно уберите перенаправления, и после запуска посмотрите почту командой mail – там могут быть сообщения от cron с выводом или ошибками.

Пример задания: Добавим задачу, которая запускает скрипт /home/user/backup.sh каждый день в 3:00 ночи:

Открываем crontab:

crontab -e

И добавляем строку:

0 3 * * * /home/user/backup.sh >> /home/user/backup.log 2>&1

Это значит: в 03:00 каждого дня выполнить backup.sh. Мы также перенаправили вывод в backup.log (используя >>, чтобы дописывать, а не перетирать файл) и ошибки туда же через 2>&1. Таким образом, лог выполнения будет сохраняться в файл, а не рассылаться почтой.

Права и исполняемость. Убедитесь, что скрипт, который вызывается cron-ом, помечен на выполнение (chmod +x script.sh), иначе cron не сможет его запуститьcronitor.iocronitor.io. Также желательно в скрипте использовать полные пути к бинарным файлам, либо установить PATH в crontab, потому что cron может иметь ограниченный PATH. Например, вместо просто tar лучше /usr/bin/tar или в начале скрипта: PATH=/usr/local/bin:/usr/bin:/bin.

Отладка cron-заданий. Если задача не выполняется, проверяйте:

• Синтаксис расписания (не перепутаны ли поля минут/часов и т.д.). Опечатки легко допустить. Можно использовать сайт crontab.guru для проверки выражения времени.
• Лог системы: часто cron пишет сообщения в /var/log/syslog (в Linux). Там можно увидеть, запускалась ли задача и были ли ошибки.
• Как сказано выше, убедитесь, что все пути верны и окружение имеется. Часто распространенная проблема: в терминале скрипт работает, а в cron нет. Причина – другой PATH или нет какой-то переменной. Решение: прописать необходимые экспортируемые переменные прямо в скрипте (например, если нужна та же $USER, можно делать USER=username в начале скрипта или не полагаться на нее).
• Если cron-задача запускается, но не делает ожидаемое, логи (если вы их настроили) подскажут, либо отправленный на почту вывод.

Автоматизация задач. Помимо cron, существуют и другие способы планирования:

• at – для однократного отложенного запуска (например, “выполнить команду через 2 часа”).
• systemd timers – альтернатива cron в системах с systemd, позволяет более гибко управлять расписанием и отслеживать успех выполнения. Но cron по-прежнему популярен благодаря простоте.

Для большинства простых случаев cron достаточен. Например, вы можете поставить очистку временных файлов раз в неделю, бэкап базы каждый день, проверку доступности сервера каждые 5 минут (хотя тут уже надо быть осторожным, чтоб задачи не пересеклись, cron не проверяет это).

Cron – мощный инструмент, который в сочетании с Bash-скриптами позволяет полностью автоматизировать администрацию и обслуживание системы. Написав скрипт, не забудьте протестировать его вручную, а потом уже доверять cron-у регулярный запуск.

Продвинутые приёмы Bash

На завершающем этапе рассмотрим несколько продвинутых техник и рекомендаций, которые помогут сделать скрипты более надежными, безопасными и удобными.

• Строгий режим (set -euo pipefail). Мы уже подробно разбирали его в разделе об ошибках, но повторим кратко как чеклист:
  • set -e – немедленный выход при ошибке команды (защита от незамеченных сбоевdigitalocean.com).
  • set -u – падать при обращении к неинициализированным переменным (ловля опечаток и пропущенных параметров).
  • set -o pipefail – учитывать ошибки в частях конвейера (а не только в последней команде).
  Обычно эти опции ставят первой строчкой (после shebang) в скрипте, чтобы они распространялись на весь скрипт. В результате многие “тихие” ошибки превратятся в явные, и скрипт не выполнит некорректные действия, а завершится. Иногда употребляют термин “неофициальный строгий режим Bash” для комбинации set -euo pipefail плюс настройка IFS (внутреннего разделителя) = $'\n\t' (новая строка и таб, чтобы словоразделителем не считался пробел, но эта тонкость выходит за рамки обзора).
• Использование trap для очистки ресурсов. Еще раз отметим, что trap полезен не только для удаления файлов на EXIT, но и для обработки сигналов. Например, можно перехватить сигнал SIGTERM (завершение процесса) и сделать в обработчике аккуратное завершение (например, разлогиниться от сервиса, закрыть файл). Пример: cleanup() { echo "Получен сигнал, завершаем..." >&2 # здесь команды по очистке rm -f "$temp_file" exit 1 } trap cleanup SIGINT SIGTERM Теперь если процессу пришлют SIGINT (Ctrl+C) или SIGTERM (убить процесс), вызовется функция cleanup вместо мгновенного прекращения.
• Проверка зависимостей (внешних утилит). Скрипт может полагаться на внешние команды (например, curl, tar, jq). Хорошим стилем считается проверить наличие этих утилит в системе и, если чего-то нет, выдать понятную ошибку и выйти, чем получить загадочное сообщение вроде “command not found” посреди работы. Типовой паттерн на эту тему: if ! command -v tar &> /dev/null; then echo "Ошибка: утилита tar не установлена. Установите tar и повторите." >&2 exit 1 fi Здесь command -v tar проверяет, доступна ли команда tar в PATH (возвращает 0, если да). Мы перенаправили ее вывод в /dev/null, так как нам не нужен путь, а важен лишь код выхода. Если утилиты нет, выполняем echo ошибки и exit 1. Этот шаблон можно повторить для всех критически важных утилит. Тогда пользователь скрипта сразу узнает, чего не хватает, и скрипт не будет пытаться выполняться в неполной средеstackoverflow.com. Аналогично, можно проверять и нужные файлы/каталоги: например, если скрипт ожидает конфигурационный файл или директорию, лучше проверить через [[ -f config.cfg ]] или [[ -d /path/to/dir ]] и ясно сказать, что “не найдено то-то”.
• Безопасное обращение с переменными и аргументами. Имейте привычку обрамлять переменные в кавычки, особенно параметры скрипта, результаты подстановок, переменные, содержащие пути с пробелами. Это предотвращает много классов ошибок. Например, если пользователь передаст в скрипт файл с пробелом в имени без кавычек, он бы интерпретировался как два отдельных аргумента. Аналогично, при обходе списков файлов старайтесь использовать нулевой разделитель (если через find | xargs, то -print0 и xargs -0), либо безопасные способы чтения, чтобы имена с пробелами не ломали логику.
• Выбор между [ и [[. В Bash, как отмечалось, лучше использовать [[ ... ]] для условий, когда возможно. Оно не воспринимает шаблоны (* и ?) в аргументах как глобbing, не делает словесное разделение, и позволяет использовать && и || внутри без опасности. В [ (тест) эти конструкции более капризны. Например: if [ "$var" == "value" ]; then ... fi # в POSIX shell один знак = вместо == if [[ $var == value* ]]; then ... fi # шаблонное сравнение, работает только в [[ ]] [[ – это ключевое слово Bash, а [ – по сути вызывается программа /usr/bin/[ (или встроенная версия). Для скриптов Bash нет причин избегать [[, так что можно смело им пользоваться.
• Различие между синтаксисом (( )) и [[ ]]. (( )) используется для арифметических сравнений и операций. Например, (( x < y )) числовое сравнение без необходимости писать $ перед x и y. Результат контекстуально – он дает код 0 или 1, так что можно использовать if (( x < y )); then ... fi. [[ ]] же – чисто для логических/строковых/файловых условий.
• Экранирование и безопасная работа с вводом. Если ваш скрипт принимает пользовательский ввод (например, читается через read или передается как аргумент), будьте осторожны с содержимым. Опасность заключается, например, в том, что строка, содержащая * или ?, может неожиданно распасшириться Bash-ем в имена файлов, если не в кавычках. Всегда заключайте переменные в кавычки, а если нужно принять произвольный текст, можно использовать read -r и, возможно, отключить интерпретацию глобbing через set -f (выключить globbing) если ожидается, что ввод может содержать такие символы буквально.
• ShellCheck и стиль кода. Уже упоминали, но повторим: утилита ShellCheck (shellcheck.net) – отличный помощник. Она подскажет не только ошибки, но и потенциальные проблемы. Например, укажет на использование необъявленной переменной (если без set -u), неправильное экранирование, использование UUOC (useless use of cat) и прочие моменты. Стоит прислушиваться к ее советам.
• Протоколирование и отладочные уровни. В сложных скриптах можно реализовать логирование с разными уровнями детализации (info, debug, error). Это вручную делается, но удобно: например, завести переменную VERBOSE или DEBUG, и оборачивать отладочные сообщения в проверки: [[ -n $DEBUG ]] && echo "Debug: x=$x". Тогда при запуске скрипта с включенным флагом (например, DEBUG=1 ./script.sh) вы увидите доп. информацию.
• Функции как библиотека. Если у вас несколько скриптов, использующих общие функции, можно вынести их в отдельный файл и подключать через source common.sh (или .). Это позволяет переиспользовать код. Но следите за именами глобальных переменных, чтобы не пересекались.
• Продвинутые возможности Bash 4.x/5.x: ассоциативные массивы (declare -A arr), работа с сокетами и именованными каналами, coproc для параллельного запуска, команды mapfile (читает файл в массив) и др. – все это выходит за рамки обзора, но может существенно облегчить сложные задачи. Например, в Bash 4 появился встроенный синтаксис для работы с массивами ключ-значение, вместо ухищрений с grep/awk для парсинга конфигов.

Не забывайте, что Bash – это все же интерпретируемый язык, работающий построчно. Он не подходит для вычислительно тяжелых операций или очень сложной логики (где разумнее перейти на Python/Perl и др.). Но для управления системой, автоматизации, glue-кода между утилитами ему нет равных.

В завершение теории мы подготовили несколько примеров скриптов, которые демонстрируют сочетание различных рассмотренных техник на реальных задачах.

Примеры скриптов для реальных задач

Теперь приведем три небольших скрипта, которые решают практические задачи. Каждый пример сопровождается пояснениями.

Пример 1: Резервное копирование (backup)

Предположим, нам нужно регулярно делать резервную копию каталога с данными. Скрипт должен архивировать папку с датой в имени файла и удалять старые архивы старше определенного числа дней.

#!/bin/bash
# backup.sh - скрипт резервного копирования директории

# Настройки
SOURCE="/home/user/data"            # что бэкапим
DEST="/home/user/backups"          # куда складываем архивы
DAYS_TO_KEEP=7                     # сколько дней хранить архивы
DATE=$(date '+%Y-%m-%d_%H-%M-%S')  # текущая дата для имени файла

# Проверка необходимых утилит
if ! command -v tar &> /dev/null; then
  echo "Ошибка: tar не установлен, не могу создать архив." >&2
  exit 1
fi

# Создание архива
archive_name="backup_${DATE}.tar.gz"
echo "Создаю архив ${archive_name}..."
tar -czf "${DEST}/${archive_name}" "${SOURCE}"
if [[ $? -ne 0 ]]; then
  echo "Ошибка: не удалось создать архив." >&2
  exit 1
fi
echo "Архив создан: ${DEST}/${archive_name}"

# Удаление старых архивов
echo "Удаляю архивы старше $DAYS_TO_KEEP дней..."
find "$DEST" -type f -name "backup_*.tar.gz" -mtime +$DAYS_TO_KEEP -exec rm -v {} \;

Разбор скрипта:

• В разделе настроек мы указали исходный каталог, каталог для резервных копий и время хранения.
• Используем утилиту tar для создания сжатого архива (ключ -czf: c – создать архив, z – сжать gzip-ом, f – указать имя файла).
• Имя архива включает текущую дату (формат ГГГГ-ММ-ДД_ЧЧ-ММ-СС для уникальности до секунды).
• Перед запуском tar мы проверяем, доступна ли команда (command -v tar). Если нет, выводим сообщение об ошибке и завершаемся.
• После попытки создания архива проверяем код $? – если tar вернул не 0 (ошибка), выводим сообщение и выходим. (Здесь можно было бы просто включить set -e в начале, тогда при ошибке tar скрипт сам завершится.)
• Если архив успешно создан, выводим подтверждение.
• Далее, с помощью команды find, ищем в папке DEST файлы, имя которых начинается с backup_ и заканчивается на .tar.gz, измененные более чем $DAYS_TO_KEEP дней назад, и удаляем их. Опция -exec rm -v {} \; означает: для каждого найденного файла выполнить rm -v файл. Флаг -v у rm заставляет показать имя удаляемого файла (для отчета).
• Использование find с -mtime +7 позволяет автоматически чистить старые бэкапы, чтобы не накапливать бесконечно.

Такой скрипт можно поставить в cron на ежедневный запуск ночью. Он обеспечит, что у нас всегда есть архив за последние 7 дней, а более старые удаляются.

Пример 2: Парсинг логов

Следующий скрипт анализирует лог-файл веб-сервера (например, nginx или Apache) и извлекает некоторые метрики. Предположим, нужно узнать, сколько раз вернулся код ответа 5xx (ошибка сервера) за последний час, и сохранить эти строки в отдельный файл для разборов.

#!/bin/bash
# logcheck.sh - анализирует лог веб-сервера за последний час

LOG="/var/log/nginx/access.log"
OUTPUT="errors_last_hour.log"

# Вычисляем отметку времени час назад
one_hour_ago=$(date -d '1 hour ago' '+%d/%b/%Y:%H')
echo "Ищем ошибки (5xx) с $one_hour_ago до настоящего момента..."

# Фильтруем лог
grep "$one_hour_ago" "$LOG" | grep ' 5[0-9][0-9] ' > "$OUTPUT"

count=$(wc -l < "$OUTPUT")
echo "Найдено $count строк с кодами 5xx за последний час."
echo "Сохранено в файл $OUTPUT."

Объяснение:

• Мы задали файл лога access.log (в реальности лучше передавать путь через аргумент, но для простоты захардкожено).
• Вычисляем строку даты час назад: date -d '1 hour ago' '+%d/%b/%Y:%H' выдаст, например, 05/Oct/2025:14 если сейчас 15:35 05 Oct 2025. Формат совпадает с началом времени в стандартных логах (день/месяц/год:час). Мы берем точность до часа.
• grep "$one_hour_ago" "$LOG" отфильтрует только строки лога, где метка времени содержит этот час. Второй grep ' 5[0-9][0-9] ' ищет в этих строках строковый шаблон пробел + цифра 5 + две любые цифры + пробел, что соответствует HTTP-кодам 500–599, так как в логах код обычно отделен пробелами. Результат перенаправляем в файл $OUTPUT.
• Далее считаем число строк в сформированном файле через wc -l < "$OUTPUT" (подсчет строк, < подает файл на вход wc). Полученное число выводим.
• Такой скрипт можно запускать каждый час через cron, или вручную по необходимости. Он помогает быстро выделить серверные ошибки за недавний период.

Улучшения: можно было бы включить текущее число часа, т.е. с 14:00 до 14:59… Но для простоты берем последний час блоком. Также, если лог большой, grep дважды неэффективно – можно одним awk сделать, но grep понятнее.

Пример 3: Проверка статуса серверов

Представим, что у нас есть несколько удаленных серверов, и мы хотим периодически проверять, доступны ли они (по IP или доменному имени). Простейшая проверка доступности – послать ping или выполнить HTTP-запрос. В этом примере используем ping.

#!/bin/bash
# server_check.sh - проверяет пингом доступность списка серверов

SERVERS=("8.8.8.8" "1.1.1.1" "example.com")  # список IP или хостнеймов для проверки
LOG="servers_status.log"

echo "=== Проверка $(date) ===" >> "$LOG"
for host in "${SERVERS[@]}"; do
  if ping -c1 -W 2 "$host" &> /dev/null; then
    echo "$host : OK" | tee -a "$LOG"
  else
    echo "$host : DOWN" | tee -a "$LOG"
  fi
done
echo "" >> "$LOG"

Пояснения:

• Массив SERVERS содержит адреса для проверки. Мы указали пару общеизвестных DNS-серверов и домен example.com для демонстрации. В реальном сценарии там были бы ваши хосты.
• Каждый запуск скрипта дописывает (>>) в логфайл строку с текущей датой и времени, а затем статус каждого сервера.
• Цикл for host in "${SERVERS[@]}"; do ... done перебирает все элементы массива. Конструкция "${SERVERS[@]}" развертывает все элементы (важны кавычки, чтобы корректно обрабатывать элементы с пробелом, если бы такие были).
• Команда ping -c1 -W 2 посылает 1 пакет (-c1) и ждет максимум 2 секунды (-W 2). Этого достаточно для быстрой проверки. Результат ping мы отправляем в /dev/null (через &> /dev/null), потому что нам не нужен детальный вывод, достаточно факта успеха/неуспеха (код возврата).
• Если ping завершился успешно (код 0, значит ответ получен), то заходим в ветку then: выводим “host : OK“. Если нет ответа (код ping != 0), выводим “host : DOWN“.
• Используем echo "... | tee -a "$LOG" для вывода. tee дублирует вывод: и на экран, и добавляет в файл (-a для append). Это удобно, так как при ручном запуске вы видите результат сразу, а при автоматическом (например, cron) все равно все результаты будут накоплены в лог.
• После цикла добавляем пустую строку в лог (просто чтобы отделять блоки проверок визуально).

Запуск такого скрипта по cron, скажем, каждые 5 минут позволит иметь лог доступности серверов. При падении какого-то хоста вы увидите отметку “DOWN”. Конечно, в реальности мониторинг лучше делать специализированными средствами, но как простое решение на Bash – вполне рабочее.

Кстати, вместо ping иногда лучше делать именно прикладной запрос (например, curl -s -o /dev/null http://site/healthcheck и смотреть код ответа), но это зависит от характера проверки.

---

Эти примеры показывают, как можно применять различные конструкции Bash в решении практических задач: создание архивов, обработка текстовых логов, взаимодействие с сетью. При написании своих скриптов старайтесь комбинировать приведенные приемы: внимательно обрабатывать ошибки, выдавать понятные сообщения, документировать поведение комментариями. По мере накопления опыта ваши Bash-скрипты будут становиться более лаконичными и надежными.

Заключение

Мы рассмотрели широкий спектр тем, связанных с написанием скриптов на Bash – от базовых понятий (команды, переменные, циклы) до продвинутых техник (trap, строгий режим, cron). Bash остается мощным инструментом системного администратора и разработчика, позволяющим автоматизировать множество задач. Ключевые моменты, которые стоит помнить:

• Всегда проверяйте успех выполнения важных команд. Используйте if, логические операторы &&/|| или хотя бы set -e, чтобы скрипт не продолжал работу в неверном состоянии.
• Безопасность и надежность. Включение опций -u и -o pipefail, экранирование переменных кавычками, очищение ресурсов через trap – все это делает скрипт устойчивее к неожиданным ситуациям.
• Отладка. Не жалейте времени на отладочные выводы, запуск с set -x и использование ShellCheck перед тем, как доверить скрипту важную задачу в продакшене.
• Документация. Хорошие комментарии и структурирование кода через функции значительно облегчат понимание скрипта, особенно когда вы вернетесь к нему через месяцы.

Bash-сценарии отлично подходят для автоматизации в Unix-среде. Однако помните их ограничения: для очень сложной логики или кросс-платформенных сценариев возможно лучше использовать языки как Python. Тем не менее, знание Bash обязательно для эффективной работы в Linux, и надеемся, что этот гайд помог вам укрепить и расширить это знание.

Удачного скриптинга! Если вы дочитали до конца и воспроизвели примеры – вы уже обладаете всеми необходимыми навыками, чтобы писать собственные утилиты на Bash, экономя свое время и автоматизируя рутину.