Как bash передаёт аргументы скрипту: базовая модель
Вызов ./deploy.sh prod 8080 даёт скрипту два аргумента: в $1 окажется prod, в $2 число 8080. В $0 лежит ./deploy.sh, то есть имя файла ровно в том виде, в каком его набрали в командной строке. Всё, что идёт после имени скрипта, bash раскладывает по позиционным параметрам и нумерует с единицы.
Отсюда два практических следствия. Первое: $0 не аргумент, в проверках его не считают. Второе: позиционные параметры живут только внутри текущего процесса shell. Дочерняя команда получит их лишь тогда, когда вы передадите их явно: другой_скрипт "$@" или через переменные окружения.
Валидация опирается на $#: он возвращает число переданных аргументов без учёта $0. При вызове без аргументов $# равен нулю, и на этом факте держится проверка в первых строках скрипта. Для флагов есть встроенный getopts, для отбрасывания уже прочитанных значений shift. Ниже каждый элемент разобран с готовым фрагментом.
$0, $1, $2 и почему для десятого нужен ${10}
Bash читает $10 как ${1} и приклеенный к нему символ «0». Если в $1 лежит ten, команда echo "$10" напечатает ten0. Начиная с десятого параметра нужны фигурные скобки: ${10}, ${11} и дальше. Это прямо следует из руководства GNU Bash: десятый позиционный параметр записывается как ${10}, и скобки обязательны после $9 (Special Parameters, Bash Reference Manual).
#!/usr/bin/env bash
# корректно: фигурные скобки задают границу имени параметра
printf 'десятый аргумент: %s\n' "${10}"
# ловушка: значение $1 плюс символ 0
echo "$10"
Что окажется в переменных при вызове ./deploy.sh prod 8080:
| Параметр | Что содержит | Значение в примере |
|---|---|---|
| $0 | имя скрипта так, как его вызвали | ./deploy.sh |
| $1 | первый аргумент | prod |
| $2 | второй аргумент | 8080 |
| $9 | девятый аргумент | пусто |
| ${10} | десятый аргумент, скобки обязательны | пусто |
| $# | количество аргументов, $0 не считается | 2 |
| "$@" | все аргументы отдельными словами | prod 8080 |
Если запустить файл через bash deploy.sh prod 8080, в $0 окажется deploy.sh без префикса. В сообщениях об ошибке надёжнее печатать $(basename "$0"), чтобы не выводить полный путь.
Больше 3-5 позиционных аргументов читаются плохо: вызов ./script.sh prod eu-west-1 8080 yes force трудно запомнить, а порядок легко перепутать. Как только аргументов стало больше трёх, переводите их в именованные флаги через getopts.
$# - сколько аргументов реально пришло
$# считает все переданные значения, включая пустые строки, переданные как "". Счётчик уменьшается после каждого shift, поэтому проверки лучше делать до сдвигов.
echo "Получено аргументов: $#" if [ "$#" -lt 2 ]; then echo "Нужно минимум два аргумента" >&2 exit 1 fi
Сравнивайте $# в кавычках: при пустом значении без кавычек тест разваливается так же, как обычная переменная. Числовые операторы -lt, -ne, -gt работают с целыми, и $# всегда целое.
Проверка наличия аргументов и значения по умолчанию
Проверяйте аргументы в начале скрипта, до любых деструктивных действий: удаления файлов, перезапуска сервисов, записи в базу. Два рабочих шаблона: по количеству и по конкретному параметру.
# вариант 1: нужно ровно два аргумента
if [ "$#" -ne 2 ]; then
echo "Использование: $0 <окружение> <порт>" >&2
exit 1
fi
# вариант 2: проверка конкретного параметра
if [ -z "${1:-}" ]; then
echo "Не указано окружение" >&2
exit 1
fi
Подстановка значений по умолчанию отличается от проверки: она не останавливает скрипт, а подставляет подходящее значение. Разница между формами важна:
- ${VAR:-default} подставит default, если переменная не задана или пуста.
- ${VAR-default} подставит default только если переменная не задана; пустое значение сохранится.
- ${VAR:=default} не только подставит значение, но и запишет его в переменную.
- ${VAR:?Сообщение} напечатает сообщение в stderr и завершит shell с кодом 1, если значение пусто или не задано.
log_dir="${1:-/var/log}"
retries="${RETRIES:-3}"
: "${BACKUP_TARGET:?Не задан BACKUP_TARGET, добавьте его в /etc/backup.env}"
Двоеточие в последней строке это встроенная команда-заглушка: сама она ничего не делает, зато подстановка с :? успевает сработать и остановить скрипт с понятным текстом. Такой приём удобен для обязательных переменных окружения, которые приходят извне.
Почему [ -z "$1" ] без кавычек - ошибка
Без кавычек тест получает не то число аргументов, на которое рассчитан. При $1 со значением "a b" выражение [ -z $1 ] превращается в [ -z a b ] и печатает «too many arguments». В сравнении [ $1 = prod ] пустой параметр даёт [ = prod ] и ошибку «unary operator expected». В лучшем случае ветка сработает неверно, в худшем скрипт продолжит работу с мусором в переменной.
# ненадёжно
[ -z $1 ] && echo "пусто"
# надёжно: кавычки плюс защита от unbound variable
[ -z "${1:-}" ] && echo "пусто"
Запись ${1:-} закрывает ещё одну проблему: под set -u обращение к незаданному $1 без обработки завершает скрипт сообщением об unbound variable. Подстановка пустой строки убирает этот эффект.
Функция usage и понятное сообщение об ошибке
Справка нужна в двух случаях: верный вызов с флагом -h и неверный вызов. Код выхода при этом разный, поэтому функцию удобно сделать с параметром.
usage() {
local code="${1:-1}"
cat >&2 <<EOF
Использование: $(basename "$0") [-v] [-f файл] <каталог>
-v подробный вывод
-f файл файл со списком исключений
-h эта справка
Пример:
$(basename "$0") -v -f /etc/backup.exclude /data
EOF
exit "$code"
}
Печать идёт в stderr через >&2: если вывод скрипта перенаправлен в файл или уходит в пайп, справка не попадёт в данные. Heredoc <<EOF без кавычек подставляет имя скрипта и сохраняет переносы строк, поэтому сообщение остаётся читаемым и в терминале, и в логах CI.
$@ и $*: разница, которая ломает скрипты
"$@" разворачивается в каждый аргумент как отдельное слово и сохраняет его как есть: с пробелами, спецсимволами и пустыми строками. "$*" при цитировании склеивает все аргументы в одно слово, разделяя их первым символом IFS, по умолчанию пробелом (Special Parameters, Bash Reference Manual). Если IFS пуст, параметры при объединении соединяются вообще без разделителей. Без кавычек $@ и $* ведут себя одинаково: значение режется по IFS, а затем к результату применяется подстановка имён файлов.
#!/usr/bin/env bash printf 'argc=%s\n' "$#" for a in "$@"; do printf 'quoted-at: [%s]\n' "$a"; done for a in $@; do printf 'bare-at: [%s]\n' "$a"; done for a in "$*"; do printf 'quoted-star: [%s]\n' "$a"; done
Результат запуска ./args.sh "a b" c:
$ ./args.sh "a b" c argc=2 quoted-at: [a b] quoted-at: [c] bare-at: [a] bare-at: [b] bare-at: [c] quoted-star: [a b c]
Правило: по умолчанию пишите "$@" в кавычках. Вариант без кавычек уместен, когда вы осознанно хотите разбить строку на слова или подставить маску. Глобы добавляют ещё один риск: аргумент * без кавычек развернётся в список файлов текущего каталога, и скрипт получит совсем не то, что ему передали.
Если аргументы нужно сохранить, а не обработать сразу, сложите их в массив: args=("$@"), дальше работайте с "${args[@]}". Индексы, добавление и удаление элементов разбираем в статье Массивы в Bash: индексированные и ассоциативные.
Пустые аргументы и пробелы: как не потерять данные
Пустой аргумент остаётся аргументом. Вызов ./script.sh "" "a b" даёт $# = 2, при этом "$1" это пустая строка. Проверка [ -z "$1" ] не отличит её от отсутствующего параметра, поэтому для такой логики нужен именно $#.
# потеря данных: пустая строка исчезает, пробел режет значение for f in $@; do echo "файл: $f" done # сохраняет и пробелы, и пустые элементы for f in "$@"; do printf 'обрабатываю: %s\n' "$f" done # передача в другую команду без потерь; -- отделяет имена файлов от опций tar -czf "$archive" -- "$@"
Двойной дефис -- перед "$@" закрывает ещё один класс проблем: файл с именем -rf иначе будет прочитан как набор флагов.
shift: как отбрасывать уже обработанные аргументы
shift сдвигает позиционные параметры влево: $2 становится $1, $3 становится $2, а $# уменьшается на единицу. Форма shift 2 сдвигает сразу на два значения. Типичный сценарий: первое слово в командной строке это подкоманда, остальное относится к ней.
#!/usr/bin/env bash
set -euo pipefail
cmd="${1:-}"
if [ -z "$cmd" ]; then
echo "Укажите команду: start|stop|status" >&2
exit 1
fi
shift # теперь $1 это первый аргумент команды, а не её имя
case "$cmd" in
start|stop|status)
printf 'команда=%s, осталось аргументов=%s\n' "$cmd" "$#"
;;
*)
echo "Неизвестная команда: $cmd" >&2
exit 1
;;
esac
Что важно знать про границы. Если запрошенное количество сдвигов превышает число позиционных параметров, встроенная shift печатает сообщение об ошибке (bash-builtins(7), Debian Manpages). Поэтому при нефиксированном количестве аргументов сверяйте $# перед сдвигом. Отдельно отметим: поведение shift без аргумента при $# = 0 и точный код возврата при нехватке аргументов в подтверждённых источниках не зафиксированы — не полагайтесь на них в логике, проверяйте $# явно.
После цикла getopts переменная OPTIND указывает на первый не-флаг, и строка shift $((OPTIND - 1)) отбрасывает разобранные опции. Без неё первый позиционный аргумент останется в $1 вместе с флагами, и проверка «первый аргумент обязателен» сработает на значении вроде -v.
Разбор флагов через getopts: рабочий пример
getopts разбирает короткие опции по строке опций и на каждой итерации кладёт букву в переменную цикла, а значение опции в OPTARG. OPTIND отслеживает состояние разбора (How to Parse Command-Line Options in Bash with getopts, Linuxize). Полный каркас:
#!/usr/bin/env bash
set -euo pipefail
verbose=0
file=""
while getopts ":vf:h" opt; do
case "$opt" in
v) verbose=1 ;;
f) file="$OPTARG" ;;
h) usage 0 ;;
\?) echo "Неизвестная опция: -$OPTARG" >&2; usage ;;
:) echo "Опция -$OPTARG требует аргумента" >&2; usage ;;
esac
done
shift $((OPTIND - 1))
printf 'verbose=%s file=%s остаток=%s\n' "$verbose" "$file" "$*"
Ведущее двоеточие в строке опций включает тихий режим: bash не печатает собственных сообщений об ошибках, и вы обрабатываете их сами в case. В тихом режиме можно различить два случая: неизвестная буква приходит как \?, отсутствующее значение как :, и в обоих случаях OPTARG содержит проблемную букву. Без ведущего двоеточия (обычный режим) переменная устанавливается в '?' и для неверной опции, и для отсутствующего аргумента — различить их не получится. OPTIND стартует с 1 и после цикла указывает на первый аргумент, который не опция.
Опции с аргументом и без: строка опций
В строке "vf:h" двоеточие после буквы означает обязательное значение: v работает как флаг, f требует аргумент, h работает как флаг. Для -f подходят три формы записи: -f /data, -f/data и -vf/data в одном токене.
Вызов ./backup.sh -v -f /data /etc даёт verbose=1, file=/data, после shift остаётся $1=/etc и $#=1. Если написать ./backup.sh -f без значения, сработает ветка : и скрипт напечатает, какой именно опции не хватает.
Что делать с длинными опциями --flag
Встроенный getopts в bash поддерживает только односимвольные (короткие) опции и не умеет разбирать длинные вида --verbose (Linuxize). Такой аргумент останется в позиционных параметрах и молча попадёт в $1, а скрипт продолжит работу с неверными значениями. Два выхода: ручной разбор или внешний getopt.
while [ "$#" -gt 0 ]; do
case "$1" in
--verbose) verbose=1; shift ;;
--file) file="${2:-}"
[ -n "$file" ] || { echo "--file требует значения" >&2; exit 1; }
shift 2 ;;
--file=*) file="${1#*=}"; shift ;;
--) shift; break ;;
-*) echo "Неизвестная опция: $1" >&2; exit 1 ;;
*) break ;;
esac
done
Внешний вариант выглядит так: getopt -o vf: -l verbose,file: -- "$@". Команда печатает нормализованный список опций, который читают через eval set --. GNU getopt (тот, что используется утилитой getopt(1) в Linux) поддерживает разбор длинных опций; имена длинных опций могут сокращаться, если сокращение уникально или точно совпадает с определённой опцией (getopt_long_only(3), man-страница). Поведение BSD-версии getopt в macOS и способ проверки через getopt --version в подтверждённых источниках не зафиксированы — если целевые системы включают macOS, проверьте поддержку длинных опций на месте, прежде чем закладывать её в CI.
Готовый шаблон скрипта: аргументы, getopts и usage вместе
Скелет, который можно скопировать в рабочий скрипт и заменить содержательную часть. Проверки стоят до основной логики, справка уходит в stderr, значения по умолчанию подставлены через ${VAR:-default}.
#!/usr/bin/env bash
set -euo pipefail
readonly SCRIPT_NAME="$(basename "$0")"
verbose=0
file=""
usage() {
local code="${1:-1}"
cat >&2 <<EOF
Использование: $SCRIPT_NAME [-v] [-f файл] <каталог>
-v подробный вывод
-f файл файл со списком исключений
-h эта справка
Пример: $SCRIPT_NAME -v -f /etc/backup.exclude /data
EOF
exit "$code"
}
while getopts ":vf:h" opt; do
case "$opt" in
v) verbose=1 ;;
f) file="$OPTARG" ;;
h) usage 0 ;;
\?) echo "Неизвестная опция: -$OPTARG" >&2; usage ;;
:) echo "Опция -$OPTARG требует аргумента" >&2; usage ;;
esac
done
shift $((OPTIND - 1))
target="${1:-}"
[ -n "$target" ] || { echo "Не указан каталог" >&2; usage; }
[ -d "$target" ] || { echo "Каталог не найден: $target" >&2; exit 1; }
exclude_file="${file:-/etc/backup.exclude}"
if [ "$verbose" -eq 1 ]; then
printf 'verbose=1, target=%s, exclude=%s\n' "$target" "$exclude_file"
fi
printf 'Готово: %s\n' "$target"
Почему каждая строка на своём месте:
- #!/usr/bin/env bash находит bash в PATH, а не по фиксированному пути /bin/bash.
- set -euo pipefail останавливает скрипт на ошибке, падает при обращении к незаданной переменной и не даёт пайпу скрыть сбой средней команды.
- usage с параметром кода выхода разделяет два случая: справка по -h завершает работу с 0, ошибка вызова с 1.
- shift $((OPTIND - 1)) оставляет в $1 только позиционные значения, флаги больше не мешают проверкам.
- ${1:-} и ${file:-/etc/backup.exclude} дают предсказуемое поведение при неполном вызове.
Проверка поведения на четырёх вызовах: ./backup.sh печатает справку и выходит с кодом 1, ./backup.sh -h печатает справку и выходит с 0, ./backup.sh -v /data работает с verbose=1, ./backup.sh -x /data сообщает о неизвестной опции. Коды возврата проверяйте через echo $? сразу после запуска.
Полный каркас с trap, mktemp и обработкой кодов возврата разбираем отдельно: Bash-скрипты для администрирования Linux: структура, set -euo pipefail и чек-лист.
Типичные ловушки и как их избежать
Сводка ошибок, которые чаще всего встречаются в ревью скриптов автоматизации.
| Ошибка | Что происходит | Как правильно |
|---|---|---|
| $@ без кавычек | аргументы с пробелами режутся, маски раскрываются в имена файлов | for a in "$@"; do ... done |
| $10 | читается как ${1} плюс символ 0 | ${10}, ${11} и далее в скобках |
| [ -z $1 ] | «too many arguments» при пробелах, «unary operator expected» при пустом значении | [ -z "${1:-}" ] |
| shift без проверки $# | при превышении числа параметров shift печатает ошибку | сверять $# или сдвигать ровно $((OPTIND - 1)) |
| getopts без ведущего двоеточия | bash печатает свои сообщения, а неверная опция и отсутствующий аргумент неразличимы (оба дают '?') | строка опций ":vf:h" плюс case по : и \? |
| ожидание --long от getopts | длинная опция остаётся в позиционных параметрах | ручной while-case или getopt -o vf: -l verbose,file: |
| забытый shift $((OPTIND - 1)) | первый позиционный аргумент подменяется флагом | сдвиг сразу после цикла getopts |
| секрет в аргументе командной строки | значение видно в ps aux и в истории shell | файл окружения с правами 600, чтение через source |
Про последнюю строку подробнее: пароль, переданный как ./script.sh --password s3cret, остаётся в списке процессов и в ~/.bash_history. Права на файл и ротацию секретов разбираем в материале Безопасность скриптов администрирования: права, секреты и аудит.
Чек-лист перед выкаткой скрипта:
- Все обращения к аргументам в кавычках, для $@ используется "$@".
- Проверки $# и обязательных параметров стоят до первого деструктивного действия.
- Есть usage с примером вызова, вывод идёт в stderr, код выхода различается для -h и ошибки.
- Значения по умолчанию заданы через ${VAR:-default}, обязательные переменные проверены через ${VAR:?}.
- После getopts стоит shift $((OPTIND - 1)), длинные опции либо реализованы вручную, либо задокументированы как неподдерживаемые.
- Скрипт прогнан на пустом вызове, на неверном флаге и на аргументе с пробелом, коды возврата проверены через echo $?.
Прогоните новый скрипт по этим шести пунктам до деплоя, и большая часть инцидентов с «тихо сломалось в кроне» закроется на этапе ревью.