Как задать переменную в bash
Перейти к содержимому

Как задать переменную в bash

  • автор:

Bash Variables: Useful Methods for Working with Variables in Bash

Any programming language comes with its own set of variables. They are an essential part of any system and are needed to run even the most simple programs.

With variables, users can store any information, such as numbers or dates, as well as strings, such as answers to questions, alphanumeric characters, their name information, or even array elements.

Bash is no exception and also comes with variables. It’s a Unix shell that reads shell commands and uses them to interact with your physical computer or a virtual private server (VPS).

This tutorial will cover all the different types of bash variables and provide some practical examples of how you can use them on your machine.

What Exactly Are Bash Variables, and How Do They Work?

A bash variable acts as temporary storage for a string or a number. Bash variables are prevalent when it comes to bash scripting. Variables also make it easy for users to write complex functions and perform various operations.

Users can create variables by giving them a name and a value. A name can be anything. However, it cannot start with a number, and it cannot contain spaces, only underscores if necessary.

As for value, it can be any string or number. Keeping the variable name similar to its value is recommended, as it’s easier to remember and differentiate between other variables.

Here are a few other syntax caveats worth mentioning:

  • Even though it’s not possible to put numbers at the start of variables, users can still make the first or any characters in a variable name using capital letters.
  • Bash variables are case-sensitive, meaning that myvariable and MyVariable will be considered different variables.
  • When a user wants to refer to a variable, print it out. In other words, you need to add a $ symbol before its name. This way, bash will know that the user wants to use a variable value.
  • Whenever a user needs to create a variable or modify its value, the $ symbol is not necessary, just the actual name of the variable.
  • Usually, variable manipulation is used in bash scripts, loops, and arrays. However, it is possible to specify and use variables without scripts – simply state that in the command-line.

Types of Bash Variables

Bash comes in two types of variables – system-defined and user-defined variables. Let’s analyze them in greater detail:

  • System-defined variables – as the name suggests, bash already comes with a set of variables, which can also be called environment variables. All of them can be used by all bash scripts as they are already defined by the system itself:
  • User-defined variables – these are variables set and modified by the user. They can also be called local variables and are only visible within the block of code. Unlike environment variables, user-defined variables only work for that particular script.

Working With Variables in Bash

Bash allows users to define and manipulate variables in both bash scripts and the command-line. Let’s take a quick look at both examples:


We will create a myuser variable and check which shell it is using.

The use of local variables combined with the system-defined variable that displays the SHELL type

Bash script

A more convenient way to manipulate variables is with the help of a bash script. We will create the same script in the command-line but using a bash script. Start by creating a bash script file with your preferred text editor:

Then, paste the following contents:

Lastly, run the script:

The use of two variables in a terminal window. Output ends when an echo shows the results

How to Use Variables in Bash Scripts

One of the most popular uses for bash variables is in bash scripting. Users can define all sorts of variables and use them in automated scripts.

When executed, such scripts can perform thousands of operations with a single click, making them especially useful for automation tasks or to save time writing similar commands manually.

Let’s start with a simple example. Begin by creating a script with your favorite text editor. We will use nano in this case:

Then, paste the following contents:

The first line defines the shell we will use. In our case, it will be a bash shell.

Then, the script will create a new variable named myvariablename. Mind that in order to assign a new variable, you will need to use an equals sign (=).

We will use the echo command to print out the variable value. We also need to use a dollar sign ($), so the bash knows we need variable value.

Lastly, run the script using this bash command:

The terminal window displaying on how to assign a particular value to a variable in bash

As shown in the example above, the command executes the whole script, and bash performs all user-specified actions on the system.

How to Work With Special Variables

Bash comes with various special characters, also called special variables. The following table will cover all of them:

The terminal window shows the use of a few special characters in bash

First, we declared a new variable, then used the first parameter to connect the strings with double quotes into one. We then used the remaining special characters to display the ID of the current shell and the shell file name we executed.

How to Create Your Bash Variables

Any variable you create other than environment variables is considered your own. In other words, it will only work within your script.

Note that variables cannot start with a number or contain spaces. However, underscores and capital letters are allowed. Let’s create an example bash script with different types of variable names:

Then, paste the following:

The current script on the terminal displays the majority of valid variable names

Our example shows that even if the variable names are similar, they are all interpreted as separate variables.

How to Work with Environment Variables

Environment variables can be used by all bash scripts on a given system. Unlike local variables, environment ones are automatically set by the system. They are always written with capital letters, which is one of the main indications that users are using environment variables.

For example, the following script will display four essential parameters that system administrators can use when managing systems: shell type, user current working directory, home directory, and actual user name.

The terminal window showcases the commands to display user

How to Export Bash Variables

Exporting variables in bash allows users to use such variables between different child shell instances. In order to export variables, first, we need to create a test variable:

Now, if you were to print this variable, it would work just fine:

Variable declaration in a terminal, echo command prints out the variable value

Now, use the export command to export the hello variable and switch out to a new shell instance:

Export command use case in a terminal. It allows users to use locally defined variables within different shell instances

For example, if you would’ve skipped the export command, no output would be visible:

Terminal output when the export command wasn

How to Quote Bash Variables

Quotation marks play an essential role in the bash shell. Depending if you use double quotes (“) or single quotes (‘), it can change the output.

For example, we will create two scripts, one using double quotes and the other one using single quotes. Start making the bash script by pasting the following command:

Now, paste the following:

The terminal shows the use case of double quotes, in that case, the user will see a standard output where bash will print out the actual value of a given variable

Then, create another bash script:

Finally, use the following command:

The terminal window shows the second script containing single quotes, in this case, bash will print out the original variables

Double quotes print out the actual variable value, as seen in the examples. In contrast, single quotes show only the variable name instead.

How to Use Substitution Command on Bash

Command substitution, also known as variable substitution, is the process of allowing a command to run and its output to be pasted back as command-line arguments.

For example, let us use substitution to create 10 files with the help of a sequence command and $( ) special characters:

The terminal window displays the use of command substitution. It creates ten empty files with the help of touch and seq commands

touch $(seq 1 5) $( ) substitution special characters allow the touch command to be run together, resulting in a command that creates 10 empty files.


As with most programming languages, bash comes with its own variables, classified as local and environment variables. Users can use them to create scripts to automate tasks or perform several other actions on the bash shell.

In this tutorial, we’ve covered all the different types of variables and provided some useful examples of how they can be used in real-life scenarios on your physical or virtual servers. We hope that you found this tutorial helpful. If you have any questions or insights, leave them in the comments section below.


Ignas takes great satisfaction in helping people tackle even the most complex technical issues. His current goal is to write easy-to-follow articles so that these issues will not happen at all. During his free time, Ignas likes to play video games and fix up things around his house.

Titiaiev / bash-guide-1.md

BASH — Bourne-Again SHell (что может переводится как «перерожденный шел», или «Снова шел Борна(создатель sh)»), самый популярный командный интерпретатор в юниксоподобных системах, в особенности в GNU/Linux. Ниже приведу ряд встроенных команд, которые мы будем использовать для создания своих скриптов.

break выход из цикла for, while или until
continue выполнение следующей итерации цикла for, while или until
echo вывод аргументов, разделенных пробелами, на стандартное устройство вывода
exit выход из оболочки
export отмечает аргументы как переменные для передачи в дочерние процессы в среде
hash запоминает полные имена путей команд, указанных в качестве аргументов, чтобы не искать их при следующем обращении
kill посылает сигнал завершения процессу
pwd выводит текущий рабочий каталог
read читает строку из ввода оболочки и использует ее для присвоения значений указанным переменным.\
return заставляет функцию оболочки выйти с указанным значением
shift перемещает позиционные параметры налево
test вычисляет условное выражение
times выводит имя пользователя и системное время, использованное оболочкой и ее потомками
trap указывает команды, которые должны выполняться при получении оболочкой сигнала
unset вызывает уничтожение переменных оболочки
wait ждет выхода из дочернего процесса и сообщает выходное состояние.

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

Что необходимо знать с самого начала

  1. Любой bash-скрипт должен начинаться со строки:

в этой строке после #! указывается путь к bash-интерпретатору, поэтому если он у вас установлен в другом месте(где, вы можете узнать набрав whereis bash ) поменяйте её на ваш путь.

  1. Коментарии начинаются с символа # (кроме первой строки).
  2. В bash переменные не имеют типа(о них речь пойдет ниже)

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

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

#!/bin/bash #указываем где у нас хранится bash-интерпретатор
#присваиваем переменной parametr1 значение первого параметра скрипта
#присваиваем переменной script_name значение имени скрипта
# команда echo выводит определенную строку, обращение к переменным осуществляется через $имя_переменной.
echo «Вы запустили скрипт с именем $script_name и параметром $parametr1»
# здесь мы видим другие кавычки, разница в том, что в одинарных кавычках не происходит подстановки переменных.
echo ‘Вы запустили скрипт с именем $script_name и параметром $parametr1’
#Выход с кодом 0 (удачное завершение работы скрипта)
exit 0

Результат выполнения скрипта:

$ ./test.sh qwerty
Вы запустили скрипт с именем ./test.sh и параметром qwerty
Вы запустили скрипт с именем $script_name и параметром $parametr1

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

$DIRSTACK — содержимое вершины стека каталогов
$EDITOR — текстовый редактор по умолчанию
$EUID — Эффективный UID. Если вы использовали программу su для выполнения команд от другого пользователя, то эта переменная содержит UID этого пользователя, в то время как.
$UID — . содержит реальный идентификатор, который устанавливается только при логине.
$FUNCNAME — имя текущей функции в скрипте.
$GROUPS — массив групп к которым принадлежит текущий пользователь
$HOME — домашний каталог пользователя
$HOSTNAME — ваш hostname
$HOSTTYPE — архитектура машины.
$LC_CTYPE — внутренняя переменная, котороя определяет кодировку символов
$OLDPWD — прежний рабочий каталог
$OSTYPE — тип ОС
$PATH — путь поиска программ
$PPID — идентификатор родительского процесса
$SECONDS — время работы скрипта(в сек.)
$# — общее количество параметров переданных скрипту
$* — все аргументы переданыне скрипту(выводятся в строку)
$@ — тоже самое, что и предыдущий, но параметры выводятся в столбик
$! — PID последнего запущенного в фоне процесса
$$ — PID самого скрипта

Условные операторы, думаю, знакомы практически каждому, кто хоть раз пытался на чем-то писать программы. В bash условия пишутся след. образом (как обычно на примере):

#в переменную source засовываем первый параметр скрипта
#в переменную dest засовываем второй параметр скрипта

# в ковычках указываем имена переменных для сравнения. -eq — логическое сравнение обозначающие «равны»
if [[ «$source» -eq «$dest» ]]
# если они действительно равны, то
#выводим сообщение об ошибке, т.к. $source и $dest у нас равны
echo «Применик $dest и источник $source один и тот же файл!»
# выходим с ошибкой (1 — код ошибки)
exit 1
# если же они не равны
# то выполняем команду cp: копируем источник в приемник
cp $source $dest
echo «Удачное копирование!»
fi #обозначаем окончание условия.

Результат выполнения скрипта:

$ ./primer2.sh 1 1
Применик 1 и источник 1 один и тот же файл!

$ ./primer2.sh 1 2
Удачное копирование!

Структура if-then-else используется следующим образом:

if <команда или набор команд возвращающих код возврата(0 или 1)>
<если выражение после if истино, то выполняется этот блок>
<если выражение после if ложно, тот этот>

В качестве команд возвращающих код возврата могут выступать структуры [[ , [ , test, (( )) или любая другая(или несколько) linux-команда.

test — используется для логического сравнения. после выражения, неоьбходима закрывающая скобка «]»
[ — синоним команды test
[[ — расширенная версия «[» (начиная с версии 2.02)(как в примере), внутри которой могут быть использованы || (или), & (и). Долна иметь закрывающуб скобку «]]»
(( )) — математическое сравнение.

для построения многоярусных условий вида:

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

Условия. Множественный выбор

Если необходимо сравнивать какоую-то одну переменную с большим количеством параметров, то целесообразней использовать оператор case.

echo «Выберите редатор для запуска:»
echo «1 Запуск программы nano»
echo «2 Запуск программы vi»
echo «3 Запуск программы emacs»
echo «4 Выход»
#здесь мы читаем в переменную $doing со стандартного ввода
read doing

case $doing in
/usr/bin/nano # если $doing содержит 1, то запустить nano
/usr/bin/vi # если $doing содержит 2, то запустить vi
/usr/bin/emacs # если $doing содержит 3, то запустить emacs
exit 0
*) #если введено с клавиатуры то, что в case не описывается, выполнять следующее:
echo «Введено неправильное действие»

esac #окончание оператора case.

$ ./menu2.sh
Выберите редатор для запуска:
1 Запуск программы nano
2 Запуск программы vi
3 Запуск программы emacs
4 Выход

После выбор цифры и нажатия Enter запуститься тот редактор, который вы выбрали(если конечно все пути указаны правильно, и у вас установлены эти редакторы 🙂 )

Прведу список логических операторв, которые используются для конструкции if-then-else-fi:

-z # строка пуста
-n # строка не пуста
=, (==) # строки равны
!= # строки неравны
-eq # равно
-ne # неравно
-lt,(< ) # меньше
-le,(<=) # меньше или равно
-gt,(>) #больше
-ge,(>=) #больше или равно
! #отрицание логического выражения
-a,(&&) #логическое «И»
-o,(||) # логическое «ИЛИ»

С основами языка и условиями мы разобрались, чтобы не перегружать статью, разобью её на несколько частей(допустим на 3). Во второй части разберем операторы цикла и выполнение математических операций.

Циклы. Цикл for-in.

Оператор for-in предназначен для поочередного обращения к значениям перечисленным в списке. Каждое значение поочередно в списке присваивается переменной.
Синтаксис следующий:

Рассмотрим небольшой пример:

После выполнения примера в первых 5 виртуальных консолях(терминалах) появится строка с её номером. В переменную $i поочередно подставляются значения из списка и в цикле идет работа со значением этой переменной

Циклы. Цикл while.

Цикл while сложнее цикла for-in и используется для повторения команд, пока какое-то выражение истинно( код возврата = 0).
Синтаксис оператора следующий:

Пример работы цикла рассмотрим на следующем примере:

А теперь результат работы скрипта:

Как видим цикл выполняется до тех пор, пока мы не введем что-то отличное от «yes». Между do и done можно описывать любые структуры, операторы и т.п., все они будут выполнятся в цикле.Но следует быть осторожным с этим циклом, если вы запустите на выполнение в нём какую-либо команду, без изменения переменной выражения, вы можете попасть в бесконечный цикл.

Теперь об условии истинности. После while , как и в условном операторе if-then-else можно вставлять любое выражение или команду, которая возвращает код возврата, и цикл будет исполнятся до тех пор, пока код возврата = 0! Оператор [ аналог команды test , которая проверяет истинность условия, которое ей передали.

Рассмотрим еще один пример, я взял его из книги Advanced Bash Scripting. Уж очень он мне понравился :), но я его немного упростил. В этом примере мы познакомимся с еще одним типом циклов UNTIL-DO. Эта практически полный аналог цикла WHILE-DO, только выполняется пока какое-то выражение ложно.
Вот пример:

Результат выполнения скрипта:

Команда let .
Команда let производит арифметические операции над числами и переменными.
Рассмотрим небольшой пример, в котором мы производим некоторые вычисления над введенными числами:

Ну вот, как видите ничего сложного, список математических операций стандартный:

+ — сложение
— — вычитание
* — умножение
/ — деление
** — возведение в степень
% — модуль(деление по модулю), остаток от деления
let позволяет использовать сокращения арифметических команд, тем самым сокращая кол-во используемых переменных. Например: a = a+b эквивалентно a +=b и т.д

Работа с внешними программами при написании shell-скриптов

Для начала немного полезной теории.

В bash (как и многих других оболочках) есть встроенные файловые дескрипторы: 0 (stdin) , 1 (stdout) , 2 (stderr) .
stdout — Стандартный вывод. Сюда попадает все что выводят программы
stdin — Стандартный ввод. Это все что набирает юзер в консоли
stderr — Стандартный вывод ошибок.
Для операций с этими дескрипторами, существуют специальные символы: > (перенаправление вывода), < (перенаправление ввода). Оперировать ими не сложно. Например:

Если есть необходимость дописывать в файл(при использовании » > » он заменятеся), необходимо вместо » > » использовать » >> «

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

цифра 2 перед » > » означает что нужно перенаправлять все что попадет в дескриптор 2(stderr).
Если необходимо заставить stderr писать в stdout , то это можно след. образом:

символ » & » означает указатель на дескриптор 1(stdout)
(Поумолчанию stderr пишет на ту консоль, в котрой работает пользователь(вренее пишет на дисплей)).

Конвеер — очень мощный инструмент для работы с консолью Bash. Синтаксис простой:
команда1 | команда 2 — означает, что вывод команды 1 передастся на ввод команде 2
Конвееры можно группировать в цепочки и выводить с помощью перенаправления в файл, например:

вывод команды ls -la передается команде grep , которая отбирает все строки, в которых встретится слово hash, и передает команде сортировке sort , которая пишет результат в файл sorting_list. Все довольно понятно и просто.

Чаще всего скрипты на Bash используются в качестве автоматизации каких-то рутинных операций в консоли, отсюда иногда возникает необходимость в обработке stdout одной команды и передача на stdin другой команде, при этом результат выполнения одной команды должен быть неким образом обработан. В этом разделе я постораюсь объяснить основные принципы работы с внешними командами внутри скрипта. Думаю что примеров я привел достаточно и можно теперь писать только основные моменты.

1. Передача вывода в переменную.

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

Результат работы: qwerty

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

Здесь мы используем цикл for-do-done для архивирование всех директорий в папке /svn/ с помощью команды svnadmin hotcopy (что в нашем случае не имеет никого значения, просто как пример). Наибольшй интерес вызывает строка: LIST= find /svn/ -type d 2>/dev/null| awk ‘ ‘| sort|uniq | tr ‘\n’ ‘ ‘ В ней переменной LIST присваивается выполнение команды find, обработанной командами awk, sort, uniq,tr(все эти команды мы рассматривать не будем, ибо это отдельная статья). В переменной LIST будут имена всех каталогов в папке /svn/ пгомещенных в одну строку(для того чтобы её стравить циклу.

Bash-скрипты: начало

Сегодня поговорим о bash-скриптах. Это — сценарии командной строки, написанные для оболочки bash. Существуют и другие оболочки, например — zsh, tcsh, ksh, но мы сосредоточимся на bash. Этот материал предназначен для всех желающих, единственное условие — умение работать в командной строке Linux.

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

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

На самом деле, если вы опробовали это в своём терминале, ваш первый bash-скрипт, в котором задействованы две команды, уже написан. Работает он так. Сначала команда pwd выводит на экран сведения о текущей рабочей директории, потом команда whoami показывает данные о пользователе, под которым вы вошли в систему.

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

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

Как устроены bash-скрипты

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

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

Команды оболочки отделяются знаком перевода строки, комментарии выделяют знаком решётки. Вот как это выглядит:

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

Установка разрешений для файла сценария

Сохраните файл, дав ему имя myscript , и работа по созданию bash-скрипта почти закончена. Сейчас осталось лишь сделать этот файл исполняемым, иначе, попытавшись его запустить, вы столкнётесь с ошибкой Permission denied .

Попытка запуска файла сценария с неправильно настроенными разрешениями

Сделаем файл исполняемым:

Теперь попытаемся его выполнить:

После настройки разрешений всё работает как надо.

Успешный запуск bash-скрипта

Вывод сообщений

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

Вот что получится после запуска обновлённого скрипта.

Вывод сообщений из скрипта

Теперь мы можем выводить поясняющие надписи, используя команду echo . Если вы не знаете, как отредактировать файл, пользуясь средствами Linux, или раньше не встречались с командой echo , взгляните на этот материал.

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

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

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


Существуют два типа переменных, которые можно использовать в bash-скриптах:

  • Переменные среды
  • Пользовательские переменные

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

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

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

Использование переменной среды в сценарии

А что если надо вывести на экран значок доллара? Попробуем так:

Система обнаружит знак доллара в строке, ограниченной кавычками, и решит, что мы сослались на переменную. Скрипт попытается вывести на экран значение неопределённой переменной $1 . Это не то, что нам нужно. Что делать?

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

Теперь сценарий выведет именно то, что ожидается.

Использование управляющей последовательности для вывода знака доллара

Пользовательские переменные

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

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

TNW-CUS-FMP — промо-код на 10% скидку на наши услуги, доступен для активации в течение 7 дней

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

Пользовательские переменные в сценарии

Подстановка команд

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

Сделать это можно двумя способами.

  • С помощью значка обратного апострофа «`»
  • С помощью конструкции $()

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

При втором подходе то же самое записывают так:

А скрипт, в итоге, может выглядеть так:

В ходе его работы вывод команды pwd будет сохранён в переменной mydir , содержимое которой, с помощью команды echo , попадёт в консоль.

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

Математические операции

Для выполнения математических операций в файле скрипта можно использовать конструкцию вида $((a+b)) :

Математические операции в сценарии

Управляющая конструкция if-then

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

А вот рабочий пример:

В данном случае, если выполнение команды pwd завершится успешно, в консоль будет выведен текст «it works».

Воспользуемся имеющимися у нас знаниями и напишем более сложный сценарий. Скажем, надо найти некоего пользователя в /etc/passwd , и если найти его удалось, сообщить о том, что он существует.

Вот что получается после запуска этого скрипта.

Здесь мы воспользовались командой grep для поиска пользователя в файле /etc/passwd . Если команда grep вам незнакома, её описание можно найти здесь.

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

Управляющая конструкция if-then-else

Для того, чтобы программа смогла сообщить и о результатах успешного поиска, и о неудаче, воспользуемся конструкцией if-then-else . Вот как она устроена:

Если первая команда возвратит ноль, что означает её успешное выполнение, условие окажется истинным и выполнение не пойдёт по ветке else . В противном случае, если будет возвращено что-то, отличающееся от нуля, что будет означать неудачу, или ложный результат, будут выполнены команды, расположенные после else .

Напишем такой скрипт:

Его исполнение пошло по ветке else .

Запуск скрипта с конструкцией if-then-else

Ну что же, продолжаем двигаться дальше и зададимся вопросом о более сложных условиях. Что если надо проверить не одно условие, а несколько? Например, если нужный пользователь найден, надо вывести одно сообщение, если выполняется ещё какое-то условие — ещё одно сообщение, и так далее. В подобной ситуации нам помогут вложенные условия. Выглядит это так:

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

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

Сравнение чисел

В скриптах можно сравнивать числовые значения. Ниже приведён список соответствующих команд.

n1 -eq n2 Возвращает истинное значение, если n1 равно n2 .
n1 -ge n2 Возвращает истинное значение, если n1 больше или равно n2 .
n1 -gt n2 Возвращает истинное значение, если n1 больше n2 .
n1 -le n2 Возвращает истинное значение, если n1 меньше или равно n2 .
n1 -lt n2 Возвращает истинное значение, если n1 меньше n2 .
n1 -ne n2 Возвращает истинное значение, если n1 не равно n2 .

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

Вот что выведет эта команда.

Сравнение чисел в скриптах

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

Сравнение строк

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

str1 = str2 Проверяет строки на равенство, возвращает истину, если строки идентичны.
s tr1 != str2 Возвращает истину, если строки не идентичны.
str1 < str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 Возвращает истину, если str1 больше, чем str2 .
-n str1 Возвращает истину, если длина str1 больше нуля.
-z str1 Возвращает истину, если длина str1 равна нулю.

Вот пример сравнения строк в сценарии:

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

Сравнение строк в скриптах

Вот одна особенность сравнения строк, о которой стоит упомянуть. А именно, операторы «>» и «<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>» как команду перенаправления вывода.

Вот как работа с этими операторами выглядит в коде:

Вот результаты работы скрипта.

Сравнение строк, выведенное предупреждение

Обратите внимание на то, что скрипт, хотя и выполняется, выдаёт предупреждение:

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

Теперь всё работает как надо.

Ещё одна особенность операторов «>» и «<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Сохраним его, дав имя myfile , после чего выполним в терминале такую команду:

Она отсортирует строки из файла так:

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

Если его запустить, окажется, что всё наоборот — строчная буква теперь больше прописной.

Команда sort и сравнение строк в файле сценария

В командах сравнения прописные буквы меньше строчных. Сравнение строк здесь выполняется путём сравнения ASCII-кодов символов, порядок сортировки, таким образом, зависит от кодов символов.

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

Проверки файлов

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

-d file Проверяет, существует ли файл, и является ли он директорией.
-e file Проверяет, существует ли файл.
-f file Проверяет, существует ли файл, и является ли он файлом.
-r file Проверяет, существует ли файл, и доступен ли он для чтения.
-s file П роверяет, существует ли файл, и не является ли он пустым.
-w file Проверяет, существует ли файл, и доступен ли он для записи.
-x file Проверяет, существует ли файл, и является ли он исполняемым.
file1 -nt file2 Проверяет, новее ли file1 , чем file2 .
file1 -ot file2 Проверяет, старше ли file1 , чем file2 .
-O file Проверяет, существует ли файл, и является ли его владельцем текущий пользователь.
-G file Проверяет, существует ли файл, и соответствует ли его идентификатор группы идентификатору группы текущего пользователя.

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

Опробуем одну из команд на практике:

Этот скрипт, для существующей директории, выведет её содержимое.

Вывод содержимого директории

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


Сегодня мы рассказали о том, как приступить к написанию bash-скриптов и рассмотрели некоторые базовые вещи. На самом деле, тема bash-программирования огромна. Эта статья является переводом первой части большой серии из 11 материалов. Если вы хотите продолжения прямо сейчас — вот список оригиналов этих материалов. Для удобства сюда включён и тот, перевод которого вы только что прочли.

    — здесь речь идёт о том, как начать создание bash-скриптов, рассмотрено использование переменных, описаны условные конструкции, вычисления, сравнения чисел, строк, выяснение сведений о файлах. — тут раскрываются особенности работы с циклами for и while. — этот материал посвящён параметрам командной строки и ключам, которые можно передавать скриптам, работе с данными, которые вводит пользователь, и которые можно читать из файлов. — здесь речь идёт о дескрипторах файлов и о работе с ними, о потоках ввода, вывода, ошибок, о перенаправлении вывода. — этот материал посвящён сигналам Linux, их обработке в скриптах, запуску сценариев по расписанию. — тут можно узнать о создании и использовании функций в скриптах, о разработке библиотек. — эта статья посвящена работе с потоковым текстовым редактором sed. — данный материал посвящён программированию на языке обработки данных awk. — тут можно почитать об использовании регулярных выражений в bash-скриптах. — здесь приведены приёмы работы с сообщениями, которые можно отправлять пользователям, а так же методика мониторинга диска. — этот материал посвящён средству Expect, с помощью которого можно автоматизировать взаимодействие с интерактивными утилитами. В частности, здесь идёт речь об expect-скриптах и об их взаимодействии с bash-скриптами и другими программами.

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

Уважаемые читатели! Просим гуру bash-программирования рассказать о том, как они добрались до вершин мастерства, поделиться секретами, а от тех, кто только что написал свой первый скрипт, ждём впечатлений.

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

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

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

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

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

Командный интерпретатор Bash поддерживает переменные среды, которые отслеживают различную системную информацию:

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

Для ознакомления с полным списком локальных переменных среды используется команда set.

Значения этих переменных Bash можно использовать в сценариях, для чего необходимо указать имя переменной с предшествующим ей знаком доллара ($).

echo «Информация о пользователе $USER:»
echo UID: $UID
echo Домашний каталог: $HOME

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

Переменные окружения Bash $USER, $UID и $HOME использовались для отображения запрашиваемой информации о текущем зарегистрированном пользователе.

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

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

echo «Неправильная цена вещи: $15»
echo «Правильная цена вещи: \$15»

Результат работы скрипта:

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

На заметку: частым случаем является использование фигурных скобок вокруг имени переменной после знака доллара (например $ ). Этот приём позволяет просто определить имя переменной, а на её функциональность это никак не влияет.

Пользовательские переменные Bash

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

Пользовательские переменные Bash Linux могут быть названы любой текстовой строкой длиной до 20 символов, состоящей из букв, цифр и символа подчёркивания. В названии учитывается регистр букв, поэтому переменная Var1 не является переменной var1. Новички в области написания сценариев часто забывают об этой особенности, отчего и допускают трудно диагностируемые ошибки.

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

var4=»текстовая строка»

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

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


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

Обнаружили ошибку в тексте? Сообщите мне об этом. Выделите текст с ошибкой и нажмите Ctrl+Enter.

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

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