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


Работа с переменными и/или подстановка их значений

${parameter}

То же самое, что и $parameter, т.е. значение переменной parameter. В отдельных случаях, при возникновении неоднозначности интерпретации, корректно будет работать только такая форма записи: ${parameter}.

Может использоваться для конкатенации (слияния) строковых переменных.

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


${parameter-default}, ${parameter:-default}

Если параметр отсутствует, то используется значение по-умолчанию.

  1. echo ${username-`whoami`}
  2. # Вывод результата работы команды `whoami`, если переменная $username не установлена.


Note

Формы записи ${parameter-default} и ${parameter:-default} в большинстве случаев можно считать эквивалентными. Дополнительный символ : имеет значение только тогда, когда parameter определен, но имеет "пустое" (null) значение.

  1. #!/bin/bash
  2. username0=
  3. # переменная username0 объявлена, но инициализирована "пустым" значением.
  4. echo "username0 = ${username0-`whoami`}"
  5. # Вывод после символа "=" отсутствует.
  6. echo "username1 = ${username1-`whoami`}"
  7. # Переменная username1 не была объявлена.
  8. # Выводится имя пользователя, выданное командой `whoami`.
  9. username2=
  10. # переменная username2 объявлена, но инициализирована "пустым" значением.
  11. echo "username2 = ${username2:-`whoami`}"
  12. # Выводится имя пользователя, выданное командой `whoami`, поскольку
  13. #+здесь употребляется конструкция ":-" , а не  "-".
  14. exit 0


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

  1. DEFAULT_FILENAME=generic.data
  2. filename=${1:-$DEFAULT_FILENAME}
  3. #  Если имя файла не задано явно, то последующие операторы будут работать
  4. #+ с файлом "generic.data".
  5. #


см. так же Пример 3-4, Пример 28-2 и Пример A-7.

Сравните этот подход с методом списков and list, для задания параметров командной строки по-умолчанию .

${parameter=default}, ${parameter:=default}

Если значения параметров не задананы явно, то они принимают значения по-умолчанию.

Оба метода задания значений по-умолчанию до определенной степени идентичны. Символ : имеет значение только когда $parameter был инициализирован "пустым" (null) значением, [22] как показано выше.

  1. echo ${username=`whoami`}
  2. # Переменная "username" принимает значение, возвращаемое командой `whoami`.


${parameter+alt_value}, ${parameter:+alt_value}

Если параметр имеет какое либо значение, то используется alt_value, иначе — null ("пустая" строка).

Оба варианта до определенной степени идентичны. Символ : имеет значение только если parameter объявлен и "пустой", см. ниже.

  1. echo "###### \${parameter+alt_value} ########"
  2. echo
  3. a=${param1+xyz}
  4. echo "a = $a"      # a =
  5. param2=
  6. a=${param2+xyz}
  7. echo "a = $a"      # a = xyz
  8. param3=123
  9. a=${param3+xyz}
  10. echo "a = $a"      # a = xyz
  11. echo
  12. echo "###### \${parameter:+alt_value} ########"
  13. echo
  14. a=${param4:+xyz}
  15. echo "a = $a"      # a =
  16. param5=
  17. a=${param5:+xyz}
  18. echo "a = $a"      # a =
  19. # Вывод отличается от a=${param5+xyz}
  20. param6=123
  21. a=${param6+xyz}
  22. echo "a = $a"      # a = xyz


${parameter?err_msg}, ${parameter:?err_msg}

Если parameter инициализирован, то используется его значение, в противном случае — выводится err_msg.

Обе формы записи можно, до определенной степени, считать идентичными. Символ : имеет значение только когда parameter инициализирован "пустым" значением, см. ниже.

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

  1. #!/bin/bash
  2. #  Проверка отдельных переменных окружения.
  3. #  Если переменная, к примеру $USER, не установлена,
  4. #+ то выводится сообщение об ошибке.
  5. : ${HOSTNAME?} ${USER?} ${HOME?} ${MAIL?}
  6.   echo
  7.   echo "Имя машины: $HOSTNAME."
  8.   echo "Ваше имя: $USER."
  9.   echo "Ваш домашний каталог: $HOME."
  10.   echo "Ваш почтовый ящик: $MAIL."
  11.   echo
  12.   echo "Если перед Вами появилось это сообщение,"
  13.   echo "то это значит, что все критические переменные окружения установлены."
  14.   echo
  15.   echo
  16. # ------------------------------------------------------
  17. #  Конструкция ${variablename?} так же выполняет проверку
  18. #+ наличия переменной в сценарии.
  19. ThisVariable=Value-of-ThisVariable
  20. #  Обратите внимание, в строковые переменные могут быть записаны
  21. #+ символы, которые запрещено использовать в именах переменных.
  22. : ${ThisVariable?}
  23. echo "Value of ThisVariable is $ThisVariable".
  24. echo
  25. echo
  26. : ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
  27. #  Если ZZXy23AB не инициализирована,
  28. #+ то сценарий завершается с сообщением об ошибке.
  29. # Текст сообщения об ошибке можно задать свой.
  30. # : ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
  31. # То же самое:  dummy_variable=${ZZXy23AB?}
  32. #               dummy_variable=${ZZXy23AB?"Переменная ZXy23AB не инициализирована."}
  33. #
  34. #               echo ${ZZXy23AB?} >/dev/null
  35. echo "Это сообщение не будет напечатано, поскольку сценарий завершится раньше."
  36. HERE=0
  37. exit $HERE   # Сценарий завершит работу не здесь.

Пример 9-14. Подстановка параметров и сообщение о "порядке использования"

  1. #!/bin/bash
  2. # usage-message.sh
  3. : ${1?"Порядок использования: $0 ARGUMENT"}
  4. #  Сценарий завершит свою работу здесь, если входные аргументы отсутствуют,
  5. #+ со следующим сообщением.
  6. #    usage-message.sh: 1: Порядок использования: usage-message.sh ARGUMENT
  7. echo "Эти две строки появятся, только когда задан аргумент в командной строке."
  8. echo "Входной аргумент командной строки = \"$1\""
  9. exit 0 # Точка выхода находится здесь, только когда задан аргумент командной строки.
  10. # Проверьте код возврата в обеих случаях, с и без аргумента командной строки.
  11. # Если аргумент задан, то код возврата будет равен 0.
  12. # Иначе — 1.

Подстановка параметров и/или экспансия. Следующие выражения могут служить дополнениями оператора match команды expr, применяемой к строкам (см. Пример 12-9). Как правило, они используются при разборе имен файлов и каталогов.

Длина переменной / Удаление подстроки

${#var}

String length (число символов в переменной $var). В случае массивов, команда ${#array} возвращает длину первого элемента массива.

Note

Исключения:

  • ${#*} и ${#@} возвращает количество аргументов (позиционных параметров).

  • Для массивов, ${#array[*]} и ${#array[@]} возвращает количество элементов в массиве.



Пример 9-15. Длина переменной

  1. #!/bin/bash
  2. # length.sh
  3. E_NO_ARGS=65
  4. if [ $# -eq 0 ]  # Для работы скрипта необходим хотя бы один входной параметр.
  5. then
  6.   echo "Вызовите сценарий с одним или более параметром командной строки."
  7.   exit $E_NO_ARGS
  8. fi
  9. var01=abcdEFGH28ij
  10. echo "var01 = ${var01}"
  11. echo "Length of var01 = ${#var01}"
  12. echo "Количество входных параметров = ${#@}"
  13. echo "Количество входных параметров = ${#*}"
  14. exit 0
${var#Pattern}, ${var##Pattern}

Удаляет из переменной $var наименьшую/наибольшую подстроку, совпадающую с шаблоном $Pattern. Поиск ведется с начала строки $var.

Пример использования из Пример A-8:

  1. # Функцмя из сценария "days-between.sh".
  2. # Удаляет нули, стоящие в начале аргумента-строки.
  3. strip_leading_zero () # Ведущие нули, которые могут находиться в номере дня/месяца, лучше удалить
  4. {                     #+ В противном случае Bash будет интерпретировать числа как восьмеричные
  5.   return=${1#0}       # "1" — это аргумент "$1".
  6. }                     # "0" — это то, что удаляется из "$1" — ведущие нули.


Manfred Schwarb предложил более сложный вариант вышеприведенного кода:

  1. strip_leading_zero2 () # Удалить ведущие нули
  2. {
  3.   shopt -s extglob     # переход в режим расширенной подстановки.
  4.   local val=${1##+(0)} # Поиск самой длинной последовательности нулей.
  5.   shopt -u extglob     # выход из режима расширенной подстановки.
  6.   _strip_leading_zero2=${val:-0}
  7.                        # Если был введен 0, то возвращается 0, а не "".
  8. }


Другой пример:

  1. echo `basename $PWD`        # Имя текущего рабочего каталога.
  2. echo "${PWD##*/}"           # Имя текущего рабочего каталога.
  3. echo
  4. echo `basename $0`          # Имя файла-сценария.
  5. echo $0                     # Имя файла-сценария.
  6. echo "${0##*/}"             # Имя файла-сценария.
  7. echo
  8. filename=test.data
  9. echo "${filename##*.}"      # data
  10.                             # Расширение файла.


${var%Pattern}, ${var%%Pattern}

Удаляет из переменной $var наименьшую/наибольшую подстроку, совпадающую с шаблоном $Pattern. Поиск ведется с конца строки $var.

Bash версии 2 имеет ряд дополнительных возможностей.

Пример 9-16. Поиск по шаблону в подстановке параметров

  1. #!/bin/bash
  2. # Поиск по шаблону в операциях подстановки параметров # ## % %%.
  3. var1=abcd12345abc6789
  4. pattern1=a*c  # * (символ шаблона), означает любые символы между a и c.
  5. echo
  6. echo "var1 = $var1"           # abcd12345abc6789
  7. echo "var1 = ${var1}"         # abcd12345abc6789   (альтернативный вариант)
  8. echo "Число символов в ${var1} = ${#var1}"
  9. echo "pattern1 = $pattern1"   # a*c  (между 'a' и 'c' могут быть любые символы)
  10. echo
  11. echo '${var1#$pattern1}  =' "${var1#$pattern1}"    #         d12345abc6789
  12. # Наименьшая подстрока, удаляются первые 3 символа  abcd12345abc6789
  13.                                   ^^^^^^            |-|
  14. echo '${var1##$pattern1} =' "${var1##$pattern1}"   #                  6789
  15. # Наибольшая подстрока, удаляются первые 12 символов abcd12345abc6789
  16. #                                 ^^^^^^             |----------|
  17. echo; echo
  18. pattern2=b*9            # все, что между 'b' и '9'
  19. echo "var1 = $var1"     # abcd12345abc6789
  20. echo "pattern2 = $pattern2"
  21. echo
  22. echo '${var1%pattern2}  =' "${var1%$pattern2}"     #     abcd12345a
  23. # Наименьшая подстрока, удаляются последние 6 символов  abcd12345abc6789
  24. #                                 ^^^^^^^^^                       |----|
  25. echo '${var1%%pattern2} =' "${var1%%$pattern2}"    #     a
  26. # Наибольшая подстрока, удаляются последние 12 символов  abcd12345abc6789
  27. #                                 ^^^^^^^^^               |-------------|
  28. # Запомните, # и ## используются для поиска с начала строки,
  29. #            % и %% используются для поиска с конца строки.
  30. echo
  31. exit 0

Пример 9-17. Изменение расширений в именах файлов:

  1. #!/bin/bash
  2. #                 rfe
  3. #                 ---
  4. # Изменение расширений в именах файлов.
  5. #
  6. #         rfe old_extension new_extension
  7. #
  8. # Пример:
  9. # Изменить все расширения *.gif в именах файлов на *.jpg, в текущем каталоге
  10. #          rfe gif jpg
  11. ARGS=2
  12. E_BADARGS=65
  13. if [ $# -ne "$ARGS" ]
  14. then
  15.   echo "Порядок использования: `basename $0` old_file_suffix new_file_suffix"
  16.   exit $E_BADARGS
  17. fi
  18. for filename in *.$1
  19. # Цикл прохода по списку имен файлов, имеющих расширение равное первому аргументу.
  20. do
  21.   mv $filename ${filename%$1}$2
  22.   #  Удалить первое расширение и добавить второе,
  23. done
  24. exit 0

Подстановка значений переменных / Замена подстроки

Эти конструкции перекочевали в Bash из ksh.

${var:pos}

Подстанавливается значение переменной var, начиная с позиции pos.

${var:pos:len}

Подстанавливается значение переменной var, начиная с позиции pos, не более len символов. См. Пример A-16.

${var/Pattern/Replacement}

Первое совпадение с шаблоном Pattern, в переменной var замещается подстрокой Replacement.

Если подстрока Replacement отсутствует, то найденое совпадение будет удалено.

${var//Pattern/Replacement}

Глобальная замена. Все найденые совпадения с шаблоном Pattern, в переменной var, будут замещены подстрокой Replacement.

Как и в первом случае, если подстрока Replacement отсутствует, то все найденые совпадения будут удалены.

Пример 9-18. Поиск по шаблону при анализе произвольных строк

  1. #!/bin/bash
  2. var1=abcd-1234-defg
  3. echo "var1 = $var1"
  4. t=${var1#*-*}
  5. echo "var1 (все, от начала строки по первый символ \"-\", включительно, удаляется) = $t"
  6. #  t=${var1#*-}  то же самое,
  7. #+ поскольку оператор # ищет кратчайшее совпадение,
  8. #+ а * соответствует любым предшествующим символам, включая пустую строку.
  9. # (Спасибо S. C. за разъяснения.)
  10. t=${var1##*-*}
  11. echo "Если var1 содержит \"-\", то возвращается пустая строка...   var1 = $t"
  12. t=${var1%*-*}
  13. echo "var1 (все, начиная с последнего \"-\" удаляется) = $t"
  14. echo
  15. # -------------------------------------------
  16. path_name=/home/bozo/ideas/thoughts.for.today
  17. # -------------------------------------------
  18. echo "path_name = $path_name"
  19. t=${path_name##/*/}
  20. echo "Из path_name удален путь к файлу = $t"
  21. #  В данном случае, тот эе эффект можно получить так:  t=`basename $path_name`
  22. #  t=${path_name%/}; t=${t##*/}   более общее решение,
  23. #+ но имеет некоторые ограничения.
  24. #  Если $path_name заканчивается символом перевода строки, то `basename $path_name` не будет работать,
  25. #+ но для данного случая вполне применимо.
  26. # (Спасибо S.C.)
  27. t=${path_name%/*.*}
  28. # Тот же эффект дает    t=`dirname $path_name`
  29. echo "Из path_name удалено имя файла = $t"
  30. # Этот вариант будет терпеть неудачу в случаях: "../", "/foo////", # "foo/", "/".
  31. #  Удаление имени файла, особенно когда его нет,
  32. #+ использование dirname имеет свои особенности.
  33. # (Спасибо S.C.)
  34. echo
  35. t=${path_name:11}
  36. echo "Из $path_name удалены первые 11 символов = $t"
  37. t=${path_name:11:5}
  38. echo "Из $path_name удалены первые 11 символов, выводится 5 символов = $t"
  39. echo
  40. t=${path_name/bozo/clown}
  41. echo $path_name подстрока \"bozo\" заменена на \"clown\" = $t"
  42. t=${path_name/today/}
  43. echo $path_name подстрока \"today\" удалена = $t"
  44. t=${path_name//o/O}
  45. echo $path_name все символы \"o\" переведены в верхний регистр, = $t"
  46. t=${path_name//o/}
  47. echo "Из $path_name удалены все символы \"o\" = $t"
  48. exit 0
${var/#Pattern/Replacement}

Если в переменной var найдено совпадение с Pattern, причем совпадающая подстрока расположена в начале строки (префикс), то оно заменяется на Replacement. Поиск ведется с начала строки

${var/%Pattern/Replacement}

Если в переменной var найдено совпадение с Pattern, причем совпадающая подстрока расположена в конце строки (суффикс), то оно заменяется на Replacement. Поиск ведется с конца строки

Пример 9-19. Поиск префиксов и суффиксов с заменой по шаблону

  1. #!/bin/bash
  2. # Поиск с заменой по шаблону.
  3. v0=abc1234zip1234abc    # Начальное значение переменной.
  4. echo "v0 = $v0"         # abc1234zip1234abc
  5. echo
  6. # Поиск совпадения с начала строки.
  7. v1=${v0/#abc/ABCDEF}    # abc1234zip1234abc
  8.                         # |-|
  9. echo "v1 = $v1"         # ABCDE1234zip1234abc
  10.                         # |---|
  11. # Поиск совпадения с конца строки.
  12. v2=${v0/%abc/ABCDEF}    # abc1234zip123abc
  13.                         #              |-|
  14. echo "v2 = $v2"         # abc1234zip1234ABCDEF
  15.                         #               |----|
  16. echo
  17. #  ----------------------------------------------------
  18. #  Если совпадение находится не с начала/конца строки,
  19. #+ то замена не производится.
  20. #  ----------------------------------------------------
  21. v3=${v0/#123/000}       # Совпадение есть, но не в начале строки.
  22. echo "v3 = $v3"         # abc1234zip1234abc
  23.                         # ЗАМЕНА НЕ ПРОИЗВОДТСЯ!
  24. v4=${v0/%123/000}       # Совпадение есть, но не в конце строки.
  25. echo "v4 = $v4"         # abc1234zip1234abc
  26.                         # ЗАМЕНА НЕ ПРОИЗВОДТСЯ!
  27. exit 0
${!varprefix*}, ${!varprefix@}

Поиск по шаблону всех, ранее объявленных переменных, имена которых начинаются с varprefix.

  1. xyz23=whatever
  2. xyz24=
  3. a=${!xyz*}      # Подстановка имен объявленных переменных, которые начинаются с "xyz".
  4. echo "a = $a"   # a = xyz23 xyz24
  5. a=${!xyz@}      # То же самое.
  6. echo "a = $a"   # a = xyz23 xyz24
  7. # Эта возможность была добавлена в Bash, в версии 2.04.



[22]    Если $parameter "пустой",в неинтерактивных сценариях, то это будет приводить к завершению с кодом возврата 127 ("command not found").