Как задать переменную в bash
оператор присваивания ( пробельные символы до и после оператора — недопустимы )
Обратите внимание: символ = может использоваться как в качестве оператора присваивания, так и в качестве оператора сравнения, конкретная интерпретация зависит от контекста применения.
Пример 4-2. Простое присваивание
#!/bin/bash # Явные переменные echo # Когда перед именем переменной не употребляется символ '$'? # В операциях присваивания. # Присваивание a=879 echo "Значение переменной \"a\" -- $a." # Присваивание с помощью ключевого слова 'let' let a=16+5 echo "Значение переменной \"a\" теперь стало равным: $a." echo # В заголовке цикла 'for' (своего рода неявное присваивание) echo -n "Значения переменной \"a\" в цикле: " for a in 7 8 9 11 do echo -n "$a " done echo echo # При использовании инструкции 'read' (тоже одна из разновидностей присваивания) echo -n "Введите значение переменной \"a\" " read a echo "Значение переменной \"a\" теперь стало равным: $a." echo exit 0
Пример 4-3. Присваивание значений переменным простое и замаскированное
#!/bin/bash a=23 # Простейший случай echo $a b=$a echo $b # Теперь немного более сложный вариант (подстановка команд). a=`echo Hello!` # В переменную 'a' попадает результат работы команды 'echo' echo $a # Обратите внимание на восклицательный знак (!) в подстанавливаемой команде #+ этот вариант не будет работать при наборе в командной строке, #+ поскольку здесь используется механизм "истории команд" BASH # Однако, в сценариях, механизм истории команд запрещен. a=`ls -l` # В переменную 'a' записывается результат работы команды 'ls -l' echo $a # Кавычки отсутствуют, удаляются лишние пробелы и пустые строки. echo echo "$a" # Переменная в кавычках, все пробелы и пустые строки сохраняются. # (См. главу "Кавычки.") exit 0
# Взято из /etc/rc.d/rc.local R=$(cat /etc/redhat-release) arch=$(uname -m)
| Назад | К началу | Вперед |
| Переменные и параметры. Введение. | Наверх | Переменные Bash не имеют типа |
13. bash №2: переменные
Когда мы говорим сегодня, мы подразумеваем 26 ноября. Если вы читаете эту тему завтра, то для вас слово сегодня будет означать 27 ноября. То есть, есть слово сегодня и оно может иметь различные значения. Постоянная часть, то есть слово сегодня – называется именем переменной или просто переменной, а та часть, которая меняется – 26 ноября или 27 ноября – называется значением переменной. Без переменных нельзя представить программирование и в bash-е они часто используются. Например, в эмуляторе терминала вы видите надпись user@centos8. Собственно user – это логин текущего пользователя, а centos8 – это имя системы. Если зайти другим пользователем или поменять имя системы, то будут отображаться другие значения.
В bash переменные нужны для нескольких задач. Начнём с так называемых локальных переменных, которые также называются shell variables. Это переменные, которые мы сами создаём и нужны они нам для каких-то своих задач.
Для примера создадим переменную files. Я создаю 3 файла:
touch file1 file2 file3
files=file1
Обратите внимание, никаких пробелов, чтобы bash не подумал, что я запускаю программу files. Итак, я создал переменную files и дал ей значение file1. Значение переменной я могу увидеть с помощью команды echo. Echo у нас выводит текст в stdout:
echo Hello World!
и используется во многих задачах, но о нём подробно поговорим в другой раз. Пока что выведем значение переменной c помощью echo:
echo $files
files – имя переменной, а чтобы взять значение нужно перед именем поставить знак доллара. echo нам показал значение file1. Мы можем использовать эту переменную с другими командами, например, чтобы посмотреть:
ls $files rm -i $files
или удалить файл. Но нужно понимать, что значение переменной – просто текст и с файлом он никак не связан. Просто bash превращает переменную в её значение, прежде чем запустить команду. В итоге в терминале получается команда:
rm file1
От того, что я удалил файл, значение переменной никуда не делось:
echo $files
поэтому я могу снова использовать эту переменную:
touch $files
Имя переменной может содержать цифры, но не может начинаться с неё:
file1=file1 1file=file1 (неправильно)
Также в имени переменной нельзя использовать специальные символы, точку, дефис и всё такое:
file.1=file1 (неправильно) file-1=file (неправильно)
Но имя можно писать строчными, заглавными и их комбинацией:
pRiFfKi=2007 echo $pRiFfKi
И помните – всё это регистрозависимо. А в значениях переменных можно указывать всё что угодно, но если там есть пробелы и всякие символы – нужно брать значение в кавычки:
info="Some text here"
Можно при задавании значения переменной использовать значение другой переменной:
myfiles="My files are $files" files="file1 file2 file3" echo $myfiles
Как тут видно, мы указали знак доллара и это воспринялось как значение переменной. Если же мы не хотим, чтобы наши значения обрабатывались, чтобы они были просто текстом, то берём значения в одинарные кавычки:
myfiles='My files are $files' echo $myfiles
либо экранируем знак доллара:
myfiles="My files are \$files" echo $myfiles
Бывает удобно указывать в значении переменной какую-то команду. Для этого нужно начинать значение с символа доллар и указать команду в скобках:
lines=$(tail -5 /etc/passwd | head -2) echo $lines
Либо использовать обратные кавычки:
lines=`tail -5 /etc/passwd | head -2`
но это устаревший метод. Ещё таким образом можно одни команды внедрять в другие, например:
head -2 $(grep -rl bash /etc/ 2> /dev/null)
Кстати, можно использовать tab для дополнения переменных. Так вот, те переменные, которые мы задали, существуют только в текущей bash сессии. Обычно локальные переменные используются во всяких скриптах, которые мы рассмотрим в другой раз, и в обычной работе с терминалом их используют не так часто. Но если вам всё же нужно, чтобы переменная работала и в других окнах, вы можете сохранить её значение в файле ~/.bashrc, как мы это делали для алиасов. Открываем файл:
nano ~/.bashrc
files=»file1 file2 file3″
и сохраняем. В новых сессиях у нас теперь будет задана эта переменная:
echo $files
В противовес локальным переменным, которые используются в рамках текущей bash сессии или скрипта и не особо-то нужны другим программам, существуют переменные окружения – environment variables. С помощью команды env можно увидеть их список. Как вы заметили, все они указаны заглавными буквами. Такие переменные нужны для передачи каких-то значений различным программам.
Например, есть переменная LANG:
env | grep LANG
которая указывает язык для запускаемых программ. Сейчас стоит английский и, если я запущу, допустим, firefox, он запустится на английском языке. Если я поменяю значение этой переменной на русский:
LANG=ru_RU.UTF-8
и запущу firefox через ту же bash сессию – то увижу, что Firefox теперь на русском. То есть, с помощью таких переменных можно настраивать окружение.
Возвращаясь к env, тут есть пара переменных, которые могут нам пригодится в дальнейшем. Например, HOME – указывает на домашнюю директорию текущего пользователя, HOSTNAME на имя системы, USERNAME на имя текущего пользователя и т.п.
Ещё одна примечательная переменная – PATH:
env | grep PATH
Обратите внимание, что в этой переменной перечислены директории. Опустим директории /home/user/bin и /home/user/.local/bin , так как их у нас пока нет, и зайдём в /usr/bin:
cd /usr/bin
Здесь у нас огромное количество файлов – всё это исполняемые файлы, то есть программы. В прошлый раз я говорил, что команды, которые запускает bash – это либо алиасы, либо внутренние команды bash, либо внешние команды. Так вот, в переменной PATH перечислены директории, где искать эти внешние программы. То есть, когда я пишу mkdir, bash ищет во всех директориях PATH наличие такого файла и, если находит, запускает.
Так вот, в отличии от локальных переменных, переменные среды передаются дочерним процессам. Например, до этого мы поменяли значение переменной LANG и firefox при запуске прочитал значение этой переменной, потому что она переменная окружения. Мы можем превратить локальную переменную в переменную окружения, чтобы использовать её в дочерних процессах, с помощью команды export. Например:
files=file1 export files
export files=file1
Это хорошо видно на примере дочерних bash сессий. Например, создадим локальные переменные test1 и test2:
test1=test1 test2=test2
Одну из них экспортнём:
export test1
а другую нет. Тут же можем запустить env и увидеть, что здесь появился test1. Запустив другое окно мы test1 там не найдём, но если запустить дочернюю сессию bash:
bash echo $test1 echo $test2
мы увидим, что у test1 здесь есть значение, а у test2 нет. Потому что дочерние сессии получают только значения переменных окружения. И чтобы задать переменную окружения на постоянно, опять же, нужно редактировать файл.
Мы с вами уже работали с файлом ~/.bashrc, и там можно задать переменную. Но основное предназначение bashrc – настройка алиасов и всяких функций bash для эмулятора терминала. Правильнее говоря, в bashrc задаются настройки bash для интерактивной оболочки, в которой не нужно логиниться – то есть для эмулятора терминала. При запуске он у нас не требует логина и при этом нам нужно с ним вручную работать, то есть интерактивно. То есть, интерактивная оболочка без логина. А, скажем, firefox обычно мы запускаем не через эмулятор терминала, а через лаунчер. И для случаев, когда нам нужно использовать какие-то переменные независимо от эмулятора терминала, то есть независимо от интерактивной оболочки, нам нужен другой файл — ~/.bash_profile. Но, на самом деле, во многих дистрибутивах этот файл при запуске также считывает настройки с ~/.bashrc, из-за чего технически без разницы, где добавлять переменные. Также в каких-то дистрибутивах этот файл обычно называет .profile. Так вот, переменную мы можем создать как в ~/.bashrc, так и в ~/.bash_profile, или вообще создать свой файл со всеми своими алиасами и переменными.
Но я этого делать не буду, просто добавлю свою переменную в ~/.bash_profile:
nano ~/.bash_profile
Единственное что, этот файл считывается в момент моего логина, а значит недостаточно просто открыть новую bash сессию, нужно перезайти в систему. В этом плане ~/.bashrc удобнее. Ну и если мы хотим, чтобы наши переменные работали не только для нашего пользователя, но и для всех других пользователей, то настраивать эти переменные нужно в файлах /etc/profile и /etc/bashrc. А если мы не хотим зависеть от bash-а, а использовать любую другую оболочку, то лучше указывать в /etc/environment.
Так вот, мы с вами разобрались, что bash умеет работать с переменными, что эти переменные бывают локальными и переменными окружения и разобрали, где и как их задавать. Там где есть переменные, там же будут и условия, циклы и прочее, что, действительно, поддерживает bash. Всё это мы будем разбирать в другие разы.
© Copyright 2021, GNU Linux Pro, CC-BY-SA-4.0. Ревизия 5f665cc2 .
Переменные в Bash
Переменные — одна из тех вещей, которые на самом деле довольно просты в использовании, но также довольно легко попасть в проблему, если вы неправильно понимаете, как они работают. Таким образом, в этом разделе есть немного чтения, но если вы потратите время на то, чтобы пройти и понять это, вы будете благодарны за то, что позже вы начали заниматься более сложными сценариями.
Для тех из вас, кто раньше занимался программированием, вы будете хорошо знакомы с переменными. Для тех из вас, кто этого не сделал, подумайте о переменной как временном хранилище для простой информации. Эти переменные могут быть очень полезными для того, чтобы мы могли управлять и контролировать действия нашего скрипта Bash. Мы рассмотрим различные способы, с помощью которых переменные будут иметь свои данные и способы, которыми мы можем их использовать.
Как они работают?
Переменная является временным хранилищем для части информации. Для переменных можно выполнить два действия:
- Установка значения для переменной.
- Чтение значения переменной.
Переменные могут иметь значение, определенное несколькими различными способами. Наиболее распространенными являются установка значения непосредственно и его значение, которое должно быть установлено в результате обработки командой или программой. Вы увидите примеры обоих ниже.
Чтобы прочитать переменную, мы помещаем ее имя (которому предшествует знак $) в любом месте сценария, который нам нужен. Прежде чем Bash интерпретирует (или запускает) каждую строку нашего скрипта, он сначала проверяет, имеются ли какие-либо имена переменных. Для каждой переменной, которую она идентифицировала, она заменяет имя переменной своим значением. Затем он запускает эту строку кода и снова запускает процесс на следующей строке.
Вот несколько быстрых точек синтаксиса. Они будут подробно рассмотрены и продемонстрированы ниже.
- При указании или чтении переменной мы помещаем знак $ перед именем переменной.
- При установке переменной мы оставляем знак $.
- Некоторым людям нравится писать имена переменных в верхнем регистре, чтобы они выделялись. Это ваше предпочтение. Они могут быть все прописными буквами, все строчными буквами или смесью.
- Переменная может быть размещена в любом месте сценария (или в командной строке, если на то пошло), а при запуске Bash заменит его значением переменной. Это стало возможным, поскольку замена выполняется до запуска команды.
Аргументы командной строки
Аргументы командной строки обычно используются и просты в работе, поэтому они являются хорошим местом для начала.
Когда мы запускаем программу в командной строке, вы будете знакомы с предоставлением аргументов после нее, чтобы контролировать ее поведение. Например , мы могли бы выполнить команду Ls -l / и т.д. . -l и / etc — оба аргумента командной строки для команды ls . Мы можем сделать подобное с нашими сценариями bash. Для этого мы используем переменные $ 1 для представления первого аргумента командной строки, $ 2 для представления второго аргумента командной строки и т. д. Они автоматически устанавливаются системой, когда мы запускаем наш скрипт, поэтому все, что нам нужно сделать, это обратиться к ним.
Давайте посмотрим на пример mycopy.sh
#!/bin/bash # Простой сценарий копирования cp $1 $2 # Давайте проверим, что копия работала echo Details for $2 ls -lh $2
Давайте разберем это:
- Строка 4 — запустите команду cp с первым аргументом командной строки в качестве источника и второго аргумента командной строки в качестве адресата.
- Строка 8 — запуск эха команды для печати сообщения.
- Строка 9 — После завершения копирования запустите команду ls для адресата, чтобы убедиться, что она сработала. Мы включили опции l, чтобы показать нам дополнительную информацию и h, чтобы сделать размер читаемым человеком, чтобы мы могли проверить его правильность копирования.
Мы обсудим их использование немного больше в следующей статье.
Другие специальные переменные
Есть несколько других переменных, которые система устанавливает и для вас.
- $0 — имя скрипта Bash.
- $1-$9 — Первые 9 аргументов для скрипта Bash. (Как уже упоминалось выше.)
- $# — Сколько аргументов было передано скрипту Bash.
- $@ — Все аргументы, предоставленные сценарию Bash.
- $?— Статус выхода последнего процесса.
- $$ — Идентификатор процесса текущего скрипта.
- $USER — имя пользователя, выполняющего скрипт.
- $HOSTNAME — имя хоста, на котором запущен скрипт.
- $SECONDS — количество секунд с момента запуска скрипта.
- $RANDOM — Возвращает другое случайное число каждый раз, когда он упоминается.
- $LINENO — возвращает текущий номер строки в сценарии Bash.
Если вы введете команду env в командной строке, вы увидите список других переменных, к которым вы также можете обратиться.
Некоторые из этих переменных могут показаться вам полезными. Другие не могут. По мере продвижения к более сложным сценариям в последующих разделах вы увидите примеры того, как они могут быть полезны.
Настройка собственных переменных
Помимо переменных, которые заданы системой, мы можем также установить собственные переменные. Это может быть полезно для отслеживания результатов команд и возможности ссылаться на них и обрабатывать их позже.
Существует несколько способов, которыми могут быть заданы переменные (например, часть выполнения команды), но базовая форма следует этому шаблону:
Это одна из тех областей, где важно форматирование. Обратите внимание, что по обе стороны от знака равенства (=) нет места. Мы также оставляем знак $ с начала имени переменной при настройке.
Имена переменных могут быть прописными или строчными буквами или смесью обоих, но Bash — это среда, чувствительная к регистру, поэтому всякий раз, когда вы ссылаетесь на переменную, вы должны быть последовательны при использовании прописных и строчных букв. Вы всегда должны убедиться, что имена переменных являются описательными. Это облегчает вам задачу.
Вот простой пример, иллюстрирующий их использование.
#!/bin/bash # Пример простой переменной myvariable=Hello anothervar=Fred echo $myvariable $anothervar echo sampledir=/etc ls $sampledir
Давайте разберем это:
- Строки 4 и 6 — задайте значение двух переменных myvariable и anothervar.
- Строка 8 — запустить эхо команды, чтобы проверить, что переменные были установлены в соответствии с назначением.
- Строка 9 — запустите команду echo на этот раз без аргументов. Это хороший способ получить пустую строку на экране, чтобы помочь решить проблему.
- Строка 11 — установите другую переменную, на этот раз в качестве пути к определенному каталогу.
- Строка 13 — запустите команду ls, заменив значение переменной sampledir в качестве первого аргумента командной строки.
Важно отметить, что в приведенном выше примере мы использовали команду echo просто потому, что это удобный способ продемонстрировать, что переменные действительно были установлены. эхо не требуется для использования переменных и используется только тогда, когда вы хотите напечатать определенное сообщение на экране. (Практически все команды печатают вывод на экран по умолчанию, поэтому вам не нужно помещать эхо перед ними.)
Переменные могут быть полезны для упрощения управления нашими сценариями. Возможно, наш скрипт будет запускать несколько команд, некоторые из которых будут ссылаться на конкретный каталог. Вместо того, чтобы вводить эту директорию каждый раз, когда мы можем установить ее один раз в переменной, обратитесь к этой переменной. Затем, если требуемый каталог изменится в будущем, нам нужно обновить только одну переменную, а не каждый экземпляр внутри скрипта.
Цитаты
В приведенном выше примере мы сохранили все хорошо и просто. Переменные должны были хранить только одно слово. Если мы хотим, чтобы переменные сохраняли более сложные значения, нам нужно использовать кавычки. Это связано с тем, что при обычных условиях Bash использует пространство для определения отдельных элементов.
- Помните, что команды работают точно так же в командной строке, как и в скрипте.
Поскольку команды работают точно так же в командной строке, как в скрипте, иногда бывает легче экспериментировать в командной строке.
Когда мы заключим наш контент в кавычки, мы указываем Bash, что содержимое должно рассматриваться как отдельный элемент. Вы можете использовать одинарные кавычки (‘) или двойные кавычки («).
- Одиночные кавычки будут обрабатывать каждый символ буквально.
- Двойные кавычки позволят вам выполнять подстановку (то есть включают переменные в пределах значения).
Замена команды
Подстановка команд позволяет нам выводить вывод команды или программы (что обычно печатается на экране) и сохранять ее как значение переменной. Для этого мы помещаем его в скобки, которому предшествует знак $.
Подстановка команд хороша и проста, если вывод команды — это одно слово или строка. Если выход идет по нескольким строкам, то новые строки просто удаляются, и весь вывод заканчивается на одной строке.
Давайте разберем это:
- Строка 1 — Запустим команду ls . Обычно его выход будет состоять из нескольких строк. Я немного сократил его в приведенном выше примере, чтобы сэкономить место.
- Строка 4 — Когда мы сохраняем команду переменной myvar, все строки новой строки удаляются , а вывод теперь находится в одной строке.
Когда вы играете с подстановкой команд, рекомендуется проверить ваш результат, а не предполагать, что он будет вести себя определенным образом. Самый простой способ сделать это — просто повторить переменную и посмотреть, что произошло. (После этого вы можете удалить команду эха, когда вы будете счастливы.)
Экспорт переменных
Помните, как в предыдущем разделе мы говорили о сценариях, запущенных в их собственном процессе ? Это вводит явление, известное как область действия, которая влияет на переменные между прочим. Идея состоит в том, что переменные ограничены процессом, в котором они были созданы. Нормальный это не проблема, но иногда, например, сценарий может запускать другой скрипт в качестве одной из его команд. Если мы хотим, чтобы переменная была доступна для второго скрипта, нам нужно экспортировать переменную.
script1.sh
#!/bin/bash # demonstrate variable scope 1. var1=blah var2=foo # Let's verify their current value echo $0 :: var1 : $var1, var2 : $var2 export var1 ./script2.sh # Let's see what they are now echo $0 :: var1 : $var1, var2 : $var2
script2.sh
#!/bin/bash # demonstrate variable scope 2 # Let's verify their current value echo $0 :: var1 : $var1, var2 : $var2 # Let's change their values var1=flop var2=bleh
Теперь давайте запустим его и посмотрим, что произойдет.
Вывод выше может показаться неожиданным. Фактически, когда мы экспортируем переменную, мы говорим Bash, что каждый раз, когда создается новый процесс (для запуска другого скрипта или такого), создайте копию переменной и передайте ее новому процессу. Поэтому, хотя переменные имеют одно и то же имя, они существуют в отдельных процессах и поэтому не связаны друг с другом.
Экспорт переменных — односторонний процесс. Первоначальный процесс может передавать переменные новому процессу, но все, что происходит с копией переменных, не влияет на исходные переменные.
Экспорт переменных — это то, что вам, вероятно, не нужно будет беспокоиться о большинстве сценариев Bash, которые вы создадите. Иногда вы можете захотеть разбить конкретную задачу на несколько отдельных сценариев, однако упростить управление или разрешить повторное использование (что всегда хорошо). Например, вы можете создать сценарий, в котором будет скопирована копия всех файлов, экспортированных на определенную переменную, датированной (то есть сегодняшней датой, предшествующей имени файла). Затем вы можете легко вызвать этот скрипт из других сценариев, которые вы создаете, всякий раз, когда вы хотите сделать снимок набора файлов.
Определение переменной в Bash: с командой export и без
Bash-переменные Linux предполагают два способа определения переменной оболочки — с командой export и без нее. Это важный момент — добавление этой команды меняет область действия переменной. В этой статье разберем различия между определением переменной оболочки с export и без, а также рассмотрим варианты использования export и его параметры.
Это адаптированный перевод статьи Defining a Bash Variable With or Without ‘export’ из блога образовательного проекта Baeldung.
С одной стороны, Bash — самый популярный командный интерпретатор в юниксоподобных системах, особенно в GNU/Linux. С другой — скриптовый язык программирования со своим синтаксисом и особенностями.
Бесплатные курсы по программированию в Хекслете
- Освойте азы современных языков программирования
- Изучите работу с Git и командной строкой
- Выберите себе профессию или улучшите навыки
Определение переменной с export и без
Переменные Bash похожи на переменные в Java или C++, но с одним существенным отличием: они не нуждаются в объявлении. Переменную создает присвоение ее имени значения. Например, так:
$ MYVAR=1729 $ export MYVAR=1729 В первом случае создается переменная оболочки с именем MYVAR, которой присваивается значение 1729. Во втором определение переменной происходит точно также, но с помощью export . Эта команда отмечает переменную для экспорта во все дочерние процессы, которые созданы внутри оболочки и делают ее переменной окружения.
Читайте также: Как сохранять фокус на протяжении всего обучения: советы от Хекслета
Основное различие между этими двумя способами определения переменной заключается в том, что export делает переменную доступной для всех следующих команд, которые выполняются в этой оболочке. Команда export помечает MYVAR для автоматического экспорта в среду дочерних процессов, которые создаются такими командами:
$ export MYVAR=1729 $ echo $MYVAR 1729 $ bash # Open a new child shell $ echo $MYVAR 1729 Если переменная задана без использования export, то она будет доступна только внутри оболочки. Другими словами, дочерние оболочки, процесс или команды вне ее не получат доступа к ней:
$ MYVAR=1729 $ echo $MYVAR 1729 $ bash # Open a new child shell $ echo $MYVAR $ Отличия переменных в Bash от переменных в других языках программирования заключаются в следующем:
- Переменные оболочки (определенные без экспорта) подобны локальным переменным. Доступ к ним можно получить только внутри этой оболочки.
- Переменные окружения (определенные с помощью экспорта) подобны глобальным переменным. Доступ к ним могут получить как в родительской оболочке, так и во всех дочерних оболочках, процессах и командах.
Однако между глобальными переменными в Bash и других языках программирования существует важное различие. Родительская оболочка может экспортировать свои переменные в среду дочерней оболочки, но дочерняя оболочка не может экспортировать переменные обратно в родительскую.
Когда стоит использовать export, а когда — нет
Переменные окружения следует использовать в случае, когда нужно экспортировать переменные и сделать их доступными для следующих команд и процессов. Обычно это происходит, когда среду нужно использовать вместе с дочерними процессами, например:
- При настройке среды дочернего процесса или оболочки
- При определении переменной, которую будет использовать сценарий bash, выполняемый из родительской оболочки
- При настройке переменных окружения для терминальных мультиплексоров (например, screen или tmux)
- При настройке среды сборки для сценариев и инструментов сборки
Переменные оболочки стоит использовать в случаях, когда они должны существовать только в родительской оболочке. Например, к ним относятся:
- Переменные счетчика циклов
- Временные переменные
Как использовать export
Подробнее рассмотрим команду export и связанные с ней команды, которые часто используются с переменными окружения и оболочки.
Экспорт функции
export может экспортировать не только переменные, но и функции. Для этого нужно использовать опцию командной строки export -f . Стоит отметить, что функции будут доступны и в дочерних оболочках и процессах:
$ func() > echo hi > > $ func hi $ bash # Open a new child shell $ func bash: func: command not found $ exit # Back to parent shell $ export -f func $ bash # Open a new child shell $ func hi Удаление переменной
Переменные окружения автоматически экспортируются во все дочерние оболочки, а также в их дочерние оболочки. Для удаления автоматически унаследованной переменной существует команда export -n :
$ echo $USER ubuntu $ bash # Open a new child shell $ echo $USER ubuntu $ exit # Back to parent shell $ export -n USER $ bash # Open a new child shell again $ echo $USER $ Список всех экспортированных переменных
Для получения списка всех переменных и функций, экспортированных в текущую оболочку, используется команда export -p :
$ export -p declare -x COLORTERM="truecolor" declare -x DESKTOP_SESSION="ubuntu" declare -x DISPLAY=":0" declare -x GDMSESSION="ubuntu" declare -x LESSCHARSET="latin1" declare -x LESSCLOSE="/usr/bin/lesspipe %s %s" declare -x LESSOPEN="|/usr/bin/lesspipe.sh %s 2>&-" . . declare -x XDG_SESSION_DESKTOP="ubuntu" declare -x XDG_SESSION_ID="2" declare -x XDG_SESSION_TYPE="x11" declare -x XDG_VTNR="1" Эта команда помогает проверить, что все переменные оболочки экспортированы правильно.
Автоматический экспорт всех переменных
Для автоматического экспорта всех переменных, определенных в текущей оболочке, существует опция all export . Ее можно включать или отключать, используя команду set :
$ set -a # Enable allexport using single letter syntax $ set -o allexport # Enable using full option name syntax $ set +a # Disable allexport using single letter syntax $ set +o allexport # Disable using full option name syntax $ set -a $ MYVAR=1729 # no export $ bash # Open a new child shell $ echo $MYVAR 1729 Эту команду полезно включать перед вызовом сценария Bash, который определяет множество переменных без команды экспорта.
Как связаны родительская и дочерние оболочки
У передачи переменной окружения между родительской и дочерними оболочками существует определенная иерархия:
Сценарии и export
При создании сценария, вызываемого из командной оболочки и содержащего команду export , нужно проверить соответствие результата экспорта ожидаемому. Для этого есть несколько способов.
Export во время выполнения скрипта
Выполнение сценария с командой export из командной оболочки происходит в дочерней оболочке. Это означает, что любые переменные, экспортируемые сценарием, будут доступны только его дочерним оболочкам, но не родительской. Когда выполнение сценария завершится, экспортированные переменные исчезнут из среды:
$ echo "export MYVAR=1729" > myscript.sh $ chmod +x myscript.sh $ ./myscript.sh $ echo $MYVAR $ Экспорт переменной в родительскую оболочку
Если при выполнении сценария необходимо экспортировать переменную окружения в родительскую оболочку, можно использовать команду source . Она позволяет выполнить сценарий в текущей среде без создания дочерней оболочки.
$ echo "MYVAR=1729" > myscript.sh $ source myscript.sh $ echo $MYVAR 1729 Заключение
Команда export помогает экспортировать переменные окружения так, чтобы они были доступны во всех дочерних процессах, оболочках и командах. Кроме того, различные параметры командной строки export и других связанных команд предоставляют различные способы определения, экспорта и использования переменных в разных оболочках и сценариях.
Бесплатные курсы по программированию в Хекслете
- Освойте азы современных языков программирования
- Изучите работу с Git и командной строкой
- Выберите себе профессию или улучшите навыки