Что такое переменные окружения
Перейти к содержимому

Что такое переменные окружения

  • автор:

Переменные окружения в Node.js: полное руководство

В этой статье мы рассмотрим переменные окружения (environment variables). По сути, это пары ключ-значение набора данных, которые хранятся на уровне операционной системы.

В этой статье мы узнаем о переменных окружения в Node.js с примерами. Содержание:

  • Что такое переменные окружения
  • Почему переменные окружения важны
  • Необходимые условия для проекта
  • Установка Node.js и настройка нового проекта
  • Инициализация первой переменной окружения в Node.js
  • Переменные окружения при вызове API / асинхронные задачи
  • Переменные окружения в операциях с базой данных / асинхронные задачи
  • Расширенные возможности работы с переменными окружения в Node.js: кодирование, валидация и преобразование типов
  • Управление секретами и лучшие практики безопасности с примерами
  • Подводные камни и как их избежать

Переменные окружения

Переменные окружения — это набор данных в виде пар ключ-значение, доступных на уровне операционной системы. Этот набор данных доступен во всех основных оболочках командной строки операционных систем Windows, Mac и Linux.

Почему переменные окружения важны?

  • Разделение проблем
  • Безопасность
  • Переносимость
  • Масштабируемость
  • Совместимость
  • Интероперабельность

Необходимые условия для этого проекта

Предполагается, что у вас есть:

  1. Базовые знания Node.js
  2. Базовые знания JavaScript
  3. Некоторые знания о разработке бэкенда

Установка Node и настройка проекта

Установить Node.js на машину можно разными способами. Для начала нужно зайти на официальный сайт Node и скачать оттуда нужную версию.

Давайте рассмотрим установку Node.js в операционной системе Linux, предпочтительно Ubuntu

Шаг 1. Откройте терминал

Шаг 2. Используйте скрипт curl или wget для установки nvm, используя git-репозиторий nvm. Запустите скрипт для установки nvm

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash # OR wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

Шаг 3. Закройте и снова откройте терминал и выполните следующие действия, чтобы применить скрипт

export NVM_DIR="$HOME/.nvm" [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

Шаг 4. Подтверждение установки

Убедиться, что NVM установлен в вашей системе, можно с помощью следующей команды:

nvm --version

*Шаг 5. * Установка Node

Введите следующую команду для установки последней версии node:

nvm install latest
nvm install --lts

Шаг 6. Установка версии по умолчанию

Чтобы установить версию Node, которая будет использоваться в вашей системе по умолчанию, используйте команду:

nvm alias default 20.8.0

Шаг 7. Проверка установки

Чтобы проверить, установлен ли Node, введите команду:

node -v # сообщает текущую версию node в вашей системе. В нашем случае это 20.8.0

Инициализация проекта

Теперь, когда мы установили Node, давайте создадим новый проект, в котором мы будем использовать переменную окружения.

Создайте новую директорию, назовите ее env-demo и перейдите в нее:

mkdir env-demo cd env-demo

Теперь введите команду для инициализации нового проекта и заполните поля по своему усмотрению.

npm init
package name: (env-demo) version: (1.0.0) description: entry point: (index.js) test command: git repository: keywords: author: license: (ISC) 

В итоге будет создан файл package.json, который будет выглядеть примерно так:

< "name": "env-demo", "version": "1.0.0", "description": "", "main": "index.js", "scripts": < "test": "echo \"Error: no test specified\" && exit 1" >, "author": "", "license": "ISC" >

Инициализация первой переменной окружения

Шаг 1: Установите пакет dotenv

Сейчас у вас инициализирован проект в приведенном выше разделе и создан файл package.json . Чтобы установить пакет node dotenv, который используется для создания env-файлов, введите в терминале команду:

npm install dotenv --save

Пакет dotenv будет установлен и сохранен как зависимость в файле package.json. Это должно выглядеть примерно так:

< "name": "env-demo", "version": "1.0.0", "description": "", "main": "index.js", "scripts": < "test": "echo \"Error: no test specified\" && exit 1" >, "author": "", "license": "ISC", "dependencies": < "dotenv": "^16.3.1" >>
Шаг 2 Создание файла .env
  • В корневой папке создайте новый файл и назовите его .env .
  • Откройте его в текстовом редакторе и создайте несколько пар ключ-значение. Это ваши переменные окружения. Вот пример
DATABASE_URL=sample-database-url PORT=3000 SECRET_KEY=mysecretkey
Шаг 3. Загрузка и чтение переменных окружения

В корневой папке создайте файл index.js, затем откройте терминал и введите следующую команду для установки Express.js:

npm install express --save

Express будет установлен и сохранен в качестве зависимости в файле package.json . Файл package.json будет выглядеть следующим образом:

< "name": "env-demo", "version": "1.0.0", "description": "", "main": "index.js", "scripts": < "test": "echo \"Error: no test specified\" && exit 1" >, "author": "", "license": "ISC", "dependencies": < "dotenv": "^16.3.1", "express": "^4.18.2" >>

и структура вашего проекта выглядит следующим образом:

Теперь откройте файл index.js и введите следующую команду, чтобы запустить простой веб-сервер.

const express = require('express'); const app = express(); const port = 4000; // defaults to 4000 app.get('/', (req, res) => < res.send('Hello World!') >) app.listen(port, () => < console.log(`Server running on http://localhost:$/`); >);

запустите код с помощью

node index.js

и перейдите на localhost://4000, чтобы получить hello world

Image description

Загрузка и чтение файла .env

Теперь, когда сервер запущен, давайте прочитаем файл .env , который мы создали в предыдущем шаге, и загрузим данные о порте из файла .env .

Откроем файл index.js и «потребуем» там библиотеку dotenv :

require('dotenv').config()

Теперь вы можете получить доступ к файлу .env с помощью process.env . Давайте воспользуемся process.env для доступа к номеру порта в файле index.js :

const express = require('express'); require('dotenv').config() const app = express(); const port = process.env.PORT || 4000; // Read from .env if not available then defaults to 4000 app.get('/', (req, res) => < res.send('Hello World!') >) app.listen(port, () => < console.log(`Server running on http://localhost:$/`); >);

Теперь давайте перезапустим сервер и перейдем на localhost://3000 . Вместо того, чтобы работать на 4000, наш сервер теперь работает на порту 3000, который он взял из файла .env

Вы также можете увидеть это в консоли:

Итак, вы успешно создали и сохранили файл env на своей машине.

В качестве другого примера вы можете получить доступ к DATABASE_URL следующим образом:

const dbUrl = process.env.DATABASE_URL; // Use dbUrl to connect to your database
index.js
const express = require('express'); require('dotenv').config() const app = express(); const port = process.env.PORT || 4000; // Read from .env if not available then defaults to 4000 app.get('/', (req, res) => < res.send('Hello World!') >) app.listen(port, () => < console.log(`Server running on http://localhost:$/`); >); 
package.json
< "name": "env-demo", "version": "1.0.0", "description": "", "main": "index.js", "scripts": < "test": "echo \"Error: no test specified\" && exit 1" >, "author": "", "license": "ISC", "dependencies": < "dotenv": "^16.3.1", "express": "^4.18.2" >>
.env
DATABASE_URL=sample-database-url PORT=3000 SECRET_KEY=mysecretkey

Как использовать переменные окружения в асинхронных задачах

В этом разделе мы поговорим о том, как переменные окружения можно использовать в асинхронных задачах, таких как вызов API или операции с базой данных.

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

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

Шаг 1. Настройка переменных окружения

Откройте файл .env и отредактируйте его следующим образом:

API_URL=https://jsonplaceholder.typicode.com/todos/1 API_KEY=sfjks4325 PORT=3000
Шаг 2. Использование async / await с переменными окружения

Далее установите библиотеку axios, чтобы выполнять вызовы на удаленный сервер:

npm install axios --save

Эта команда установит axios и сохранит ее как зависимость в файле package.json.

Файл package.json должен выглядеть примерно так:

< "name": "env-demo", "version": "1.0.0", "description": "", "main": "index.js", "scripts": < "test": "echo \"Error: no test specified\" && exit 1" >, "author": "", "license": "ISC", "dependencies": < "axios": "^1.5.1", "dotenv": "^16.3.1", "express": "^4.18.2" >>

Далее используйте axios для выполнения вызовов сайта jsonplaceholder и записи их в консоль.

Введите этот код в файл index.js

const express = require('express'); require('dotenv').config(); const axios = require('axios'); const app = express(); const port = process.env.PORT || 4000; // Read from .env if not available then defaults to 4000 const fetchData = async () => < const url = process.env.API_URL; const apiKey = process.env.API_KEY; try < const response = await axios.get(url, < headers: < 'Authorization': `Bearer $` > >); console.log(response.data); > catch (error) < console.error(`Error fetching data: $`); > >; app.get('/', (req, res) => < fetchData() res.send('Hello World!') >) app.listen(port, () => < console.log(`Server running on http://localhost:$/`); >); 
Что мы здесь делаем:
  1. Импортируем модули express , dotenv , axios .
  2. Затем инициализируем приложение и порт с помощью переменных окружения.
  3. Затем создаем асинхронную функцию const fetchData = async ()=> (. )
  4. В этой функции мы используем url и apiKey из файла .env . Хотя я должен отметить, что вам не нужен apiKey для вызова сайта jsonplaceholder. Я просто поместил этот ключ для демонстрации.
  5. Записываем данные в консоль.
  6. Вызываем метод fetchData() на маршруте get. Таким образом, каждый раз, когда кто-то переходит на / , вызывается метод и данные записываются в консоль.

Использование Async/await с переменными окружения в операциях с базой данных

Давайте рассмотрим еще один пример. На этот раз мы будем выполнять операции с базой данных с помощью переменных окружения.

Шаг 1: Настройка переменных окружения.

Откройте файл .env в текстовом редакторе и введите следующее:

DB_HOST=localhost DB_PORT=5432 DB_NAME=mydatabase DB_USER=username DB_PASSWORD=password

Шаг 2: Установите библиотеку pg

Следующим шагом будет установка библиотеки pg :

npm install pg --save

*Шаг 3: * Подключитесь к базе данных и выполните асинхронный запрос с помощью файла .env

Напишите следующий код, чтобы подключиться к базе данных и использовать учетные данные .env, которые мы только что создали:

const < Pool >= require('pg'); require('dotenv').config(); const pool = new Pool(< host: process.env.DB_HOST, port: process.env.DB_PORT, database: process.env.DB_NAME, user: process.env.DB_USER, password: process.env.DB_PASSWORD >); const fetchUsers = async () => < try < const res = await pool.query('SELECT * FROM users'); console.log(res.rows); >catch (err) < console.error(`Error fetching users: $`); > >; fetchUsers(); 

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

Расширенные возможности работы с переменными окружения в Node JS: кодирование, валидация и преобразование типов

Переменные окружения — это не только чтение и хранение. С помощью расширенных манипуляций с переменными окружения мы узнаем о:

  • кодировании
  • валидации и
  • преобразовании типов
1. Кодирование

Кодирование используется для различных целей в переменных окружения, в том числе для обеспечения безопасности. Наиболее популярный тип кодировки — base64.

Кодирование:

const decodedData = Buffer.from(encodedData, 'base64').toString('utf-8'); console.log(`Decoded: $`);
2. Валидация

Валидация используется для проверки того, является ли код правильным или нет. Например, url, который вы собираетесь использовать — является ли он корректным или нет и т.д.

Или, как в этом примере, мы проверяем, находится ли номер порта в указанном диапазоне или нет.

const validatePort = (port) => < const parsedPort = parseInt(port, 10); if (isNaN(parsedPort) || parsedPort < 1024 || parsedPort >65535) < throw new Error('Invalid port number'); >return parsedPort; >; const port = validatePort(process.env.PORT);
3. Преобразование типа

Переменные окружения всегда имеют тип string. Но часто возникает необходимость использовать и другие типы данных, например int или booleans. Здесь поможет преобразование типов.

Пример целого числа:

const isProduction = process.env.NODE_ENV === 'production'; const retries = parseInt(process.env.RETRIES, 10) || 3;

Пример булевого значения

const shouldLog = process.env.SHOULD_LOG === 'true';

Комбинированный пример

Вот пример, объединяющий все расширенные манипуляции с env, доступные в переменных окружения.

// Encoding and decoding const apiKey = Buffer.from(process.env.API_KEY || '', 'base64').toString('utf-8'); // Validation if (apiKey.length !== 32) < throw new Error('Invalid API key length'); >// Type conversion const maxUsers = parseInt(process.env.MAX_USERS, 10); if (isNaN(maxUsers))

Управление секретами и лучшие практики безопасности с примерами

В этом разделе мы узнаем об управлении секретами и лучших практиках безопасности с примерами. Вот шаги, которые вы можете предпринять для защиты переменной окружения, а также их примеры.

1. Никогда не делайте коммит файлов .env

Всегда следите за тем, чтобы файлы .env находились в gitignore и никогда не коммитились в git-репозиторий.

# Ignore dotenv environment variables file .env
2. Хеширование пароля

Всегда хэшируйте пароли, хранение паролей в виде обычного текста — плохая практика. Для хэширования паролей можно использовать, например, библиотеку bcryt.

const bcrypt = require('bcrypt'); const saltRounds = 10; async function hashPassword(plainPassword)
3. Кодирование переменных окружения

В качестве меры безопасности всегда кодируйте секреты, обычно они имеют кодировку base-64.

const buffer = Buffer.from(process.env.MY_SECRET, 'base64'); const decodedSecret = buffer.toString('utf-8');
4. Централизованное управление секретами

Для крупных проектов можно рассмотреть сервисы централизованного управления секретами — например, hashicorp vault, AWS secrets manager.

Они предлагают такие расширенные функции, как ротация секретов, автоматическая аренда и ротация, а также ведение журнала аудита.

Вот пример с node vault:

const vault = require("node-vault")(< endpoint: "https://vault-endpoint", token: process.env.VAULT_TOKEN, >); async function getDatabaseCreds() < const data = await vault.read("path/to/secret"); return < user: data.data.username, password: data.data.password, >; >
5. Принцип наименьших привилегий

Всегда следуйте принципу наименьших привилегий. API, которые не требуют идентификационных данных на запись, никогда не должны получать привилегии на запись.

Подводные камни

  1. Хардкодинг служебной информации
  2. Отсутствие валидации
  3. Игнорирование окружения
  4. Неадекватная безопасность
  5. Плохая документация
  6. Возврат в предыдущее значение (Fallback) по умолчанию

Нужен Chat API для вашего сайта или приложения

Поставщиком Chat API является DeadSimpleChat

  • Добавьте масштабируемый чат в приложение за считанные минуты
  • Одновременно 10 миллионов пользователей
  • Uptime 99,999%
  • Фичи модерации
  • Чат 1-1
  • Групповой чат
  • Полностью настраиваемый
  • Чат API и SDK
  • Предварительно созданный чат

Заключение

В этой статье мы узнали о переменных окружения и о том, как их использовать в Node.js.

Мы рассмотрели важные темы, связанные с управлением переменными окружения в Node.js. Этого должно быть достаточно для большинства случаев использования переменных окружения в приложениях Node.js.

Надеюсь, вам понравилась статья, и спасибо за чтение.

Всех разработчиков на JavaScript приглашаем на открытое занятие в OTUS «Построение графических приложений с применением библиотеки Konva.js». Записаться на урок можно на странице курса.

  • node.js
  • javascript
  • переменные окружения
  • Konva.js
  • Блог компании OTUS
  • JavaScript
  • Node.JS

Переменная окружения PATH

Довольно часто на наших курсах нам приходится работать с различными переменными окружения. Особый интерес у учеников вызывает переменная окружения PATH. В этой мини-статье решили рассказать о том, что это за переменная и зачем нужна нашей операционной системе.

Что такое переменная окружения

Для начала давайте определимся с тем, что вообще такое переменная окружения.

Переменная окружения — это то же самое, что и переменная в любом языке программирования. Для тех, кто никогда не писал код, проще всего объяснить это следующим образом. Это некая сущность, у которой есть имя и значение.

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

Нужны такие переменные как раз для этого — чтобы программы могли к ним обращаться и получать требующуюся им для работы информацию.

Например, давайте представим, что мы пишем программу, которая в ходе своей работы должна взаимодействовать с Java. На каждом компьютере она может находиться в разных местах. У меня в одной директории, у другого человека — в другой. Как нам написать программу, которая работала бы у всех?

Очень просто, мы пишем требование к нашей программе — в системе, где вы будете ее запускать, обязательно должна быть выставлена переменная окружения JAVA_HOME, содержащая путь до Java. Читая значение этой переменной наша программа будет понимать, где искать движок на том компьютере, на котором ее запустили.

Переменная окружения PATH

Переменная окружения PATH нужна прежде всего самой командной строке. Ее значение — это список директорий, в которых хранятся исполняемые файла. Директории перечислены через двоеточие. Например:

Тут две директории, перечисленные через двоеточие:

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

Переменная окружения PATH существует как в Linux, так и в MacOS и Windows и везде работает одинаково.

По дефолту в PATH лежат только основные директории, но мы можем добавлять туда и новые после установки каких-то новых программ.

Дальнейшие команды будут работать только в командной оболочке bash в операционных системах Linux (например, Ubuntu) и MacOS. Если у вас Windows, повторить их можно, установив специальное расширение cygwin по нашему видео — https://www.youtube.com/watch?v=2csABC85onI

Чтобы узнать, какие директории уже указаны в PATH, можно распечатать ее содержимое:

Если директорий много, в таком виде читать ее содержимое не очень удобно и мы предлагаем использовать следующую команду:

Так получится гораздо нагляднее.

Чтобы узнать, в какой директории лежит исполняемый файл той или иной команды, необходимо ввести команду which. Например, давайте посмотрим, где лежит исполняемый файл команды ls:

Как редактировать переменную окружения PATH?

Для ОС Windows версии 8 и 10:

В строке «Поиск» выполните поиск: Система (Панель управления)
Нажмите на ссылку “Дополнительные параметры системы”
Нажмите “Переменные среды”
В разделе “Переменные среды” выберите переменную среды PATH
Нажмите “Изменить”
Если переменной PATH не существует, нажмите “Создать”
В окне “Изменение системной переменной” (или “Новая системная переменная”) укажите значение переменной среды PATH
Нажмите “ОК”
Откройте заново окно командной строки (если она была открыта)

Для MacOS и Linux переменная окружения PATH обычно дополняется через системные файлы .bashrc и .bash_profile

Вот и все, что нужно знать о переменной окружения PATH, чтобы начать с ней работать.

Приходите на наш курс Bash — инструменты тестировщика, там мы рассказываем это и многое другое для того, чтобы наши ученики чувствовали себя уверенным пользователем Linux и MacOS и могли эффективно работать с любой командной оболочкой.

А если хочешь почувствовать себя настоящим профессионалом командной строки, покупай пакет курсов Консольные утилиты PRO с хорошей скидкой.

Учитесь новому каждый день! 🙂

Работа с переменными окружения в Python

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

В Python для работы с переменными окружения используется модуль os . Он предоставляет функциональность для взаимодействия с операционной системой, включая переменные окружения.

Установка переменных окружения

Для установки значения переменной окружения в Python используется метод os.environ . Это словарь, который содержит текущие переменные окружения. Для установки нового значения достаточно просто присвоить его ключу этого словаря.

import os os.environ["MY_VARIABLE"] = "my value"

Важно отметить, что все значения переменных окружения должны быть строками. Если попытаться присвоить другой тип данных, Python выдаст ошибку. Например, следующий код вызовет ошибку:

os.environ["MY_VARIABLE"] = 1 # Неверно!

Для того чтобы присвоить числовое значение, его нужно сначала преобразовать в строку:

os.environ["MY_VARIABLE"] = str(1) # Верно

Чтение переменных окружения

Для чтения значения переменной окружения также используется os.environ . Просто обратитесь к нужному ключу, как если бы это был обычный словарь:

value = os.environ["MY_VARIABLE"]

Если переменная окружения не существует, Python выдаст ошибку. Чтобы избежать этого, можно использовать метод get , который возвращает None , если переменная не найдена:

value = os.environ.get("MY_VARIABLE")

В этом случае, если переменная «MY_VARIABLE» не существует, value будет равно None .

Итак, с помощью модуля os в Python можно легко устанавливать и читать переменные окружения, что позволяет эффективно работать с глобальными настройками и передавать информацию между различными частями программы.

Переменные среды окружения

Любая программа, работающая в Linux, имеет так называемое окружение — специальную область памяти, в которой хранятся строки вида:

ИМЯ=ЗНАЧЕНИЕ

Эти строки называются переменные среды окружения.

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

У переменных есть имена. В имени можно использовать только английские буквы, символы – и _, цифры (но не в начале имени). Большие и маленькие буквы отличаются. Имена переменных среды окружения принято писать, используя большие буквы, но Вы можете не следовать этому правилу.

Переменные среды окружения — это еще один способ управления программами. Программы имеют доступ к переменным и могут использовать значения переменных в своей работе. Например, программам, работающим в графической оболочке в Linux, можно указать X сервер, с помощью которого они будут выводить свои данные. Это можно сделать двумя способами:

  • передать программе при запуске специальный параметр;
  • определить переменную среды окружения DISPLAY.

Во втором случае не требуется каждой программе при ее запуске передавать параметр. Все они будут использовать содержимое переменной DISPLAY и выводить данные с помощью X сервера, указанного в этой переменной.

То, какие переменные среды окружения использует программа зависит от ее автора.

Вы как пользователь системы можете определять, изменять и удалять переменные среды окружения.

Давайте рассмотрим пример работы с переменными. Что бы добавить новую переменную в окружение программы надо написать ее имя, затем без пробелов символ = и значение переменной.

$ CAR=запорожец $

Переменные среды окружения не имеют типа и считается, что они содержат строку. Если в строке встречаются пробелы, значение переменной берут в двойные кавычки.

$ CAR="запорожец - это машина?" $

Для того, что бы получить значение переменной, перед ее именем необходимо поставить символ $. Вместо $CAR, шелл подставит значение переменной CAR.

Используйте программу echo если вы хотите увидеть значение переменной. Echo выводит на стандартный вывод все, что вы передадите ей в командной строке. Например, что бы посмотреть содержимое переменной CAR следует выполнить следующую команду:

$ echo $CAR запорожец - это машина? $

Содержимое переменной было выведено на экран в следующей строке.

$ echo CAR CAR $

Предположим, что мы присвоили переменной CAR значение bmw. И запустили еще одну оболочку — sh.

$ CAR=bmw $ sh $

Внешний вид командной строки не изменится, но вы будете работать совсем в другой программе, имеющей свой собственный набор переменных среды окружения. И если теперь посмотреть содержимое переменной CAR на экран ничего выведено не будет, так как в окружении программы sh переменной CAR не существует.

$ echo $CAR $

В UNIX есть возможность заранее определить переменные, которые будут помещены в окружение программы при ее запуске. Ниже приведен пример того, что необходимо сделать, что бы переменная CAR была доступна программе sh.

$ CAR=bmw $ export CAR $ sh $ echo $CAR bmw $

Переменную нужно экспортировать при помощи оператора export. Только экспортированные переменные будут видны в программах-потомках. То есть во всех программах, которые будут запущены из программы, где переменная была определена. Эта переменная будет автоматически определяться только у программ потомков и только у них. На остальные программы, работающие в системе, операция экспорта не повлияет.

После входа пользователя в систему у пользователя существует большое количество заранее определенных переменных среды окружения. Их список можно посмотреть при помощи команды set. Некоторые из них определяются самой оболочкой, а некоторые определены в специальных конфигурационных файлах. Вы можете самостоятельно определять новые переменные или изменять старые.

Существует набор файлов, которые выполняются при входе пользователя в систему (обычно в Linux — это файлы, находящиеся в директории /etc/profile.d. Но могут применяться и другие файлы, это зависит от используемой программы оболочки.). Именно в этих файлах можно осуществить добавление или переопределение переменных среды окружения. Если говорить о конкретном пользователе, то используют файл ~/.bash_profile или ~/.profile (символ тильда обозначает домашнюю директорию текущего пользователя).

Для изменения содержимого переменной следует просто присвоить ей новое значение. Например, необходимо в переменную PATH добавить директорию ~/bin. Для этого можно отредактировать файл .bash_profile и добавить в него следующую строку:

export PATH=$PATH:~/bin

Для удаления переменной используется команда unset. Например:

$ unset CAR $ echo $CAR $

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *