Руководство по башу

Bash-скрипты: начало
Bash-скрипты, часть 2: циклы
Bash-скрипты, часть 3: параметры и ключи командной строки
Bash-скрипты, часть 4: ввод и вывод
Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями
Bash-скрипты, часть 6: функции и разработка библиотек
Bash-скрипты, часть 7: sed и обработка текстов
Bash-скрипты, часть 8: язык обработки данных awk
Bash-скрипты, часть 9: регулярные выражения
Bash-скрипты, часть 10: практические примеры
Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит

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

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

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

pwd ; whoami

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

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

getconf ARG_MAX

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

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

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

#!/bin/bash

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

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

#!/bin/bash
# This is a comment
pwd
whoami

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

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

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

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

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

chmod +x ./myscript

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

./myscript

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

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

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

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

#!/bin/bash
# our comment is here
echo "The current directory is:"
pwd
echo "The user logged in is:"
whoami

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

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

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

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

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

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

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

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

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

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

#!/bin/bash
# display user home
echo "Home for the current user is: $HOME"

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

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

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

echo "I have $1 in my pocket"

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

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

echo "I have \$1 in my pocket"

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

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

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

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

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

#!/bin/bash
# testing variables
grade=5
person="Adam"
echo "$person is a good boy, he is in grade $grade"

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

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

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

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

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

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

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

mydir=`pwd`

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

mydir=$(pwd)

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

#!/bin/bash
mydir=$(pwd)
echo $mydir

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

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

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

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

#!/bin/bash
var1=$(( 5 + 5 ))
echo $var1
var2=$(( $var1 * 2 ))
echo $var2

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

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

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

if команда
then
команды
fi

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

#!/bin/bash
if pwd
then
echo "It works"
fi

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

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

#!/bin/bash
user=likegeeks
if grep $user /etc/passwd
then
echo "The user $user Exists"
fi

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

Поиск пользователя

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

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

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

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

if команда
then
команды
else
команды
fi

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

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

#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
else
echo "The user $user doesn’t exist"
fi

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

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

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

if команда1
then
команды
elif команда2
then
команды
fi

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

#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
elif ls /home
then
echo "The user doesn’t exist but anyway there is a directory under /home"
fi

В подобном скрипте можно, например, создавать нового пользователя с помощью команды 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.

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

#!/bin/bash
val1=6
if [ $val1 -gt 5 ]
then
echo "The test value $val1 is greater than 5"
else
echo "The test value $val1 is not greater than 5"
fi

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

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

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

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

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

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

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

#!/bin/bash
user ="likegeeks"
if [$user = $USER]
then
echo "The user $user  is the current logged in user"
fi

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

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

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

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

#!/bin/bash
val1=text
val2="another text"
if [ $val1 \> $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

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

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

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

./myscript: line 5: [: too many arguments

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

#!/bin/bash
val1=text
val2="another text"
if [ $val1 \> "$val2" ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

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

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

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

Likegeeks
likegeeks

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

sort myfile

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

likegeeks
Likegeeks

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

#!/bin/bash
val1=Likegeeks
val2=likegeeks
if [ $val1 \> $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

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

Команда 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Проверяет, существует ли файл, и соответствует ли его идентификатор группы идентификатору группы текущего пользователя.

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

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

#!/bin/bash
mydir=/home/likegeeks
if [ -d $mydir ]
then
echo "The $mydir directory exists"
cd $ mydir
ls
else
echo "The $mydir directory does not exist"
fi

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

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

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

Итоги

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

1. Bash Script Step By Step — здесь речь идёт о том, как начать создание bash-скриптов, рассмотрено использование переменных, описаны условные конструкции, вычисления, сравнения чисел, строк, выяснение сведений о файлах.
2. Bash Scripting Part 2, Bash the awesome — тут раскрываются особенности работы с циклами for и while.
3. Bash Scripting Part 3, Parameters & options — этот материал посвящён параметрам командной строки и ключам, которые можно передавать скриптам, работе с данными, которые вводит пользователь, и которые можно читать из файлов.
4. Bash Scripting Part 4, Input & Output — здесь речь идёт о дескрипторах файлов и о работе с ними, о потоках ввода, вывода, ошибок, о перенаправлении вывода.
5. Bash Scripting Part 5, Sighals & Jobs — этот материал посвящён сигналам Linux, их обработке в скриптах, запуску сценариев по расписанию.
6. Bash Scripting Part 6, Functions — тут можно узнать о создании и использовании функций в скриптах, о разработке библиотек.
7. Bash Scripting Part 7, Using sed — эта статья посвящена работе с потоковым текстовым редактором sed.
8. Bash Scripting Part 8, Using awk — данный материал посвящён программированию на языке обработки данных awk.
9. Bash Scripting Part 9, Regular Expressions — тут можно почитать об использовании регулярных выражений в bash-скриптах.
10. Bash Scripting Part 10, Practical Examples — здесь приведены приёмы работы с сообщениями, которые можно отправлять пользователям, а так же методика мониторинга диска.
11. Bash Scripting Part 11, Expect Command — этот материал посвящён средству Expect, с помощью которого можно автоматизировать взаимодействие с интерактивными утилитами. В частности, здесь идёт речь об expect-скриптах и об их взаимодействии с bash-скриптами и другими программами.

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

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

Переводить остальные части цикла статей?

Проголосовали 1579 пользователей.

Воздержались 125 пользователей.

Advanced Bash-Scripting Guide

��������� ���������������� �� ����� ���������
��������� ��������

�������: ������ �������

��������: Russian Linux Gazette

����� ����������� � html-������� (~380��)

����� ����������� � sgml-������� (~380��)

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

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

Содержание

• Что такое Bash
• Синтаксис Bash: из чего состоит

• Пишем первый скрипт
• Заключение

Bash (Bourne again shell) — это стандартная командная оболочка в большинстве дистрибутивов Linux и macOS, а также язык для этой оболочки.

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

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

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

Кодить будем в терминале Linux — он открывается сочетанием клавиш Ctrl + Alt + T. Если вы хотите научиться работать с Bash, но пока не пользуетесь Linux, то пишите код в одном из онлайн-терминалов — например, Replit.

Переменные в Bash объявляются просто:

message="Hello, World!"

Теперь переменная message хранит значение — текстовое сообщение «Hello, World!». Давайте выведем его — сделать это можно с помощью команды echo:

echo $message # Будет выведено «Hello, World!»

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

Следующий код приведёт к ошибке:

message = "Hello, World!"
bash: message: command not found

Также обратите внимание на символ $ — в Bash он называется символом расширения (expansion character). Поставленный перед именем переменной, он указывает на то, что нужно использовать именно значение переменной, а не одноимённую строку.

Следующий код выведет сообщение «message»:

message="Hello, World!"
echo message

Чтобы сохранить в переменной введённое пользователем значение, используйте команду read:

read name
# Пользователь вводит что-то — например, «Olga»
echo $name # Будет выведено «Olga»

Если вы хотите добавить сообщение перед пользовательским вводом, добавьте флаг -p и сообщение после команды read:

read -p "Enter your name: " name # Будет выведено «Enter your name: »
# Пользователь вводит что-то — например, «Olga»
echo $name # Будет выведено «Olga»

В Bash есть несколько правил именования переменных:

• Имя переменной должно начинаться с буквы латинского алфавита (нижнего или верхнего регистра) или символа подчёркивания _.
• Оно может включать буквы, цифры и символ подчёркивания, но не может содержать пробелы или специальные символы.
• Регистр букв в именах переменных имеет значение. Например, переменные var1 и Var1 будут рассматриваться как разные.
• Не рекомендуется использовать зарезервированные слова Bash в качестве имён переменных.

Ну что же, вот мы и создали нашу первую переменную. Поздравляем! Пока эта переменная содержит всего один тип данных — строковый (string). Но в Bash он далеко не единственный — давайте разберём ещё несколько.

Строки (strings) — это набор символов, заключённый в кавычки. В Bash можно писать строки в одинарных ‘…’ или двойных «…» кавычках. Например, ‘Привет’ и «Мир» — это строки.

Числа (numbers) — это целочисленные значения. Bash поддерживает арифметические операции с целыми числами, включая сложение, вычитание, умножение и деление. Арифметические выражения нужно предварять знаком $ и обрамлять двойными круглыми скобками:

a=2 b=3
echo $(($a + $b)) # Будет выведено 5

Также можно использовать команду expr:

echo $(expr $a + $b)  # Будет выведено 5

Стандартные библиотеки Bash поддерживают следующие арифметические операции:

• Сложение — +.
• Вычитание — —.
• Умножение — *.
• Целочисленное деление — /.
• Остаток от деления — %.
• Возведение в степень — **.

Массивы (arrays) — тип переменных, который может хранить несколько значений. Элементы массива перечисляются в круглых скобках через пробел:

my_array=(apple banana cherry)

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

echo ${my_array[0]} # Выведет «apple»
echo ${my_array[1]} # Выведет «banana»
echo ${my_array[2]} # Выведет «cherry»

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

echo ${my_array[*]} # Выведет «apple banana cherry»
echo ${my_array[@]} # Выведет «apple banana cherry»

Логические значения (boolean) — нужны для того, чтобы проверить, выполняется ли какое-то условие или нет. Они могут быть либо true (истина), либо false (ложь). Например, в операторах if и while мы пишем условие, и если оно true, то выполняем какое-то действие.

В Bash логические значения представлены целыми числами. Число 0 означает true, а любое другое число означает false. Когда мы выводим логическое значение на экран, то вместо true мы видим 0.

Также в Bash есть операторы сравнения. Например, эти нужны для строк:

• = проверяет, одинаковы ли две строки.
• != проверяет, различаются ли две строки.

А эти — для чисел:

• -eq проверяет, равны ли два числа.
• -ne проверяет, различаются ли два числа.
• -gt проверяет, больше ли первое число, чем второе.
• -lt проверяет, меньше ли первое число, чем второе.
• -ge выводит true, если первое число больше или равно второму.
• -le выводит true, если первое число меньше или равно второму.

Использовать операторы сравнения можно с помощью команды test. Команда test принимает два значения и оператор сравнения и возвращает 1 или 0 в зависимости от результата:

test "hello" = "hello" 
echo $? 
# Выведет 0 (true), так как строки одинаковые
test "hello" != "world" 
echo $? 
# Выведет 0 (true), так как строки различаются

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

Ветвления if-then-else позволяют проверить условие и выполнить один набор команд, если условие истинно, и другой набор команд, если условие ложно. Это выглядит так:

if [ условие ]; 
then
    # Команды, которые нужно выполнить, если условие истинно
else
    # Команды, которые нужно выполнить, если условие ложно
fi

А если в паре с основным условием нужно проверить дополнительное, используют конструкцию elif:

if [ условие_1 ]; 
then
    # Команды, которые нужно выполнить, если условие_1 истинно
elif [ условие_2 ];
then
    # Команды, которые нужно выполнить, если условие_2 истинно
else
    # Команды, которые нужно выполнить, если все условия ложны
fi

Существует и более короткая форма записи условной конструкции — if-then. Её используют, когда нужно проверить только одно условие:

if [ условие ]; 
then 
# Команды, которые нужно выполнить
fi

В этом случае команды будут выполнены, только если условие истинно.

Для наглядности давайте напишем скрипт, который проверяет правильность введённого пароля:

#!/bin/bash
# Задаём значение переменной password
password="14pomTEr"

# Запрашиваем ввод пароля у пользователя и сохраняем полученное значение в переменную user_input
read -p "Enter the password: " user_input

# Сравниваем значение переменной password с введённым пользователем значением user_input
if [ "$password" = "$user_input" ]; then
  # Если пароли совпадают, выводим сообщение о том, что пароль введён правильно
  echo "Password accepted"
else
  # Если пароли не совпадают, выводим сообщение о том, что пароль введён неправильно
  echo "Wrong password"
fi

Кроме того, в Bash есть логические операторы & & (логическое И) и || (логическое ИЛИ), которые позволяют комбинировать несколько условий и возвращать соответствующее булево значение.

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

#!/bin/bash

username="OlgaBelova94"  # Устанавливаем переменную с именем пользователя
password="14pomTEr"

read -p "Enter your username: " user_input_username  # Запрашиваем имя пользователя
read -p "Enter the password: " user_input_username  # Запрашиваем пароль

echo "Enter the password: "
read user_input_password  # Запрашиваем пароль

if [ "$username" == "$user_input_username" ] && [ "$password" == "$user_input_password" ]; then
  echo "Password accepted"
else
  echo "Wrong username or password"  # Уточняем, что именно было неверно
fi

Здесь мы получим значение true и сообщение «Password accepted», только если будут выполнены оба условия.

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

• for — когда количество итераций заранее известно.
• while — когда количество итераций заранее не известно.

Вот как выглядит сигнатура цикла for:

for переменная цикла in элемент1 элемент2 ... элементN
do
# Команды, которые будут выполняться в цикле
done

Количество итераций (часть между in и do) можно указать простым перечислением элементов:

for fruit in apple banana cherry
do
    echo "I like $fruit"
done

# Будет выведено:
# I like apple
# I like banana
# I like cherry

Можно перебрать элементы массива:

my_array=("apple" "banana" "orange")

for fruit in "${my_array[@]}"
do
    echo "I like $fruit"
done

# Будет выведено:
# I like apple
# I like banana
# I like cherry

Для явного указания нужного количества итераций используют арифметические выражения:

for ((i=0; i<5; i++))
do
  echo "Iteration number $i"
done
# Будет выведено:
# Iteration number 0
# Iteration number 1
# Iteration number 2
# Iteration number 3
# Iteration number 4

А вот так выглядит сигнатура цикла while:

while [ условие ]
do
  # Команды, которые будут выполняться в цикле
done

Условие (condition) — это выражение, результат которого является логическим значением true или false. Команды внутри цикла будут выполняться до тех пор, пока condition возвращает true.

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

#!/bin/bash

password="14pomTEr"
user_input=""

while [ "$user_input" != "$password" ]
do
  read -p "Enter the password: " user_input
  echo "Wrong password, login denied"
done

echo "Password accepted, login allowed"

Что здесь происходит. В этом примере цикл while запрашивает пароль у пользователя, а потом проверяет его на совпадение с правильным с помощью оператора [«$user_input» != «$password»]. А дальше происходит следующее:

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

Функции на языке Bash имеют такой вид:

имя_функции (аргументы) {
    # Тело функции
}

Например, вот как выглядит простая функция без аргументов:

say_hello () {       # Создаём функцию

    echo hello
}

say_hello        # Вызываем функцию, будет выведено «hello»

А вот как выглядит функция, которая принимает аргументы:

repeat_text () {
    local text=$1
    local reps=$2

    for (( i=0; i<$reps; i++ )); do
        echo "$text"
    done
}
repeat_text "hello" 3

Что здесь происходит:

• С помощью ключевого слова local мы создали две локальные переменные — то есть переменные, существующие только внутри функции.
• В одну из них поместили текст, а во вторую — количество повторов.
• Затем создали цикл, который берёт текст из первой переменной и повторяет его столько раз, сколько раз указано во второй.
• Вызвали функцию, передав ей значения hello и 3 — то есть приказали повторить слово «hello» три раза.

Настало время применить знания на практике — напишем скрипт для автоматической очистки кэша браузера и DNS.

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

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

#!/bin/bash

Теперь напишем функцию, которая будет очищать браузерный кэш. В комментариях — разбор синтаксиса.

clear_browser_cache() {

# Проверяем, какой браузер установлен на компьютере
    if command -v google-chrome >/dev/null 2>&1; then

# Если установлен Google Chrome, очищаем кэш браузера
        google-chrome --user-data-dir=$(mktemp -d) --disable-extensions --disable-plugins --disable-geolocation --no-default-browser-check --no-first-run --noerrdialogs --disable-session-crashed-bubble --disable-infobars --disk-cache-size=0 --media-cache-size=0

# Далее проверяем, установлен ли Firefox
    elif command -v firefox >/dev/null 2>&1; then

# Если установлен Firefox, очищаем кэш браузера
        firefox --new-instance --safe-mode

# Если браузер не установлен, выводим сообщение об ошибке
    else
        echo "Error: no supported browser found"
    fi
}

Далее напишем функцию для очистки кэша DNS.

clear_dns_cache() {
# Проверяем, какая операционная система установлена на компьютере
# Если установлена Linux, очищаем кэш DNS
    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
        sudo systemd-resolve --flush-caches
# Если установлена macOS, очищаем кэш DNS
    elif [[ "$OSTYPE" == "darwin"* ]]; then
        sudo dscacheutil -flushcache
        sudo killall -HUP mDNSResponder
# Если операционная система не поддерживается, выводим сообщение об ошибке
    else
        echo "Error: unsupported operating system"
    fi
}

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

# Сначала выведем варианты
clear_cache() {
    echo "Select cache to clear:"
    echo "1. Browser cache"
    echo "2. DNS cache"
# Запросим у пользователя номер выбранного пункта меню
    read -p "Enter your choice: " choice
# В зависимости от выбранного пункта меню вызываем соответствующую функцию для очистки кэша
    if [ "$choice" -eq 1 ]; then
    clear_browser_cache
elif [ "$choice" -eq 2 ]; then
    clear_dns_cache
else
    echo "Invalid choice"
fi
}

Вуаля! Наш скрипт готов. Чтобы его запустить, нам нужно лишь вызвать функцию clear_cache:

clear_cache

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

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

Ещё можно посмотреть на проект TryBash, где вся базовая теория дана в виде коротких интерактивных уроков. Там же можно забрать удобную шпаргалку с основными командами Bash, чтобы постоянно не бегать в Google во время обучения и экспериментов.

А если чувствуете, что хотите знать больше, можете почитать Advanced Bash-Scripting Guide («Расширенный гайд по написанию скриптов на Bash») — он на английском, но есть хороший любительский перевод. Ну, или приходите на курс Skillbox «Администрирование ОС Linux» — там тоже много всего полезного

Bash (Bourne-Again SHell) — это командный интерпретатор в UNIX-подобных операционных системах, который позволяет автоматизировать задачи на уровне командной строки. Bash-скрипты — это файлы, содержащие последовательность команд, которые могут быть выполнены с помощью интерпретатора Bash. 

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

В этой статье мы рассмотрим основные концепции и инструменты для написания Bash-скриптов в Linux.

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

1. Nano — это простой текстовый редактор, который поставляется вместе с большинством дистрибутивов Linux. Он имеет простой и интуитивно понятный интерфейс, а также некоторые дополнительные полезные функции, такие как подсветка синтаксиса.
2. Vim — это один из самых популярных текстовых редакторов для Linux, хотя он может показаться сложным для начинающих. Vim имеет множество функций, которые помогают ускорить процесс написания кода, такие как подсветка синтаксиса, автодополнение и макросы.
3. Emacs — это еще один популярный текстовый редактор для Linux. Он также имеет множество функций, которые могут значительно упростить процесс написания кода. Одна из его главных особенностей — это возможность запуска интерпретатора Bash внутри редактора, что позволяет тестировать скрипты без выхода из редактора.

В начале каждого скрипта должна быть строка, называемая шебанг (shebang), которая сообщает операционной системе, какой интерпретатор использовать для выполнения скрипта. Шебанг должен начинаться с символа решетки (#) и следующим за ним символ восклицания (!), после которых указывается путь к интерпретатору. Для использования интерпретатора Bash, шебанг будет выглядеть следующим образом:

#!/bin/bash

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

# Это комментарий

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

#!/bin/bash
echo "Hello, $USER!"
echo "Today is $(date)"

Первая строка указывает на то, что это скрипт на Bash. Следующая строка echo "Hello, $USER!" выводит приветствие с именем текущего пользователя. $USER является системной переменной, которая содержит имя текущего пользователя. А третья строка echo "Today is $(date)" выводит текущую дату и время. $(date) используется для вызова команды date, которая возвращает текущую дату и время в формате, указанном в настройках системы.

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

Запуск скриптов

Для запуска скрипта в Linux необходимо дать ему права на выполнение. Чтобы сделать файл исполняемым, можно воспользоваться командой chmod (от англ. change mode — изменить режим). С помощью этой команды вы можете изменять права доступа к файлам и директориям в Linux.

Команда chmod имеет следующий синтаксис:

chmod [опции] права_доступа файл

где права_доступа — это специальный код, который задает права доступа к файлу или директории, а файл — это путь к файлу или директории, права доступа которой нужно изменить.

Для того чтобы сделать файл исполняемым, нужно добавить к его правам доступа бит исполнения (x). 

Например, сделаем файл greeting.sh исполняемым, для этого используем следующую команду:

chmod +x greeting.sh

Эта команда добавит права на выполнение для текущего пользователя. Теперь мы можем запустить Bash-скрипт в Linux, вызвав его из терминала:

./greeting.sh

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

Параметры командной строки

Параметры командной строки позволяют передавать аргументы в скрипты Linux при его запуске. Параметры командной строки могут быть доступны в скрипте как $1, $2, $3 и т.д., где $1 — это первый параметр, $2 — второй параметр и т.д.

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

#!/bin/bash
echo "Hello, $1!”

А затем запустим скрипт, передав ему аргумент $USER:

./greeting.sh $USER

Результат запуска представлен на картинке ниже.

Кроме того, возможно использовать специальные параметры командной строки:

• $0 — имя скрипта (то есть, имя файла, который был запущен)
• $# — количество переданных параметров
• $* или $@ — список всех переданных параметров (в виде одной строки или массива соответственно)
• $? — код возврата последней выполненной команды

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

#!/bin/bash
echo "Hello, " $1 “!”
echo "Количество переданных параметров: $#"

Результат запуска скрипта представлен на картинке ниже.

Переменные

Переменные в Bash используются для хранения данных, таких как строки и числа. Они могут быть определены явно, путем присвоения значения, или неявно, путем автоматического присвоения значения при выполнении определенных операций. Для создания переменной в Bash необходимо присвоить ей значение, используя знак равенства (=). Например:

company="Timeweb"

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

Значение переменной можно получить, указав ее имя после команды echo и знака $. Например:

echo $company

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

#!/bin/bash
echo "What is your name?"
read name
echo "Hello, $name!"

Результат работы данного скрипта представлен на картинке ниже.

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

Кроме этого, доступны переменные окружения, которые определяются системой и могут использоваться в скриптах. Например, $PATH содержит список директорий, в которых Bash ищет исполняемые файлы.

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

export название_переменной

Условные операторы

Условные операторы — это конструкции, которые позволяют выполнить определенный набор действий в зависимости от истинности или ложности какого-то условия. В Bash-скриптах условия записываются в скобках и передаются в команду if. 

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

if [ условие ]
then
  команды, которые нужно выполнить, если условие верно
fi

Здесь в квадратных скобках указывается условие, которое необходимо проверить. Если условие истинно, то будут выполнены команды, указанные между then и fi.

Например, напишем скрипт в Linux chetnechet.sh, который будет проверять, является ли число, введенное пользователем, четным или нечетным:

#!/bin/bash
echo "Введите число: "
read n
if (( $n % 2 == 0 ))
then
  echo "Число $n четное"
else
  echo "Число $n нечетное"
fi

В этом примере мы использовали оператор %, который вычисляет остаток от деления на 2. Если остаток равен 0, то число четное, иначе — нечетное.

Результат работы скрипта представлен на картинке ниже.

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

• -eq – равно;
• -ne – не равно;
• -gt – больше;
• -lt – меньше;
• -ge – больше или равно;
• -le – меньше или равно.

Например, чтобы проверить, является ли переменная $a больше переменной $b, можно написать следующее:

if [ $a -gt $b ]
then
  echo "$a больше $b"
fi

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

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

Конструкция Case

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

Синтаксис конструкции case выглядит следующим образом:

case variable in
    pattern1)
        command1
        ;;
    pattern2)
        command2
        ;;
    pattern3)
        command3
        ;;
    *)
        default command
        ;;
esac

Где variable — это переменная, которую нужно проверить, pattern1, pattern2, pattern3 — это возможные значения, которые нужно проверить, и command1, command2, command3 — это команды, которые нужно выполнить в зависимости от значения переменной.

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

Для примера, давайте рассмотрим скрипт, который проверяет день недели и выполняет соответствующее действие:

#!/bin/bash
day=$(date +%u)
case $day in
    1)
        echo "Сегодня понедельник"
        ;;
    2)
        echo "Сегодня вторник"
        ;;
    3)
        echo "Сегодня среда"
        ;;
    4)
        echo "Сегодня четверг"
        ;;
    5)
        echo "Сегодня пятница"
        ;;
    6)
        echo "Сегодня суббота"
        ;;
    7)
        echo "Сегодня воскресенье"
        ;;
    *)
        echo "Некорректное значение дня недели"
        ;;
esac

В этом примере мы используем переменную day, которую мы определяем с помощью команды date +%u. В данном случае, %u используется для получения числового значения дня недели от 1 (понедельник) до 7 (воскресенье). Затем мы сравниваем эту переменную с днями недели, используя конструкцию case. Если ее значение соответствует определенному значению дня недели, то мы выводим соответствующее сообщение. Если значение не соответствует перечисленным дням недели, мы выводим сообщение об ошибке.

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

Циклы

Циклы в Bash используются для выполнения повторяющихся действий. Существуют два типа циклов: цикл for и цикл while.

Цикл for используется для выполнения команд для каждого элемента из списка.

Синтаксис цикла for выглядит следующим образом:

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

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

Пример:

#!/bin/bash
for i in {1..10}; do
    echo "Number: $i"
done

В этом примере i принимает значения от 1 до 10, и для каждого из них будет выполнена команда echo "Number: $i". Результат выполнения этого цикла будет выглядеть следующим образом:

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

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

Здесь в квадратных скобках указывается условие, которое проверяется перед каждой итерацией цикла. Команды, указанные между do и done, будут выполнены до тех пор, пока условие остается истинным.

Пример:

#!/bin/bash
count=1
while [ $count -le 10 ]; do
    echo "Count: $count"
    count=$((count+1))
done

В этом примере count увеличивается на 1 после каждой итерации цикла. Когда значение count достигает 10, цикл завершается. Результат выполнения этого цикла будет выглядеть следующим образом:

Функции

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

Синтаксис функции выглядит следующим образом:

название_функции () {
    команды_и_выражения
}

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

Вот пример функции, которая выводит текущее время и дату:

#!/bin/bash
print_date () {
    echo "Сегодняшняя дата: $(date)"
}
print_date #Вызов функции



  


                       
  

Результат работы скрипта представлен на картинке ниже.

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

#!/bin/bash
sum_numbers () {
    result=$(( $1 + $2 ))
    echo "Сумма чисел $1 и $2 равна $result"
}
sum_numbers 10 20 #Вызов функции

В этом примере $1 и $2 — это переменные, которые содержат значения первого и второго аргументов соответственно. sum_numbers 10 20 вызовет функцию sum_numbers с аргументами 10 и 20 и выведет следующий результат:

Функции также могут возвращать значения при помощи ключевого слова return. Перепишем прошлый пример, используя новые знания:

#!/bin/bash
sum_numbers () {
    result=$(( $1 + $2 ))
    return $result
}
sum_numbers 12 24 #Вызов функции
echo "Сумма чисел равна $?" #Вывод

Здесь результат сохраняется в переменную result и возвращается из функции с помощью команды return.

Переменная $? содержит код возврата функции, то есть в данном случае — результат вычисления суммы.

Результат работы скрипта представлен на картинке ниже.

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

#!/bin/bash
sum_numbers () {
    result=$(( $1 + $2 ))
    echo $result
}
sum=$(sum_numbers 9 11)
echo "Сумма чисел равна $sum" #Вывод

Здесь, вместо использования $? и return, мы сохраняем результат вызова функции в переменную sum и затем выводим ее значение на экран. Результат продемонстрирован на картинке ниже.

Работа с файлами и директориями

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

test -e filename 

Если файл существует, то команда вернет значение 0, в противном случае — ненулевое значение. Для работы с директориями в Bash-скриптах можно использовать команды cd, mkdir, rmdir, ls и т.д.

Отладка скриптов

Отладка Bash-скриптов может оказаться трудной задачей, поскольку проблемы могут быть вызваны различными факторами, такими как ошибки синтаксиса, неправильное использование переменных или функций и т.д. Для отладки Bash-скриптов можно использовать такие инструменты, как set -x, set -v и set -e. 

Команда set -x позволяет выводить на экран команды перед их выполнением, команда set -v выводит на экран значения переменных перед их использованием, а set -e прерывает выполнение скрипта в случае ошибки.

Заключение

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