Циклы bash

Циклы в скриптах

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

Первым рассмотрим цикл for. Вот его синтаксис:

for переменная in списокdoкомандаdone

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

Например, переберем пять цифр:

Или вы можете перечислить все файлы из текущей директории:

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

Второй цикл, который мы рассмотрим — это цикл while, он выполняется пока команда условия возвращает код 0, успех. Рассмотрим синтаксис:

while команда условиеdoкомандаdone

Рассмотрим пример:

Как видите, все выполняется, команда let просто выполняет указанную математическую операцию, в нашем случае увеличивает значение переменной на единицу.

Хотелось бы отметить еще кое-что. Такие конструкции, как while, for, if рассчитаны на запись в несколько строк, и если вы попытаетесь их записать в одну строку, то получите ошибку. Но тем не менее это возможно, для этого там, где должен быть перевод строки ставьте точку с запятой «;». Например, предыдущий цикл можно было выполнить в виде одной строки:

Все очень просто я пытался не усложнять статью дополнительными терминами и возможностями bash, только самое основное. В некоторых случаях, возможно, вам понадобиться сделать gui для bash скрипта, тогда вы можете использовать такие программы как zenity или kdialog, с помощью них очень удобно выводить сообщения пользователю и даже запрашивать у него информацию.

Основы скриптов

Скрипт или как его еще называют — сценарий, это последовательность команд, которые по очереди считывает и выполняет программа-интерпретатор, в нашем случае это программа командной строки — bash.

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

Простейший пример скрипта для командной оболочки Bash:

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

Или на PHP:

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

Этот флаг ничего не меняет в самом файле, только говорит системе, что это не просто текстовый файл, а программа и ее нужно выполнять, открыть файл, узнать интерпретатор и выполнить. Если интерпретатор не указан, будет по умолчанию использоваться интерпретатор пользователя. Но поскольку не все используют bash, нужно указывать это явно.

Чтобы сделать файл исполняемым в linux выполните:

Теперь выполняем нашу небольшую первую программу:

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

Как работают окружение и переменные окружения

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

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

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

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

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

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

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

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

Переменные в скриптах

Написание скриптов на Bash редко обходится без сохранения временных данных, а значит создания переменных. Без переменных не обходится ни один язык программирования и наш примитивный язык командной оболочки тоже.

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

Например, объявим переменную string:

Значение нашей строки в кавычках. Но на самом деле кавычки не всегда нужны. Здесь сохраняется главный принцип bash — пробел — это специальный символ, разделитель, поэтому если не использовать кавычки world уже будет считаться отдельной командой, по той же причине мы не ставим пробелов перед и после знака равно.

Чтобы вывести значение переменной используется символ $. Например:

Модифицируем наш скрипт:

И проверяем:

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

Проверяем:

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

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

Использование переменных

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

show_name.sh

ZSH

#!/bin/bash
my_name=»Oleg»
echo «My name is $my_name»

1
2
3

#!/bin/bash

my_name=»Oleg»

echo»My name is $my_name»

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

show_name.sh

ZSH

#!/bin/bash
my_name=»Oleg»
echo ‘My name is $my_name’

1
2
3

#!/bin/bash

my_name=»Oleg»

echo’My name is $my_name’

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

cmd_output.sh

ZSH

#!/bin/bash
folders_amount=`ls -l | grep ^d | wc -l`
echo «Folders: ${folders_amount}»
local_ip=$(hostname -i | grep -E -o «({1,3}){3}{1,3}»)
echo «IP address: ${local_ip}»

1
2
3
4
5

#!/bin/bash

folders_amount=`ls-l|grep^d|wc-l`

echo»Folders: ${folders_amount}»

local_ip=$(hostname-i|grep-E-o»({1,3}){3}{1,3}»)

echo»IP address: ${local_ip}»

Также переменным можно присвоить значение содержимого какого-либо файла:

#!/bin/bash
file_content=$(<somefile)
echo $file_content

1
2
3

#!/bin/bash

file_content=$(<somefile)

echo$file_content

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

Например, в данной ситуации мы хотим слить воедино значение переменной и следующее за ней слово — «rock».

var_merge.sh

ZSH

#!/bin/bash
prefix=»Hard»
echo «$prefixrock cafe.»

1
2
3

#!/bin/bash

prefix=»Hard»

echo»$prefixrock cafe.»

В результате мы получим только часть вывода т.к. интерпретатор будет пытаться найти переменную $prefixrock, которой у нас нет.

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

var_merge.sh

ZSH

#!/bin/bash
prefix=»Hard»
echo «${prefix}rock cafe.»

1
2
3

#!/bin/bash

prefix=»Hard»

echo»${prefix}rock cafe.»

Пример 1: объявить логическую переменную с использованием 0 или 1

В этом примере показан способ использования логических значений 0 и 1 в переменной bash. Создайте файл bash со следующим сценарием, который будет печатать сообщение на основе значения переменной, которая будет содержать 0 или 1. Два числовых значения будут приняты в качестве MCQ и описательных меток. Если значение переменной mcq больше и равно 60, а значение переменной des больше и равно 50, то значение переданной переменной будет установлено на 1; в противном случае этой переменной будет присвоено значение 0. Затем переданная переменная будет проверена, чтобы напечатать сообщение об успешном выполнении или сообщение об ошибке.

Выход:

Судя по выходным данным, указанный выше сценарий был выполнен два раза. 70 было присвоено как MCQ, а 65 было дано как описательное при первом выполнении. Оба значения возвращают истину для условного выражения, а 1 установлено для переданной переменной. 40 было дано как отметка MCQ, а 80 было дано как описательная отметка во втором исполнении. Из условного выражения для 40 было возвращено false, а для переданной переменной было установлено значение 0. «Вы сдали экзамен» печатается, когда значение переданной переменной равно 1, и » Вы не сдавали экзамен » печатается, когда значение переданной переменной равно 0.

Горячие клавиши Bash

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

Tab — автодополнение, наберите начало команды или пути и нажмите Tab, если такая команда только одна оболочка ее дополнит. Если доступно несколько вариантов, нажмите два раза Tab чтобы их увидеть;
Стрелка вверх — предыдущая команда в истории;
Стрелка вниз — следующая команда в истории;
Ctrl+R — поиск по истории. Просто нажмите эту кнопку и начните вводить нужную команду;
Ctrl+G — выйти из режима поиска;
Alt+. — предыдущее слово последней команды;
Ctrl+L — очистить вывод терминала;
Ctrl+A — перейти в начало строки;
Ctrl+E — в конец строки;
Ctrl+K — удалить символы начиная от курсора и к концу команды;
Ctrl+U — удалить символы от курсора до начала команды;
Ctrl+W — удалить все символы этого слова слева;
Ctrl+Y — удалить все символы этого слова справа;
Ctrl+S — остановить вывод на экран;
Ctrl+Q — возобновить вывод на экран.

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

Цитаты

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

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

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

Когда мы заключим наш контент в кавычки, мы указываем Bash, что содержимое должно рассматриваться как отдельный элемент. Вы можете использовать одинарные кавычки (‘) или двойные кавычки («).

Одиночные кавычки будут обрабатывать каждый символ буквально.
Двойные кавычки позволят вам выполнять подстановку (то есть включают переменные в пределах значения).

Параметры скриптов

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

Для того, чтобы получить значение первого параметра, необходимо в скрипте указать , второго — , и т.д. Существует также ряд других переменных, значения которых можно использовать в скрипте: – имя скрипта – количество переданных параметров – PID(идентификатор) процесса, выполняющего скрипт – код завершения предыдущей команды

Создадим файл script1.sh следующего содержания:

Выдадим права на выполнение и выполним скрипт с параметрами:

Мы передали 2 параметра, указывающие город и страну, и использовали их в скрипте, чтобы сформировать строку, выводимую командой printf. Также для вывода в строке Hello использовали имя пользователя из переменной USER.

Для того, чтобы передать значения параметров, состоящие из нескольких слов (содержащие пробелы), нужно заключить их в кавычки:

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

Из приведенных примеров видно, что при обращении к переменной для получения её значения используется символ $. Для того, чтобы сохранить значение переменной просто указывается её имя:

Так что я должен использовать?

Итак, теперь у нас есть 3 метода ввода данных от пользователя:

Аргументы командной строки
Чтение ввода во время выполнения скрипта
Принять данные, которые были перенаправлены в скрипт Bash через STDIN

Какой метод лучше всего зависит от ситуации.

Как правило, вы предпочитаете аргументы командной строки. Они наиболее удобны для пользователей, поскольку данные будут храниться в истории команд, чтобы они могли легко вернуться к нему. Это также лучший подход, если ваш скрипт может быть вызван другими скриптами или процессами (например, возможно, вы хотите, чтобы он периодически запускался с использованием CRON).

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

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

Иногда вы можете обнаружить, что комбинация идеальна. Пользователь может предоставить имя файла в качестве аргумента командной строки, а если нет, то скрипт обработает то, что он найдет в STDIN (когда мы посмотрим на операторы If, мы увидим, как это может быть достигнуто). Или, возможно, аргументы командной строки определяют определенное поведение, но чтение также используется для запроса дополнительной информации, если требуется.

Ультимативно вы должны думать о 3 факторах при принятии решения о том, как пользователи будут предоставлять данные вашему сценарию Bash:

Простота использования — какой из этих методов облегчит пользователям использование моего сценария?
Безопасность. Есть ли конфиденциальные данные, которые я должен обрабатывать надлежащим образом?
Надежность. Могу ли я сделать так, чтобы моя работа скриптов была интуитивно понятной и гибкой, а также усложнять ошибки?

Часть 2. Переменные в Bash

Часть 4. Сложение, вычитание, умножение, деление, модуль в Bash

Управляющие конструкции в скриптах

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

В Bash для проверки условий есть команда Синтаксис ее такой:

if команда_условие thenкомандаelse командаfi

Эта команда проверяет код завершения команды условия, и если 0 (успех) то выполняет команду или несколько команд после слова then, если код завершения 1 выполняется блок else, fi означает завершение блока команд.

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

]

Для сравнения используются уже привычные нам операторы <,>,=,!= и т д. Если выражение верно, команда вернет 0, если нет — 1. Вы можете немного протестировать ее поведение в терминале. Код возврата последней команды хранится в переменной $?:

Теперь объединением все это и получим скрипт с условным выражением:

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

Что такое Bash?

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

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

Автодополнение

Tab – автодополнение (в контексте)

Во многих командных интерпретаторах (и в bash в том числе) используется такая возможность, как автодополнение. Как минимум нужно знать, что по нажатию клавиши дописывается название команды. В bash по умолчанию обычно настроено так, что если имеется только один вариант дополнения, то он дописывается по нажатию (также можно использовать и ). Когда вариантов дополнения много, то по первому нажатию дописывается только общая часть (если она есть). А по второму нажатию отображается список всех доступных вариантов. Дальше можно набрать еще символов – уточнить, какое из дополнений нужно, и снова нажать . То же самое с другими дополнениями: имен файлов, имен переменных.

^^^ Здесь, например, смотрю (нажав дважды ), что есть несколько команд, начинающихся с «if», добавив «c» и нажав , получаю набранной команду «ifconfig».

^^^ В этом примере дополняю аргументы команды (здесь имена файлов). Также видно, что в случае, когда вариантов много и все не умещаются в окне терминала, их список отображается утилитой для постраничного просмотра (также при очень большом списке вариантов выдается запрос вида «Display all 125 possibilities? (y or n)» или, как в этом примере, при малом количестве — «—More—».

Дополнения имен пользователей, переменных

Часто, когда дописываются аргументы команд по , дописываются имена файлов. Но стоит также отметить, что, в зависимости от контекста, по дописываются и имена переменных (аргументы, начинающиеся с символа «$»), имена пользователей (аргументы, начинающиеся с символа «~»),…

^^^ Здесь, чтобы набрать «$HISTFILESIZE», вместо 13 символов набрал 8 символов ( ). Помимо того, что так быстрее, это еще и позволяет допускать меньше ошибок при наборе команд, так как не просто печатаю текст, а выбираю из списка установленных переменных.

^^^ Здесь дописываю имена пользователей (фактически пишу адрес домашней директории).

Также bash может дополнять не потому, что набранный текст начинается с определенного символа, а по определенным комбинациям клавиш.

Список того, что может дополнять bash, можно посмотреть командой:

Так, например, видно, что:

– покажет список имен пользователей, начинающихся с набранных символов, а дополнить комбинацией ;
– список имен машин (согласно /etc/hosts), начинающихся с набранных символов, а дополнить – ;
– список имен переменных, заданных в этой сессии (можно их также посмотреть командой set), а дополнить – ;
– список команд (согласно доступных: $PATH, alias, функций, встроенных команд), а дополнить – ;
– список имен файлов, а дополнить – .

Alt-* – вставить дополнения, Ctrl-x * – развернуть шаблон

(точнее, ) или, что, то же самое, (точнее, , , ), вставит все варианты дополнения в командную строку. Аналогично можно развернуть список файлов, переменных, имен пользователей.

В примерах ниже разворачиваю список файлов:

Вариант с :

– развернет уже написанный в командной строке шаблон, как в примере ниже:

Создание переменных среды сеанса

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

Формат определения переменной среды одинаков для обоих файлов. Чтобы добавить определение к вашему файл, введите это в вашем домашнем каталоге:

gedit .bashrc

Мы добавили переменную окружения , Обратите внимание на слово «экспорт» в начале строки

Сохраните и закройте файл после завершения редактирования. Вы можете выйти и снова войти, или вы можете заставить оболочку перечитать файл с помощью команды точка () нравится:

. .bashrc

Теперь давайте создадим переменную окружения в командной строке:

LOCAL_VAR="This session only"

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

echo $LOCAL_VAR

echo $INHERITED_VAR

Вы заметите определение переменная окружения имела слово «экспорт» в начале строки. Это означает, что переменная окружения будет наследоваться дочерними процессами текущей оболочки. Если мы запустим еще один, используя Команда, мы можем проверить две переменные из дочерней оболочки:

bash

echo $LOCAL_VAR

echo $INHERITED_VAR

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

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

echo $INHERITED_VAR

Закрыть нашего ребенка сеанс мы используем :

exit

Унаследованные среды также влияют на сценарии. Вот простой скрипт, который записывает значения наших трех переменных среды в окно терминала:

#!/bin/bash

echo "WEBSITE" $WEBSITE
echo "LOCAL_VAR" $LOCAL_VAR
echo "INHERITED_VAR" $INHERITED_VAR

Это было сохранено в файл с именем , а затем сделал исполняемым со следующим:

chmod +x envtest.sh

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

./envtest.sh

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

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

export LOCAL_VAR

./envtest.sh

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

Настройка переменных оболочки и окружения

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

Создание переменных оболочки

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

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

Теперь у нас есть переменная. Эта переменная доступна в нашем текущем сеансе, но она не будет передаваться дочерним процессам.

Мы можем увидеть это, выполнив с помощью команды grep поиск новой переменной в выводе :

Мы можем убедиться, что это не переменная окружения, попробовав выполнить то же самое действие для команды :

Вывод должен быть пустой.

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

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

Теперь у нас есть переменная оболочки. Она не должна передаваться каким-либо дочерним процессам. Мы можем развернуть новую оболочку bash, используя для этого текущую оболочку, чтобы продемонстрировать это:

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

Вернитесь к нашей оригинальной оболочке, введя :

Создание переменных окружения

Теперь давайте превратим нашу переменную оболочки в переменную окружения. Мы можем сделать это с помощью экспорта переменной. Команда для выполнения этой задачи имеет соответствующее название:

Наша переменная будет превращена в переменную окружения. Мы можем убедиться в этом, снова проверив наш список переменных окружения:

В этот раз наша переменная отображается в списке. Давайте повторим наш эксперимент с дочерней оболочкой:

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

Проверьте, что переменная успешно была экспортирована в окружение:

Теперь давайте вернемся в нашу оригинальную оболочку:

Давайте посмотрим, доступна ли наша новая переменная:

Ничего не возвращается.

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

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

Переменные среды Shell

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

BASHOPTS: Параметры командной строки, которые использовались при был запущен.
BASH_VERSION: номер версии в виде строки слов и цифр.
BASH_VERSINFO: версия в виде цифры.
КОЛОННЫ: Текущая ширина окна терминала.
DIRSTACK: Каталоги, которые были добавлен в стек каталогов посредством команда.
HISTFILESIZE: Максимальное количество линии разрешены в файл.
HISTSIZE: Количество строк разрешено в памяти.
HOSTNAME: Имя хоста компьютера.
IFS: Внутренний разделитель полей используется для разделения ввода в командной строке. По умолчанию это пробел.
PS1: Переменная окружения содержит определение основной, командной строки и командной строки. Набор токенов, называемых escape-последовательностями, может быть включен в определение вашей командной строки. Они представляют такие вещи, как имя хоста и пользователя, текущий рабочий каталог и время.
PS2: Когда команда занимает более одной строки и ожидается больше ввода, отображается дополнительная командная строка. Переменная окружения содержит определение этого вторичного приглашения, которое по умолчанию имеет знак больше, чем ().
SHELLOPTS: Параметры оболочки, которые вы можете установить с помощью вариант.
UID: Идентификатор пользователя текущего пользователя.

СВЯЗАННЫЕ С: Как использовать pushd и popd в Linux

Давайте проверим некоторые из этих переменных оболочки:

echo $BASH_VERSION

echo $HOSTNAME

echo $COLUMNS

echo $HISTFILESIZE

echo $UID

Для полноты, вот токены, которые вы можете использовать в определениях командной строки:

Т: Текущее время в формате ЧЧ: ММ: СС.
D: Текущая дата, выраженная в виде дня недели, месяца, даты.
П: Символ новой строки.
S: Название вашей оболочки.
W: Название вашего текущего рабочего каталога.
Ш: Путь к вашему текущему рабочему каталогу.
И: Имя пользователя, который вошел в систему.
час: Имя хоста компьютера.
#: Каждая команда в оболочке пронумерована. Это позволяет увидеть номер команды в командной строке. Это не то же самое, что число, которое будет иметь команда в список.
$: Устанавливает последний символ приглашения в знак доллара () для обычного пользователя и хеш-символ () для пользователя root. Это работает путем проверки UID пользователя. Если это ноль, пользователь root.

Вы найдете определение вашего переменная окружения в вашем файл.

Заключение

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

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

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

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

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

$(команда)

С помощью этой конструкции вывод команды будет перенаправлен прямо туда, откуда она была вызвана, а не на экран. Например, утилита date возвращает текущую дату. Эти команды эквивалентны:

Понимаете? Напишем скрипт, где будет выводиться hello world и дата:

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