Аргументы bash-скрипта: $1, $@, getopts и проверка на наличие в готовом шаблоне | AdminWiki

Аргументы bash-скрипта: $1, $@, getopts и проверка на наличие в готовом шаблоне

16 ноября 2026 13 мин. чтения

Как 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. Права на файл и ротацию секретов разбираем в материале Безопасность скриптов администрирования: права, секреты и аудит.

Чек-лист перед выкаткой скрипта:

  1. Все обращения к аргументам в кавычках, для $@ используется "$@".
  2. Проверки $# и обязательных параметров стоят до первого деструктивного действия.
  3. Есть usage с примером вызова, вывод идёт в stderr, код выхода различается для -h и ошибки.
  4. Значения по умолчанию заданы через ${VAR:-default}, обязательные переменные проверены через ${VAR:?}.
  5. После getopts стоит shift $((OPTIND - 1)), длинные опции либо реализованы вручную, либо задокументированы как неподдерживаемые.
  6. Скрипт прогнан на пустом вызове, на неверном флаге и на аргументе с пробелом, коды возврата проверены через echo $?.

Прогоните новый скрипт по этим шести пунктам до деплоя, и большая часть инцидентов с «тихо сломалось в кроне» закроется на этапе ревью.

Поделиться: