Как создать переменную в линукс
Окружение (environment) или среда — это набор пар ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ, доступный каждому пользовательскому процессу. Иными словами, окружение — это набор переменных окружения. Если вы используете оболочку, отличную от bash, то не все примеры этой главы могут быть воспроизведены. Для того, чтобы посмотреть окружение, просто введите команду env без аргументов. В зависимости от конфигурации системы, вывод env может занять несколько экранов, поэтому лучше сделать так:
$ env > myenv $
$ env | more
$ env | less $
Переменные окружения могут формироваться как из заглавных, так и из строчных символов, однако исторически сложилось именовать их в верхнем регистре. Мы также не будем отступать от этого неписанного правила. Про полезность окружения можно говорить долго, но основное его назначение — заставить одни и те же программы работать у разных пользователей по-разному. Приятно, например, когда программа «угадывает» имя пользователя или домашний каталог пользователя. Чаще всего такая информация «добывается» из переменных окружения USER и HOME соответственно. Значение каждой переменной окружения изначально представляет собой строковую константу (строку). Интерпретация значений переменных полностью возлагается на программу. Иными словами, все переменные окружения имеют тип char*, а само окружение имеет тип char**. Чтобы вывести на экран значение какой-нибудь переменной окружения, достаточно набрать echo $ИМЯ_ПЕРЕМЕННОЙ:
$ echo $USER nn $ echo $HOME /home/nn $
- USER — имя текущего пользователя
- HOME — путь к домашнему каталогу текущего пользователя
- PATH — список каталогов, разделенных двоеточиями, в которых производится «поиск» программ
- PWD — текущий каталог
- OLDPWD — предыдущий текущий каталог
- TERM — тип терминала
- SHELL — текущая командная оболочка
- HOSTNAME — имя машины
- QTDIR — расположение библиотеки QT
- MAIL — почтовый ящик
- LD_LIBRARY_PATH — место «поиска» дополнительных библиотек (см. предыдущую главу)
- MANPATH — место поиска файлов man-страниц (каталоги, разделенные двоеточием)
- LANG — язык и кодировка пользователя (иногда LANGUAGE)
- DISPLAY — текущий дисплей в X11
Помимо переменных окружения, командные оболочки, такие как bash располагают собственным набором пар ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ. Это переменные оболочки. Набор таких переменных называют окружением (или средой) оболочки. Эти переменные чем-то напоминают локальные (стековые) переменные в языке C. Они недоступны для других программ (в том числе и для env) и используются в основном в сценариях оболочки. Чтобы задать переменную оболочки, достаточно написать в командной строке ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ.
$ MYVAR=Hello $ echo $MYVAR Hello $ env | grep MYVAR $
Однако, при желании, можно включить локальную переменную оболочки в основное окружение. Для этого используется команда export:
$ export MYVAR $ env | grep MYVAR MYVAR=Hello $
Можно сделать сразу так:
$ export MYNEWVAR=Goodbye $ echo $MYNEWVAR Goodbye $ env | grep MYNEWVAR MYNEWVAR=Goodbye $
Прежде, чем продолжать дальше, попробуйте поиграться с переменными окружения, чтобы лучше все понять. Выясните экспериментальным путем, чувствительны ли к регистру символов переменные окружения; можно ли использовать в качестве значений переменных окружения строки, содержащие пробелы; если можно, то как?
Теперь разберемся с тем, откуда берется окружение. Любая запущенная и работающая в Linux программа — это процесс. Запуская дважды одну и ту же программу, вы получаете два процесса. У каждого процесса (кроме init) есть свой процесс-родитель. Когда вы набираете в командной строке vim, в системе появляется новый процесс, соотвествующий текстовому редактору vim; родительским процессом здесь будет оболочка (bash, например). Для самой оболочки новый процесс будет дочерним. Мы будем подробно изучать процессы в последующих главах книги. Сейчас же важно одно: новый процесс получает копию родительского окружения. Из этого правила существует несколько исключений, но мы пока об этом говорить не будем. Важно то, что у кажного процесса своя независимая копия окружения, с которой процесс может делать все что угодно. Если процесс завершается, то копия теряется; если процесс породил другой, дочерний процесс, то этот новый процесс получает копию окружения своего родителя. Мы еще неоднократно столкнемся с окружением при изучении многозадачности.
4.2. Массив environ
Теперь, когда мы разобрались, что такое окружение, самое время написать программу для взаимодействия с окружением. Чтобы показать, как это все работает, сначала изобретем велосипед.
В заголовочном файле unistd.h объявлен внешний двумерный массив environ:
extern char ** environ;
В этом массиве хранится копия окружения процесса. Точка.
Массив не константный, но я не рекомендую вам изменять его — это опасно (для программы) и является плохим стилем программирования. Для изменения environ есть специальные механизмы, которые мы рассмотрим чуть позже. Уверен, что настоящие будущие хакеры прочитают это и сделают с точностью до «наоборот».
А читать environ нам никто не запрещал. Напишем одноименную программу (environ), которой в качестве аргумента передается имя переменной. Программа будет проверять, существует ли эта переменная в окружении; и если существует, то каково ее значение. Как мы позже узнаем, это можно было бы сделать значительно проще. Но я предупредил: мы изобретаем велосипед. Вот эта программа:
/* environ.c */ #include #include #include #include extern char ** environ; /* Environment itself */ int main (int argc, char ** argv) < int i; if (argc < 2) < fprintf (stderr, "environ: Too few arguments\n"); fprintf (stderr, "Usage: environ \n"); exit (1); > for (i = 0; environ[i] != NULL; i++) < if (!strncmp (environ[i], argv[1], strlen (argv[1]))) < printf ("'%s' found\n", environ[i]); exit (0); >> printf ("'%s' not found\n", argv[1]); exit (0); >
А вот Makefile для этой программы (если нужен):
# Makefile for environ environ: environ.c gcc -o environ environ.c clean: rm -f environ
$ make gcc -o environ environ.c $ ./environ environ: Too few arguments Usage: environ $ ./environ USER 'USER=nn' found $ ./environ ABRAKADABRA 'ABRAKADABRA' not found $
В приведенном примере мы осуществили простой синтаксический анализ массива environ, так как переменные и значения представлены в нем в обычном виде (ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ). К счастью нам больше не придется осуществлять синтаксический разбор массива environ. О настоящем предназначении этого массива будет рассказано в главе, посвященной многозадачности.
4.3. Чтение окружения: getenv()
В заголовочном файле stdlib.h объявлена функция getenv , которая доказывает, что в предыдущем примере мы изобрели велосипед. Ниже приведен адаптированный прототип этой функции.
char * getenv (const char * name);
Функция эта работает очень просто: если в качестве аргумента указано имя существующей переменной окружения, то функция возвращает указатель на строку, содержащую значение этой переменной; если переменная отсутствует, возвращается NULL.
Как видим, функция getenv() позволяет не осуществлять синтаксический разбор environ. Напишем новую программу, которая делает то же, что и предыдущая, только более простым способом. Назовем ее getenv по имени функции — виновника торжества.
/* getenv.c */ #include #include int main (int argc, char ** argv) < if (argc < 2) < fprintf (stderr, "getenv: Too few arguments\n"); fprintf (stderr, "Usage: getenv \n"); exit (1); > char * var = getenv (argv[1]); if (var == NULL) < printf ("'%s' not found\n", argv[1]); exit (0); >printf ("'%s=%s' found\n", argv[1], var); exit (0); >
4.4. Запись окружения: setenv()
Пришла пора модифицировать окружение! Еще раз напоминаю: каждый процесс получает не доступ к окружению, а копию окружения родительского процесса (в нашем случае это командная оболочка). Чтобы добавить в окружение новую переменную или изменить существующую, используется функция setenv, объявленная в файле stdlib.h. Ниже приведен адаптированный прототип этой функции.
int setenv (const char * name, const char * value, int overwrite);
Если хотите узнать, что значит «адаптированный прототип», загляните в /usr/include/stdlib.h на объявления функций getenv() и setenv() и больше не спрашивайте 😉
Функция setenv() устанавливает значение (второй аргумент, value) для переменной окружения (первый аргумент, name). Третий аргумент — это флаг перезаписи. При ненулевом флаге уже существующая переменная перезаписывается, при нулевом флаге переменная, если уже существует, — не перезаписывается. В случае успешного завершения setenv() возвращает нуль (даже если существующая переменная не перезаписалась при overwrite==0). Если в окружении нет места для новой переменной, то setenv() возвращает -1.
Наша новая программа setenv читает из командной строки два аргумента: имя переменной и значение этой переменной. Если переменная не может быть установлена, выводится ошибка, если ошибки не произошло, выводится результат в формате ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ. Вот эта программа:
/* setenv.c */ #include #include #define FL_OVWR 0 /* Overwrite flag. You may change it. */ int main (int argc, char ** argv) < if (argc < 3) < fprintf (stderr, "setenv: Too few arguments\n"); fprintf (stderr, "Usage: setenv \n"); exit (1); > if (setenv (argv[1], argv[2], FL_OVWR) != 0) < fprintf (stderr, "setenv: Cannot set '%s'\n", argv[1]); exit (1); >printf ("%s=%s\n", argv[1], getenv (argv[1])); exit (0); >
Изменяя константу FL_OVWR можно несколько изменить поведение программы по отношению к существующим переменным окружения. Еще раз напоминаю: у каждого процесса своя копия окружения, которая уничтожается при завершении процесса. Экспериментируйте!
4.5. Сырая модификация окружения: putenv()
Функция putenv(), объявленная в заголовочном файле stdlib.h вызывается с единственным аргументом — строкой формата ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ или просто ПЕРЕМЕННАЯ. Обычно такие преформатированные строки называют запросами. Если переменная отсутствует, то в окружение добавляется новая запись. Если переменная уже существует, то текущее значение перезаписывается. Если в качестве аргумента фигурирует просто имя переменной, то переменная удаляется из окружения. В случае удачного завершения, putenv() возвращает нуль и -1 — в случае ошибки.
У функции putenv() есть одна особенность: указатель на строку, переданный в качестве аргумента, становится частью окружения. Если в дальнейшем строка будет изменена, будет изменено и окружение. Это очень важный момент, о котором не следует забывать. Ниже приведен адаптированный прототип функции putenv:
int putenv (char * str);
Теперь напишем программу, использующую putenv(). Вот она:
/* putenv.c */ #include #include #include #define QUERY_MAX_SIZE 32 char * query_str; void print_evar (const char * var) < char * tmp = getenv (var); if (tmp == NULL) < printf ("%s is not set\n", var); return; >printf ("%s=%s\n", var, tmp); > int main (void)
Программа немного сложнее тех, что приводились ранее, поэтому разберем все по порядку. Сначала создаем для удобства функцию print_evar (PRINT Environment VARiable), которая будет отражать текущее состояние переменной окружения, переданной в качестве аргумента. В функции main() перво-наперво выделяем в куче (heap) память для буфера, в который будут помещаться запросы; заносим адрес буфера в query_str. Теперь формируем строку, и посылаем запрос в функцию putenv(). Здесь нет ничего необычного. Дальше идет демонстрация того, на чем я акцентировал внимание: простое изменение содержимого памяти по адресу, хранящемуся в query_str приводит к изменению окружения; это видно из вывода функции print_evar(). Наконец, вызываем putenv() со строкой, не содержащей символа ‘=’ (равно). Это запрос на удаление переменной из окружения. Функция print_evar() подтверждает это.
Хочу заметить, что putenv() поддерживается не всеми версиями Unix. Если нет крайней необходимости, лучше использовать setenv() для пополнения/модификации окружения.
4.6. Удаление переменной окружения: unsetenv()
Функция unsetenv(), объявленная в stdlib.h, удаляет переменную из окружения. Ниже приведен адаптированный прототип этой функции.
int unsetenv (const char * name);
Прежде всего хочу обратить внимание на то, что раньше функция unsetenv() ничего не возращала (void). С выходом версии 2.2.2 библиотеки glibc (январь 2001 года) функция стала возвращать int.
Функция unsetenv() использует в качестве аргумента имя переменной окружения. Возвращаемое значение — нуль при удачном завершении и -1 в случае ошибки. Рассмотрим простую программу, которая удаляет переменную окружения USER (. ). Для тех, кто испугался, напоминаю еще один раз: каждый процесс работает с собственной копией окружения, никак не связанной с копиями окружения других процессов, за исключением дочерних процессов, которых у нас нет. Ниже приведен исходный код программы, учитывающий исторические изменения прототипа функции unsetenv().
/* unsetenv.c */ #include #include #include #include #define OLD_LIBC_VERSION 0 #define NEW_LIBC_VERSION 1 #define E_VAR "USER" int libc_cur_version (void) < int ret = strcmp (gnu_get_libc_version (), "2.2.2"); if (ret < 0) return OLD_LIBC_VERSION; return NEW_LIBC_VERSION; >int main (void) < int ret; char * str; if (libc_cur_version () == OLD_LIBC_VERSION) < unsetenv (E_VAR); >else < ret = unsetenv (E_VAR); if (ret != 0) < fprintf (stderr, "Cannot unset '%s'\n", E_VAR); exit (1); >> str = getenv (E_VAR); if (str == NULL) < printf ("'%s' has removed from environment\n", E_VAR); >else < printf ("'%s' hasn't removed\n", E_VAR); >exit (0); >
В программе показан один из самых варварских способов подстроить код под версию библиотеки. Это сделано исключительно для демонстрации двух вариантов unsetenv(). Никогда не делайте так в реальных программах. Намного проще и дешевле (в плане времени), не получая ничего от unsetenv() проверить факт удаления переменной при помощи getenv().
4.7. Очистка окружения: clearenv()
Функция clearenv(), объявленная в заголовочном файле stdlib.h, используется крайне редко для полной очистки окружения. clearenv() поддерживается не всеми версиями Unix. Ниже приведен ее прототип.
int clearenv (void);
При успешном завершении clearenv() возвращает нуль. В случае ошибки возвращается ненулевое значение.
В большинстве случаев вместо clearenv() можно использовать следующую инструкцию:
environ = NULL;
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 .
Переменные окружения в Linux: как посмотреть, установить и сбросить
Переменные окружения (или переменные среды) — это набор пар ключ-значение, которые хранятся в вашем Linux и используются процессами для выполнения определенных операций. Они отвечают за стандартное поведение системы и приложений. При взаимодействии с вашим сервером через сеанс оболочки, есть много информации, которую ваша оболочка обрабатывает, чтобы определить ее поведение и доступы. Некоторые из этих параметров содержатся в настройках конфигурации, а другие определяются пользовательским вводом. Оболочка отслеживает все эти параметры и настройки через окружение. Окружение — это область, которую оболочка создает каждый раз при запуске сеанса, содержащего переменные, определяющие системные свойства. Например, это может быть часовой пояс в системе, пути к определенным файлам, приложения по-умолчанию, локали и многое другое. Переменные окружения также могут использоваться в программах оболочки или в подоболочках для выполнения различных операций.
В этом руководстве мы расскажем, как просматривать, устанавливать и сбрасывать переменные окружения в вашей системе.
Переменные окружения и переменные оболочки
Переменные имеют следующий формат:
KEY=value KEY="Some other value" KEY=value1:value2
Должны соблюдаться следующие правила:
- Имена переменных чувствительны к регистру (регистрозависимы). Переменные окружения должны быть написаны большими буквами (UPPER CASE).
- Несколько значений переменных разделяются двоеточием :
- Вокруг символа = нет пробела
Переменные можно разделить на две категории:
- Переменные окружения (Environmental Variables) — это переменные, которые определены для текущей оболочки и наследуются любыми дочерними оболочками или процессами. Переменные окружения используются для передачи информации в процессы, которые порождаются из оболочки.
- Переменные оболочки (Shell Variables) — это переменные, которые содержатся исключительно в оболочке, в которой они были установлены или определены. Они часто используются для отслеживания эфемерных данных, например, текущего рабочего каталога.
Про Linux за 5 минут
Вывести список всех переменных окружения и оболочки
Мы можем увидеть список всех наших переменных окружения, используя команды env или printenv . В состоянии по умолчанию они должны работать точно так же:
SHELL=/bin/bash TERM=xterm USER=demouser LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:ca. MAIL=/var/mail/demouser PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games PWD=/home/demouser LANG=en_US.UTF-8 SHLVL=1 HOME=/home/demouser LOGNAME=demouser LESSOPEN=| /usr/bin/lesspipe %s LESSCLOSE=/usr/bin/lesspipe %s %s _=/usr/bin/printenv
Это типичный вывод как для env , так и для printenv . Разница между этими двумя командами проявляется только в их более конкретной функциональности. Например, с помощью printenv вы можете запросить значения отдельных переменных:
printenv SHELL
/bin/bash
А как посмотреть переменные оболочки? Для этого можно использовать команду set . Если мы введем set без каких-либо дополнительных параметров, мы получим список всех переменных оболочки, переменных окружения, локальных переменных и функций оболочки:
BASH=/bin/bash BASHOPTS=checkwinsize:cmdhist:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath BASH_ALIASES=() BASH_ARGC=() BASH_ARGV=() BASH_CMDS=() . . .
Тут мы получим гигантский вывод, поэтому стоит использовать less , чтобы разделить содержимое на страницы:
set | less
Также для вывода переменной оболочки можно использовать команду echo :
echo $ BASH_VERSION
Получим ответ:
4.4.19 (1) -release
Общий набор переменных окружения в Linux
- USER: текущее имя пользователя, использующего систему
- EDITOR: какая программа запускается для редактирования файла на вашем хосте
- HOME: домашний каталог текущего пользователя
- PATH: список каталогов, разделенных двоеточиями, в которых система ищет команды
- PS1: основная строка приглашения (для определения отображения приглашения оболочки)
- PWD: текущий рабочий каталог
- _: самая последняя команда, выполненная в системе пользователем
- MAIL: путь к почтовому ящику текущего пользователя
- SHELL: оболочка, используемая для интерпретации команд в системе, она может быть много разных (например, bash, sh, zsh или другие)
- LANG: кодировка языка, используемая в системе
- DESKTOP_SESSION: текущий рабочий стол, используемый на вашем хосте (GNOME, KDE)
- HISTFILESIZE: количество строк истории команд, сохраненных в файле истории
- HISTSIZE: количество строк истории, разрешенных в памяти
- UID: текущий UID для пользователя
- HOSTNAME: имя компьютера системы
- TERM: указывает тип терминала
- OLDPWD: предыдущий рабочий каталог
- BASHOPTS: список параметров, которые использовались при выполнении bash.
- BASH_VERSION: версия bash, выполняемая в удобочитаемой форме.
- BASH_VERSINFO: версия bash с машиночитаемым выводом.
- COLUMNS: Количество столбцов в ширину, которые используются для вывода вывода на экран.
- DIRSTACK: стек каталогов, доступных с помощью команд pushd и popd.
- IFS: внутренний разделитель полей для разделения ввода в командной строке. По умолчанию это пробел.
- SHELLOPTS: параметры оболочки, которые можно установить с помощью параметра set.
Установка переменных окружения в Linux
В Linux у вас есть много разных способов установки переменных окружения в зависимости от того, хотите ли вы сделать их постоянными или нет.
Самый простой способ установить переменные окружения — использовать команду export .
export VAR="value"
Для примера создаим новую переменную, а затем экспортируем ее.
Чтобы создать новую переменную оболочки с именем NEW_VARIABLE и значением «test», и затем сразу экспортировать ее введите:
export NEW_VARIABLE='test'
printenv NEW_VARIABLE test
Используя export , ваша переменная окружения будет установлена для текущего сеанса оболочки. Как следствие, если вы откроете другую оболочку или перезапустите свою систему, переменная окружения больше не будет доступна.
Установить постоянные переменные окружения в Linux
Как вы видели в предыдущем разделе, переменные окружения не были постоянными при перезапуске оболочки. Однако существует способ сделать ваши изменения постоянными: с помощью системных файлов, которые читаются и выполняются в определенных условиях.
Использование файла .bashrc
Самый популярный способ постоянной установки переменных среды — это добавить их в файл .bashrc .
Файл .bashrc — это скрипт, выполняемый всякий раз, когда вы инициализируете сеанс интерактивной оболочки. Как следствие, когда вы запускаете новый терминал через интерфейс GNOME или просто используете screen сессию, вы будете использовать файл .bashrc .
Например, добавьте следующие записи в ваш файл .bashrc :
export TZ="America/New_York"
Сохраните ваш файл и используйте команду source для перезагрузки файла bashrc для текущего сеанса оболочки.
source ~/.bashrc
Вы можете вывести новую переменную окружения с помощью printenv и посмотреть, дату в Linux, изменив TZ.
$ printenv TZ America/New_York $ date Sat 19 Jan 2020 10:03:00 AM EDT
Отлично, ваши изменения теперь сохраняются после перезагрузки оболочки или системы!
Использование файла .bash_profile
В качестве альтернативы, если вы планируете подключаться к своим сеансам с помощью login оболочек, вы также можете добавить переменные окружения непосредственно в файл .bash_profile .
$ export TZ="America/New_York" $ source ~/.bash_profile
Использование etc/environment
Если вам нужно применить определенные переменные окружения для всех, то определить общесистемные переменные окружения. Чтобы установить общесистемные переменные окружения в Linux, вам нужно экспортировать переменные в файл /etc/environment .
Например, чтобы изменить редактор, используемый глобально, вы можете изменить переменную EDITOR в файле окружения.
$ export EDITOR="vi"
Теперь попробуйте войти в систему как под разными пользователями в вашей системе, и вы увидите, что переменная EDITOR установлена для всех на сервере.
Установить переменные окружения в одной строкой
Теперь, когда вы знаете все подробности о том, как устанавливать переменные окружения, вы можете использовать эти шорткаты для их легкой установки.
echo "export VAR="value"" >> ~/.bashrc && source ~/.bashrc
echo "export VAR="value"" >> ~/.bash_profile && source ~/.bash_profile
echo "export VAR="value"" >> /etc/environment && source /etc/environment
Сбросить переменные окружения в Linux
Теперь, когда вы установили много переменных окружения в своей системе, вы можете отменить некоторые из них, если вы больше не используете их. В Linux существует два способа сброса переменных окружения: с помощью команды unset или путем удаления записей переменных в ваших системных файлах.
Использование команды unset
Чтобы удалить переменную окружения, используйте команду unset со следующим синтаксисом:
unset
Выглядит это так:
unset USERNAME printenv USERNAME
Использование команды set -n
Кроме того, вы можете сбросить переменные окружения, используя команду set с флагом -n -n.
set -n USERNAME printenv USERNAME
Установить переменную окружения PATH в Linux
В системах Linux очень часто задают переменную окружения PATH , чтобы система могла находить команды.
Чтобы отобразить текущую переменную окружения PATH , выполните команду printenv :
printenv PATH /usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
Чтобы установить переменную окружения PATH, добавьте строку export в файл .bashrc и используйте с ним команду source :
echo "export PATH " >> ~/.bashrc && source ~/.bashrc printenv PATH :/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
Успех! Вы успешно обновили переменную окружения PATH в Linux.
Заключение
В сегодняшнем руководстве вы узнали, что переменные окружения в Linux можно задавать несколькими способами: с помощью команды export , а также путем изменения некоторых системных файлов, чтобы сделать их постоянными.
Вы также узнали, что можно сбросить переменные окружения и как легко обновить переменную окружения PATH .
Переменные окружения в Linux
Переменные окружения в Linux — это специальные переменные, определенные оболочкой и используемые программами во время выполнения. Они могут определяться системой и пользователем. Системные переменные окружения Linux определяются системой и используются программами системного уровня.
Например, команда PWD использует системную переменную, чтобы сохранять прежнюю рабочую директорию. Пользовательские переменные окружения устанавливаются пользователем, для текущей оболочки, временно или постоянно. Вся концепция добавления и удаления переменных оболочки крутится вокруг нескольких файлов, команд и различных оболочек.
Table of Contents
- Виды переменных окружения
- 1. Локальные переменные окружения
- 2. Пользовательские переменные оболочки
- 3. Системные переменные окружения
- .bashrc
- .bash_profile
- /etc/environment
- /etc/bash.bashrc
- /etc/profile
- 1. Использование env
- 2. Использование unset
- 3. Установить значение переменной в »
- 1. Устанавливаем и удаляем локальные переменные в Linux
Виды переменных окружения
Если смотреть более широко, переменная окружения может быть трех типов:
1. Локальные переменные окружения
Эти переменные определены только для текущей сессии. Они будут безвозвратно стерты после завершения сессии, будь то удаленный доступ или эмулятор терминала. Они не хранятся ни в каких файлах, а создаются и удаляются с помощью специальных команд.
2. Пользовательские переменные оболочки
Эти переменные оболочки в Linux определяются для конкретного пользователя и загружаются каждый раз когда он входит в систему при помощи локального терминала, или же подключается удаленно. Такие переменные, как правило, хранятся в файлах конфигурации: .bashrc, .bash_profile, .bash_login, .profile или в других файлах, размещенных в директории пользователя.
3. Системные переменные окружения
Эти переменные доступны во всей системе, для всех пользователей. Они загружаются при старте системы из системных файлов конфигурации: /etc/environment, /etc/profile, /etc/profile.d/ /etc/bash.bashrc.
Конфигурационные файлы переменных окружения Linux
Здесь мы кратко рассмотрим различные конфигурационные файлы, перечисленные выше, которые используются для настройки переменных окружения для всей системы или конкретного пользователя.
.bashrc
Это файл переменных конкретного пользователя. Загружается каждый раз, когда пользователь создает терминальный сеанс, то есть проще говоря, открывает новый терминал. Все переменные окружения, созданные в этом файле вступают в силу каждый раз когда началась новая терминальная сессия.
.bash_profile
Эти переменные вступают в силу каждый раз когда пользователь подключается удаленно по SSH. Если этот файл отсутствует система будет искать .bash_login или .profile.
/etc/environment
Этот файл для создания, редактирования и удаления каких-либо переменных окружения на системном уровне. Переменные окружения, созданные в этом файле доступны для всей системы, для каждого пользователя и даже при удаленном подключении.
/etc/bash.bashrc
Системный bashrc. Этот файл выполняется для каждого пользователя, каждый раз когда он создает новую терминальную сессию. Это работает только для локальных пользователей, при подключении через интернет, такие переменные не будут видны.
/etc/profile
Системный файл profile. Все переменные из этого файла, доступны любому пользователю в системе, только если он вошел удаленно. Но они не будут доступны, при создании локальной терминальной сессии, то есть если вы просто откроете терминал.
Все переменные окружения Linux созданные с помощью этих файлов, могут быть удалены всего лишь удалением их оттуда. Только после каждого изменения, нужно либо выйти и зайти в систему, либо выполнить эту команду:
Добавление пользовательских и системных переменных окружения в Linux
Теперь, когда вы знаете немного теории, перейдем к практике. Локальные переменные окружения в Linux можно создавать следующими командами:
var=значение
export var=значениеЭти переменные будут доступны только для текущей терминальной сессии.
Для удаления переменных окружения можно использовать несколько команд:
1. Использование env
По умолчанию с помощью env можно посмотреть все установленные переменные среды. Но с опцией -i она позволяет временно удалить все переменные оболочки и выполнить команду без переменных.
$ env -i [переменная=значение] команда
Var — это любая переменная, которую вы хотите передать этой команде.
Такая команда запустит оболочку вообще без переменных окружения:
После запуска такого окружения, не будет доступно никаких переменных, но после выхода все вернется на свои места.
2. Использование unset
Это другой способ удаления переменных окружения Linux. Unset удаляет переменную по имени до конца текущей сессии:
3. Установить значение переменной в »
Это самый простой способ удаления переменных окружения в Linux, устанавливая пустое значение переменной, вы удаляете ее до конца текущей сессии.
Замечание: С помощью таких способов вы можете изменять значения системных или пользовательских переменных, но они будут актуальны только для текущего сеанса.
Создание пользовательских и системных переменных окружения
В этом разделе рассмотрим как установить и удалить системные и пользовательские переменные не только для текущего сеанса, а так чтобы эффект сохранялся после перезагрузки.
1. Устанавливаем и удаляем локальные переменные в Linux
Давайте создадим локальную переменную VAR и установим ей любое значение, затем удалим ее с помощью unset и убедимся что она удалена:
VAR1=’Losst’
echo $VAR1
unset VAR1
echo $VAR1
Другой способ создать переменную — команда export. Удалим ее присвоив пустое значение:
export VAR=’Losst’
echo $VAR
VAR=
echo $VAR
Теперь создадим переменную VAR2 также зададим ей значение. А потом временно удалим все локальные переменные выполнив env -i. Она запустит оболочку без каких-либо переменных. После ввода exit все переменные будут восстановлены.
VAR2=’Losst’
echo $VAR2
env -i bash
echo $VAR2
Установка и удаление пользовательских переменных
Отредактируйте файл .bashrc, в вашей домашней директории, добавив команду export, для экспортирования нужной переменной. Затем выполните команду source для применения изменений. Создадим, например, переменную CD:
Добавьте такую строчку (o, затем вставить, затем Esc и :wq):
export CD=’This is Losst Home’
Теперь осталось обновить конфигурацию:
source .bashrc
echo $CD
Для удаления этой переменной просто удалите ее из .bashrc.
Теперь добавим переменную окружения с помощью .bash_profile. Эта переменная, как вы уже знаете будет доступна только при удаленном входе:
export VAR2=’This is Losst Home’
И выполните эти команды, чтобы применить изменения и проверить добавление переменной:
source .bash_profile
echo $VAR2Переменная недоступна, так как вы создали локальную терминальную сессию, теперь подключитесь по ssh:
ssh user@localhost
echo $VAR2
Удалить эту переменную окружения можно так же как и в предыдущем случае, удалив ее из файла.
Замечание: Эти переменные доступны всегда, но не для всех пользователей.
Установка и удаление системных переменных окружения
Создадим переменную, доступную для всех пользователей, во всех терминальных сессиях, кроме удаленных, добавлением ее в /etc/bash.profile:
vi /etc/bash.profile
export VAR=’This is system-wide variable’Теперь эта переменная доступна для всех пользователей, во всех терминалах:
echo $VAR
sudo su
echo $VAR
su —
echo $VAR
Если вы хотите сделать переменную окружения доступной для всех пользователей, которые подключаются к этой машине удаленно, отредактируйте файл /etc/profile:
export VAR1=’This is system-wide variable for only remote sessions’
Обновите конфигурацию, и проверьте доступность переменной, она будет доступна только удаленно:
source /etc/profile
echo $VAR1Если нужно добавить переменную окружения в Linux, так чтобы она была доступна и удаленно, и для локальных сессий, экспортируйте ее в /etc/environment:
export VAR12=’I am available everywhere’
source /etc/environment
echo $VAR12
sudo su
echo $VAR12
exit
ssh localhost
echo $VAR12
Как видите, переменная доступна и для локальных пользователей и удаленно.
Выводы
С помощью этих нескольких способов мы можем изменить переменные окружения. Если вы знаете другие интересные способы это сделать, поделитесь в комментариях!
Похожие записи
Оцените статью
(24 оценок, среднее: 3,96 из 5)
Об авторе
Основатель и администратор сайта losst.ru, увлекаюсь открытым программным обеспечением и операционной системой Linux. В качестве основной ОС сейчас использую Ubuntu. Кроме Linux, интересуюсь всем, что связано с информационными технологиями и современной наукой.
12 комментариев к “Переменные окружения в Linux”
/etc/profile
«Все переменные из этого файла, доступны любому пользователю в системе, только если он вошел удаленно. »
А что значит вошел удаленно? Через SSH? ОтветитьНаписанное справедливо для всех современных дистрибутивов? Ответить
Здравствуйте! Скажите можно ли запускать видео на 2-м мониторе добавив переменную в ./bashrc к примеру:
env DISPLAY=0:1 totem (ну или другой проигрыватель)?
или лучше использовать:
export DISPLAY=0:1 totem ОтветитьДумаю: лучше env -i DISPLAY=0:1 totem в ~/.xinputrc, только вот с totem’ом могут быть те ещё грабли — тут уже не подскажу. а вот если там же, в ~/.xinputrc, будет export DISPLAY=0:1, то это подействует и на X-сервер. Ну, и ваше export DISPLAY=0:1 totem — это уже ошибка, тогда уж в две строки:
export DISPLAY=0:1
totem
Но, totem будет запускаться вместе с x-сервером. может проще создать alias с env в ~/.bashrc? А может в totem есть ещё какие опции, как, например, в mplayer -display? Ответить«. добавлением ее в /etc/bash.profile
.
Затем обновляем:
source /etc/bash.bashrc»
я думал обновлять надо отредактированный файл, или это опечатка? ОтветитьПозволю себе добавить к вышесказанному:
VAR=1 # переменная видна только для ТЕКУЩЕГО процесса
$VAR
>> 1: команда не найдена
set | grep VAR # set без параметров отобразит ВСЕ (как локальные так и глобальные) переменные
>> VAR=1
env | grep VAR
>>
bash # запустим дочерний процесс
$VAR # наша переменная в нем не видна
>>
exit # выходим
$VAR # переменная сохранилась в родительском процессе
>> 1: команда не найдена
VAR=2 bash # установим переменную для дочернего процесса
$VAR # она видна в дочернем процессе
>> 2: команда не найдена
set | grep VAR # так же видна в set
>> VAR=2
exit # закрываем дочерний процесс
$VAR # в родительском процессе хранится свой экземпляр переменной
>> 1: команда не найдена
unset VAR
$VAR
>> # значение переменной сброшено export VAR=3 # переменная видна в ТЕКУЩЕМ и ДОЧЕРНИХ процессах
$VAR
>> 3: команда не найдена
set | grep VAR
>> VAR=3
env | grep VAR
>> VAR=3
printenv | grep VAR
>> VAR=3
bash # запускаем дочерний процесс
env | grep VAR
$VAR # переменная доступна
>> 3: команда не найдена
VAR=2 # можем изменить ее значение
$VAR
>> 2: команда не найдена
unset VAR # сбросим значение
$VAR
>> # переменная не определена
exit
$VAR
>> 3: команда не найдена # родительский процесс хранит значение переменной после сброса в дочернем
env | grep VAR
>> VAR=3 Ответить«Системный файл profile. Все переменные из этого файла, доступны любому пользователю в системе, только если он вошел удаленно. Но они не будут доступны, при создании локальной терминальной сессии, то есть если вы просто откроете терминал.» – неверно. Переменная будет доступна везде: в терминале, GUI программах, не важно. Только что проверял локально. Ответить
Пытался разобраться в этом вопросе, и мне кажется что вы не совсем правы.Во первых есть нюансы выполнения данного скрипта поэтому результат может несколько отличаться для Ubuntu Debian Arch & Centos. Столкнулся с обсуждением данного вопроса здесь https://devacademy.ru/article/razbiraiemsia-s-failami-etc-profile-i-etc-bashrc
и здесь англ. https://bencane.com/2013/09/16/understanding-a-little-more-about-etcprofile-and-etcbashrc/
процитирую:
«В Linux имеется два типа стартовых оболочек (login shells) — Интерактивные оболочки и Неинтерактивные оболочки. Интерактивная оболочка используется, когда пользователь может взаимодействовать с оболочкой, т.е., например, типичное приглашение командной строки bash. Неинтерактивная оболочка используется, когда пользователь не может взаимодействовать с оболочкой, т.е. выполнение bash-сценариев.
Разница проста: файл /etc/profile выполняется только для интерактивных оболочек, а файл /etc/bashrc – как для интерактивных, так и для неинтерактивных. Как правило, если вы вводите свой пароль в текстовом режиме (например, на текстовой консоли или удаленно с помощью ssh), то shell вы получаете логин shell. Однако, если вы вводите свой пароль в графической программе и входите в графическую среду, это обходит обычный логин shell. Чтение .profile в этом случае зависит от того, как настроен графический сеанс; например, он варьируется между распределениями Linux, между дисплейными менеджерами и между окружениями рабочего стола. Иногда одна из программ в цепочке явно вызывает логин shell; иногда одна из program явно читает ~/.профиль; а иногда ничего этого не происходит и ~/.профиль не читается. »
Поэтому поведение еще зависит и от системы. Для моего Debian все происходит так, вошел в систему через графическую оболочку, запустил Терминал переменных окружения нет, в этой же консоли залогинился заново под этим же пользователем ( i mean su — UserName) или под другим но с вводом пароля переменные окружения считываются, т.е. Если в консоли пароль вводился, файлы в /etc/profile.d/ отработались(принудительный логин,ssh, все что требует ввода пароля в консоли), если не вводился то этих переменных окружения не будет.
Но здесь есть особенности настройки именно в вашей ОС, они могут немного отличаться ОтветитьУровень маскировки — seriyyy95@seriyyy95-pc �� Ответить
Олег ФеликсовичНужна консультация «чайнику».
Centos.
Stunnel 5.59 Compiled/running with OpenSSL 1.1.1d 10 Sep 2019. (стартует под root)
Хотя root работает OpenSSL 1.0.2k , а под пользователем OpenSSL 1.1.1d
Apache 2.4.6
После обновления Apache до версии 2.4.48 или 2.4.49 Stunnel работает до перезагрузки.
После перезапуск Stunnel «ругается»: /usr/local/bin/stunnel: relocation error: usr/local/bin/stunnel: symbol MD4_Update, version OPENSSL_1_1_0 not defined in file libcrypto.so.1.1 with link time reference
по аналогии с Windows искал решения в переменных окружения (что-то наверное «сбилось»), но так и не нашел вариантов.
E-mail: of@tut.by ОтветитьFiveFiveFive
Привет всем. А какая переменная отвечает за заголовок терминала? например PS1 отвечает за первое приглашение, а вот про заголовок окна терминала, что-то я не нашёл? или какими командами можно изменить этот самый заголовок? всем удачи. Ответить