Руководство по написанию скриптов в Linux Bash

Введение

Набор встроенных команд bash (и его аналогов sh, zsh, etc) совместим с любым POSIX-совместимым приложением в Linux, что позволяет встроить в ваш bash-скрипт любое совместимое приложение. Это дает очень большой набор возможностей в сфере автоматизации рутинных задач администрирования систем Linux, деплоя и сборки приложений, различных пакетных обработок, в том числе аудио и видео.

Командная строка — самый мощный пользовательский интерфейс из существующих на данный момент. Базовый уровень знаний получить достаточно просто. Рекомендуется изучить руководство bash. Это можно сделать, выполнив команду man bash.

Суть bash-скриптов — записать все ваши действия в один файл и выполнять их по необходимости.

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

Развертывание среды

Для выполнения скриптов, которые мы будем учиться писать, нужна среда. Если вы используете на своем компьютере систему Linux, вы можете делать все локально. Если Windows, — можете установить WSL/WSL2. Кроме того, вы можете создать виртуальный сервер и подключиться к нему по SSH. Так вы не навредите своему компьютеру если что-то пойдет не так.

Мы выбрали вариант создать виртуальную машину.  Залогинимся в личном кабинете https://my.selectel.ru/, нажав на вкладку «Облачная платформа». Там вы сможете создать виртуальный сервер.

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

Нажмем «Создать сервер». 

В разделе «Источник» убеждаемся, что выбран образ Ubuntu 20.04.

Конфигурацию можно настроить по своим потребностям.

В разделе «Сеть» стоит выбрать «Подсеть — Плавающий IP-адрес».

В разделе «Доступ» загрузите SSH-ключ и не забудьте сохранить root-пароль. Подробнее об этом рассказано в этой статье

Теперь можно создать сервер кнопкой «Создать» в самом низу.

Будет отображена страница статуса сервера, надо дождаться индикации ACTIVE вверху справа.

Теперь на вкладке «Порты» можно посмотреть IP-адрес, присвоенный серверу.

Не копируйте чужой код

Копирование чужого кода на свой компьютер/сервер опасно. Ранее существовал «патч Бармина», представляющий из себя команду rm -rf /*. Ее очень любили давать новичкам Linux на некоторых конференциях в качестве универсального средства от всех проблем. Суть команды — рекурсивное удаление всех каталогов внутри корневого каталога, т. е. всех системных и пользовательских файлов. Сейчас эта команда не сработает во всех актуальных версиях Linux, но раньше она служила злой шуткой и наказанием тем, кто копировал чужие скрипты на свои серверы и выполнял их. Способов навредить серверу/компьютеру все еще достаточно, но они не столь очевидны.

Выбор редактора

Вам потребуется удобный текстовый редактор. Если вы подключаетесь по SSH, то лучшим выбором будут 3 варианта:

• * vim (если умеете из него выходить)
• * nano (прост, удобен и надежен)
• * mcedit (входит в пакет mc, классический двухпанельный консольный файловый менеджер)

Если вы делаете все локально, выбор полностью на вас. Обычный выбор под Linux — gedit. В этой инструкции мы пользовались nano через SSH на удаленном сервере.

Запуск “Hello, World!”

Первая программа, которую обычно пишут программисты это «Hello, World!» —  простой вывод этой строки. Мы тоже с этого начнем. За вывод строки в консоль отвечает команда echo. Прямо в консоли вы можете напечатать echo «Hello, World!» и получить соответствующий вывод:

root@geneviev:~ # echo "Hello, World!"
Hello, World!

Сделаем это программой. Команда touch helloworld.sh создаст файл helloworld.sh. Команда nano helloworld.sh откроет этот файл для редактирования. Заполним файл нашей программой:

#!/bin/bash
echo "Hello, World!"

Для выхода с сохранением из nano надо нажать CTRL + O для сохранения (после чего нажать enter для перезаписи текущего открытого файла), а потом CTRL + X для выхода. Можно выходить без сохранения, при этом он спросит, точно ли вы хотите выйти без сохранения. Если да, надо нажать N для выхода без сохранения. Если вы нажмете Y, он спросит куда сохранить измененный файл, можно нажать enter для перезаписи редактируемого файла.

Разберем, что мы написали.

Первой строкой идет #!/bin/bash — фактически это указание на местоположение интерпретатора. Чтобы при запуске скрипта не требовалось указывать отдельно интерпретатор. Убедиться, что ваш bash интерпретатор лежит по этому пути можно через команду which bash:

root@geneviev:~ # which bash
/usr/bin/bash

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

Запустить ваш скрипт/команду можно двумя способами.

Способ №1: bash helloworld.sh. Вы вызываете интерпретатор и в аргументе передаете ему имя файла для исполнения.

root@geneviev:~ # bash helloworld.sh 
Hello, World!

Способ №2: Сначала надо разрешить системе исполнять скрипт: chmod +x helloworld.sh. Эта команда сделает файл исполняемым. Теперь вы можете запустить его как любой бинарный файл в linux: ./helloworld.sh. 

root@geneviev:~ # ./helloworld.sh 
Hello, World!

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

Аргументы

Это параметры, которые вы можете передать программе при ее вызове. Например, программа ping принимает в качестве обязательного аргумента IP-адрес или DNS-имя, которое требуется пропинговать: ping selectel.ru. Это простой и удобный способ общения пользователя с программой.

Давайте научим нашу программу принимать аргументы и работать с ними. Доступ к аргументам осуществляется через служебную команду $X где X это число. $0 — всегда имя исполняемого скрипта. $1 — первый аргумент, $2 — второй и так далее. Конечно, если вы планируете передавать пару десятков аргументов вашему приложению, это может быть несколько утомительно, так что вам понадобится что-то вроде этого цикла, чтобы перебрать все поступившие аргументы:

for var in "$@"; do
    echo "$var"
done

Подробнее про циклы будет рассказано в следующих разделах.

Пример, создадим новый файл: touch hellousername.sh. Выдаем права на исполнение chmod +x hellousername.sh.

Открываем nano hellousername.sh

Код примера следующий:

#!/bin/bash 

echo "Hello, $1!"

Сохраняем, закрываем. Смотрим, что получилось.

root@geneviev:~ # . /hellousername.sh Vasya
Hello, Vasya!

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

root@geneviev:~ # ./hellousername.sh 
Hello, !

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

Способ №1

#!/bin/bash
if [ "$#" -lt 1 ]; then
    echo "Недостаточно аргументов. Пожалуйста, передайте в качестве аргумента имя. Пример: $0 Vasya"
    exit 1
fi
echo "Hello, $1!"

Более подробно конструкцию if then [else] fi мы рассмотрим далее, пока не будем на ней останавливаться. Важно понимать, что тут проверяется. $# Это число аргументов без учета имени скрипта, который всегда $0.  

Способ №2

#!/bin/bash
if [ -z "$1" ]; then
   echo "Имя пустое или не передано. Пожалуйста, передайте в качестве аргумента имя. Пример: $0 Vasya"
   exit 1
fi

echo "Hello, $1!"

Здесь тоже используется конструкция if then [else] fi. Ключ -z в if используется для проверки переменной на пустую строку. Есть противоположный ключ -n, он проверяет что строка не пустая. Конечно, этот способ некорректно использовать для проверки входящих аргументов, но в теле самой программы он будет полезен. Например, чтобы проверить что выполненное в самой программе приложение что-то вернуло.

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

if-else

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

Возьмем один из примеров выше.

#!/bin/bash
if [ "$#" -lt 1 ]; then
    echo "Недостаточно аргументов. Пожалуйста, передайте в качестве аргумента имя. Пример: $0 Vasya"
    exit 1
fi
echo "Hello, $1!"

Происходит проверка системной переменной $# на то, что она меньше, чем (lower than, -lt) 1. Если это выражение истинно, мы переходим в блок команд, открывающийся ключевым словом then. Весь блок, начинающийся с if, должен завершаться ключевым словом fi. Более сложная структура ветвления может выглядеть примерно так:

if TEST-COMMAND1
then
  STATEMENTS1
elif TEST-COMMAND2
then
  STATEMENTS2
else
  STATEMENTS3
fi

Реальный пример:

#!/bin/bash
if [ "$#" -lt 1 ];
then
    echo "Недостаточно аргументов. Пожалуйста, передайте в качестве аргумента имя. Пример: $0 Vasya"
    exit 1
fi
if [ "$1" = "Vasya" ]; then
        echo "Whatsupp, Vasiliy?"
elif [ "$1" = "Masha" ];
then
        echo "Hey, Masha"
elif [ "$1" = "Michael" ];
then
        echo "Shalom, Michael"
else
        echo "Hi, $1"
fi

Вывод программы:

root@geneviev:~ # . /hellousername.sh Vasya
Whatsupp, Vasiliy?
root@geneviev:~ # ./hellousername.sh Masha
Hey, Masha
root@geneviev:~ # ./hellousername.sh Michael
Shalom, Michael
root@geneviev:~ # ./hellousername.sh Andrew
Hi, Andrew
root@geneviev:~ # ./hellousername.sh 
Недостаточно аргументов. Пожалуйста, передайте в качестве аргумента имя. Пример: ./hellousername.sh Vasya

Выражение «$1» = «Vasya» проверяет строки на идентичность. Блок после else выполняется только если выше не найден более подходящий блок.

&& и ||

В предыдущей главе вы могли заметить, что я использовал exit 1 для завершения работы программы в случае неуспешной проверки аргумента. Это означает, что программа завершилась с ошибкой. В bash есть операторы && и ||, которые используются для создания цепочек команд. Каждая цепочка зависит от результата выполнения предыдущей программы.

Пример 1: command1 && command2. В этом случае command2 выполнится, только если command1 завершится с кодом 0 (exit 0, по умолчанию). 

Пример 2: command1 || command2. В этом случае command2 выполнится, только если command1 завершится с кодом отличным от 0. 

Пример 3: command1 && command2 || command3. Если command1 завершится с кодом 0, то будет выполнен command2, иначе command3.

Переменные

Как гласит один из основных принципов программирования — Do Not Repeat Yourself (DRY). Вот и мы не будем повторять себя и перепишем предыдущий пример с использованием переменных, чтобы не вызывать echo каждый раз.

Переменные в bash создаются присваиванием: x=»foo bar» или z=$1. Переменной x мы присвоили строку @foo bar«, а переменной z мы присвоили значение первого аргумента. Использовать именованные переменные гораздо удобнее, чем использовать $1, особенно когда надо использовать его значение во многих местах.

К тому же, аргументы могут идти в разном порядке. Осмысленные названия переменных очень важны, при разрастании программы это снизит неизбежную путаницу. Избегайте имен переменных (и функций) вроде «a», «b», «zzzz», etc.

Чтобы не вызывать echo в каждом варианте с разными строками, разобьем строку на части. Первая часть будет приветствием. Вторая — именем. Третья — завершающим знаком препинания. Его можно не выносить в переменную.

#!/bin/bash

greetString="Hello"
nameString="stranger"

if [ "$#" -lt 1 ];
then
    echo "Недостаточно аргументов. Пожалуйста, передайте в качестве аргумента имя. Пример: $0 Vasya"
    exit 1
fi

if [ "$1" = "Vasya" ]; 
then
    nameString="Vasiliy"
	greetString="Whatsup"
elif [ "$1" = "Masha" ];
then
	nameString="Maria"
elif [ "$1" = "Michael" ];
then
	greetString="Shalom"
	nameString="Michael"
fi

echo "$greetString, $nameString!"

В этом примере мы создаем переменные greetString и nameString, которым присваиваем значения по умолчанию. В конце программа выводит значения этих двух переменных с помощью echo и форматированной строки (в двойных кавычках переменные раскрываются). Между этими действиями программа определяет, надо ли присваивать переменным другие значения.

Switch case

Использование if-else конструкции в нашем примере не является оптимальным вариантом. Мы всего лишь сверяем значение переменной с определенным набором значений. В такой ситуации лучшим выбором будет switch-case-конструкция.

case "$variable" in

 "$condition1" )
 command...
 ;;

 "$condition2" )
 command...
 ;;

esac

Перепишем нашу программу приветствий с использованием switch-case:

#!/bin/bash

name=$1

case "$name" in
  "Vasya" )
    nameString="Vasiliy"
	greetString="Whatsup"
  ;;
  "Masha" )
	greetString="Hey"
	nameString="Maria"
  ;;
  * )
	greetString="Hello"
	nameString="stranger"
  ;;
esac

echo "$greetString, $nameString!"

Циклы

Как и любой полноценный язык программирования, bash поддерживает циклы. Цикл for и цикл while. Циклы нужны, чтобы выполнять какой-то код заданное число раз. Например, при парсинге CSV перебирать построчно и каждую строку рассматривать отдельно.

Цикл for

Вот пример структуры цикла for:

for var in list
do
команды
done

Простой реальный пример:

#!/bin/bash

for name in Maria Vasya Michael stranger
do
	echo "Hello, $name!"
done

Вывод:

root@geneviev:~ # ./cycle.sh 
Hello, Maria!
Hello, Vasya!
Hello, Michael!
Hello, stranger!

Программа просто перебирает все имена, разделенные пробелом, и выводит их с помощью echo.

Попробуем немного усложнить пример:

#!/bin/bash
file=$1
for name in $(cat $file)
do 
	echo "Hello, $name!"
done

Создадим файл с именами touch names и запишем в него список имен для приветствия:

Maria
Vasiliy
Ivan
Nikolai
Innokentiy

Вывод:

root@geneviev:~ # . C. Это символ прерывания выполнения программы. В нашем случае мы вызвали программу без аргумента, и она вошла в вечный цикл. Можно сказать, зависла. Пришлось завершить ее принудительно. Не забывайте делать проверки входных данных в реальных программах.  Как это делать, можете посмотреть в главах if-else и switch case, например.  
В нашей программе есть небольшой баг. Модифицируем файл имен:
Erich Maria Remarque
Vasiliy
Ivan
Nikolai
Innokentiy
Запустим программу, получим вывод:
root@geneviev:~ # ./cycle.sh names
Hello, Erich!
Hello, Maria!
Hello, Remarque!
Hello, Vasiliy!
Hello, Ivan!
Hello, Nikolai!
Hello, Innokentiy!
Как говорится, «Кто все эти люди?». Так получается, потому что у нас не задана переменная окружения IFS (Internal Field Separator), указывающая на разделители полей. Наш цикл использует пробелы и переносы строки как разделители. В начале скрипта (после #!/bin/bash) укажите использовать перенос строки как разделитель полей: IFS=$’\n’.  
root@geneviev:~ # ./cycle.sh names 
Hello, Erich Maria Remarque!
Hello, Vasiliy!
Hello, Ivan!
Hello, Nikolai!
Hello, Innokentiy!
В итоге мы получим возможность работать со строками целиком. Это пригодится для парсинга CSV.
Обычно цикл for используется со счетчиком. В C-like стиле. Что-то вроде for (i=0;i<10;i++){}. В bash тоже так можно. 
#!/bin/bash
for (( i=1; i 
Цикл while
Схема организации цикла while:
while команда проверки условия
do
другие команды
done
Простой способ сделать бесконечную петлю (бесконечный цикл):
while true
	do
	echo "this is infinity loop"
done
Это может пригодится, например, когда вам нужно вызывать что-то чаще, чем позволяет cron (например, раз в минуту). Или когда вам просто надо проверять какое-то значение постоянно. Областей применения у бесконечных циклов много.
Здесь используются те же самые выражения, что и в if:
#!/bin/bash
count=0
while [ $count -lt 10 ]
do
	(( count++ ))
	echo "count: $count"
done
Вывод:
root@geneviev:~ # . /cycle.sh 
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
count: 7
count: 8
count: 9
count: 10
Из цикла можно выйти с помощью команды break (работает также и для for):
#!/bin/bash
count=0
while [ $count -lt 10 ]
do
	(( count++ ))
	echo "count: $count"
	if [ "$count" -gt 5 ]
	then
		break
	fi
done
Вывод:
root@geneviev:~ # ./cycle.sh 
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
Заключение
Несмотря на огромную конкуренцию в сфере автоматизации рутины со стороны python, ruby, perl bash не сдает позиции. Он прост в освоении и использовании, гибок и так или иначе присутствует в абсолютном большинстве дистрибутивов Linux.
В этой статье были приведены только основы написания программ на bash. Надеемся, вы нашли их полезными для себя.
Bash-скрипты: начало / Хабр
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 материалов. Если вы хотите продолжения прямо сейчас — вот список оригиналов этих материалов. Для удобства сюда включён и тот, перевод которого вы только что прочли.
Bash Script Step By Step — здесь речь идёт о том, как начать создание bash-скриптов, рассмотрено использование переменных, описаны условные конструкции, вычисления, сравнения чисел, строк, выяснение сведений о файлах.

Bash Scripting Part 2, Bash the awesome — тут раскрываются особенности работы с циклами for и while.

Bash Scripting Part 3, Parameters & options — этот материал посвящён параметрам командной строки и ключам, которые можно передавать скриптам, работе с данными, которые вводит пользователь, и которые можно читать из файлов.

Bash Scripting Part 4, Input & Output — здесь речь идёт о дескрипторах файлов и о работе с ними, о потоках ввода, вывода, ошибок, о перенаправлении вывода.

Bash Scripting Part 5, Sighals & Jobs — этот материал посвящён сигналам Linux, их обработке в скриптах, запуску сценариев по расписанию.

Bash Scripting Part 6, Functions — тут можно узнать о создании и использовании функций в скриптах, о разработке библиотек.

Bash Scripting Part 7, Using sed — эта статья посвящена работе с потоковым текстовым редактором sed.

Bash Scripting Part 8, Using awk — данный материал посвящён программированию на языке обработки данных awk.

Bash Scripting Part 9, Regular Expressions — тут можно почитать об использовании регулярных выражений в bash-скриптах.

Bash Scripting Part 10, Practical Examples — здесь приведены приёмы работы с сообщениями, которые можно отправлять пользователям, а так же методика мониторинга диска.

Bash Scripting Part 11, Expect Command — этот материал посвящён средству Expect, с помощью которого можно автоматизировать взаимодействие с интерактивными утилитами. В частности, здесь идёт речь об expect-скриптах и об их взаимодействии с bash-скриптами и другими программами.



 Полагаем, одно из ценных свойств этой серии статей заключается в том, что она, начинаясь с самого простого, подходящего для пользователей любого уровня, постепенно ведёт к довольно серьёзным темам, давая шанс всем желающим продвинуться в деле создания сценариев командной строки Linux.
Уважаемые читатели! Просим гуру bash-программирования рассказать о том, как они добрались до вершин мастерства, поделиться секретами, а от тех, кто только что написал свой первый скрипт, ждём впечатлений.
 Учебное пособие по написанию сценариев оболочки 
 Купите это руководство по созданию сценариев оболочки в формате PDF всего за 5 долларов США
 Цель этого руководства 
 Это руководство написано, чтобы помочь людям понять некоторые основы оболочки .
 скрипт  (он же  shell scripting  ) и, надеюсь, представить некоторые возможности простого, но
 мощное программирование, доступное в оболочке Bourne. Таким образом, было написано как
 основой для индивидуальных или групповых занятий и упражнений, а также в качестве справочного материала для последующих
 использовать.
 Получение самой последней версии этого руководства 
 Вы читаете Версия  4.4a  , последнее обновление  14 января 2023 г.  . 
 Самая последняя версия этого руководства всегда доступна по адресу:
 https://www.shellscript.sh.
 Всегда проверяйте там последнюю копию. (Если вы читаете это по какому-то другому адресу, вероятно, это копия настоящего сайта и, следовательно, может быть устаревшей).
 Краткая история sh 
 Стив Борн написал оригинальную оболочку Bourne, которая появилась в версии Unix Seventh Edition Bell Labs Research. Со временем появилось и исчезло множество вариантов (csh, ksh и т. д.). 
 Это руководство ограничивается совместимостью с оболочкой Bourne, чтобы обеспечить основу. В этом руководстве рассматриваются все основы написания сценариев оболочки. Раздел учебника «Примеры сценариев оболочки» содержит дополнительные примеры, в частности того, как оболочка Bash обеспечивает дополнительные полезные функции по сравнению со стандартной оболочкой Bourne.
 Аудитория 
 Этот учебник предполагает некоторый предыдущий опыт; а именно:
  Использование  интерактивной оболочки  Unix/Linux 
  Минимальные знания в области программирования  - использование переменных, функций, полезные фоновые знания
 Понимание  некоторых  команд Unix/Linux и  компетентность  в использовании  некоторых  из  более распространенных . ( LS ,  CP ,  ECHO  и т. Д.)
 Программисты  Ruby ,  Perl ,  Python ,  C ,  Pascal , или любой Programming (даже базовый. читать сценарии оболочки,
 но не чувствую, что они точно понимают, как они работают.
 Возможно, вы захотите просмотреть некоторые отзывы, которые получило это руководство, чтобы понять, насколько полезным оно может быть для вас.
 Типографские обозначения, используемые в этом руководстве 
 Значимые слова будут  курсивом  при упоминании
 первый раз.
 Сегменты кода и выходные данные скрипта будут отображаться как моноширинный текст. 
 Записям командной строки будет предшествовать знак доллара ($). Если ваше приглашение отличается,
 введите команду:
 PS1="$" ; экспорт PS1 
 Тогда ваши взаимодействия должны
 соответствуют приведенным примерам (например,  ./my-script.sh  ниже). 
 Вывод сценария (например, "Hello World" ниже) отображается в начале строки.
 $ echo '#!/bin/sh' > my-script.sh
$ echo 'эхо Hello World' >> my-script.sh
$ chmod 755 my-script.sh
$ ./my-script.sh
Привет, мир
$
 
 Целые скрипты будут отображаться на сером фоне и содержать ссылку на обычный текст скрипта, если он доступен:
 my-script. sh
 #!/bin/sh
# Это комментарий!
echo Hello World # Это тоже комментарий!
 
 Обратите внимание: чтобы сделать файл исполняемым, необходимо установить бит исполняемого файла, а для оболочки
 script, бит Readable также должен быть установлен:
 $ chmod a+rx my-script.sh
$ ./my-script.sh
 
 Далее: Философия
 Книги и электронные книги 
 Контакты 
 Вы можете отправить мне письмо с этой формой. Если вы ожидаете ответа, убедитесь, что указанный вами адрес действителен. Не забудьте включить простой дополнительный вопрос в конце формы, чтобы доказать, что вы реальный человек!
 Создание сценариев Bash для начинающих: полное руководство + примеры 
 ВПС
 04 января 2023 г.
 Leonardus N.
 13min Read
 Если вы когда-либо использовали операционную систему Linux, как и большинство виртуальных частных серверов, возможно, вы слышали о bash. Это оболочка Unix, которая читает и выполняет различные команды.
 Когда вам нужно запустить несколько команд bash, вам не нужно выполнять их вручную по одной за раз. Вместо этого можно создать файл сценария, содержащий функции bash для запуска этих команд.
 Это может показаться сложным, но, изучив его основы, вы поймете язык сценариев bash и узнаете, как он может помочь вашему рабочему процессу.
 В этой статье рассматривается процесс написания сценариев bash. Мы рассмотрим все, от команд bash до запуска программы bash на терминале Linux.
 Загрузить полную памятку по Bash
 Что такое Bash? 
 Bash, сокращение от  Bourne-Again Shell , представляет собой оболочку Unix и интерпретатор командного языка. Он читает команды оболочки и взаимодействует с операционной системой для их выполнения.
 Чтобы полностью понять сценарии оболочки bash, вам необходимо знать два понятия —  оболочка  и  сценарии  .
 Shell — это макропроцессор, использующий команды для взаимодействия с операционной системой. Это означает, что он может извлекать, обрабатывать и хранить информацию на компьютере.
 Между тем, скриптинг — это процесс компиляции команд оболочки в новый файл с помощью текстового редактора.
 Когда вы пишете bash в текстовом редакторе, вы компилируете  команд bash  или  функции bash  — набор команд, которые можно вызывать много раз, используя только имя функции. Затем текст сохраняется в виде исполняемого файла сценария  bash  с расширением  .sh .
 Зачем использовать сценарии Bash? 
 Сценарии Bash могут помочь в вашем рабочем процессе, поскольку они компилируют множество длинных команд в один исполняемый файл сценария.
 Например, если у вас есть несколько команд, которые нужно выполнить через определенный интервал времени, вы можете скомпилировать сценарий bash вместо того, чтобы вводить и выполнять команды вручную одну за другой. Вам нужно только выполнить файл сценария, когда это необходимо.
 Вот некоторые другие преимущества использования скриптов bash:
  Хорошо структурированные команды  — структурируйте команды в последовательности, чтобы каждый раз, когда вы запускаете скрипт, он выполнялся в правильном порядке.
  Автоматизация задач  — автоматизация выполнения скрипта в любое заданное время с помощью планировщика cron на основе времени.
  Прозрачность  — люди могут проверить содержимое сценария, поскольку он находится в читаемом текстовом файле. Однако если вы запускаете команды, используя другую программу, написанную на другом языке программирования, например C++, вам потребуется доступ к исходному коду.
  Transferable  — если вы переносите скрипт в другие дистрибутивы Linux, он все равно будет работать, при условии, что команды оболочки доступны в этой конкретной операционной системе.
 Pro Tip 
 В Linux есть руководство по работе с командной оболочкой bash. Он содержит описания всех технических терминов и стандартных переменных оболочки. Введите и выполните команду bash  man , чтобы отобразить руководство на терминале.
 Знакомство с командами Bash 
 Bash доступен почти во всех типах операционных систем на базе Unix и не требует отдельной установки. Вам понадобится командная строка Linux, также известная как терминал Linux. Это программа, содержащая оболочку и позволяющая выполнять сценарии bash.
 Используйте эту команду, чтобы проверить список доступных оболочек в вашей операционной системе Unix:
 cat /etc/shells 
 Вывод должен показать такой список:
 /bin/bash
/бин/ш
/bin/tcsh
/bin/csh 
 Каждый сценарий оболочки bash должен начинаться с  #! , за которым следует абсолютный путь к интерпретатору bash. Чтобы просмотреть путь, введите следующую команду:
 which bash 
 Должен получиться следующий вывод:
 /bin/bash 
 Это стандартный путь к интерпретатору bash в большинстве операционных систем Unix. Чтобы сообщить оболочке, что она должна выполнять команды с помощью интерпретатора bash, запустите сценарий с помощью этой строки:
 #!/bin/bash 
  Важно!  Если вы хотите запускать bash-скрипты на виртуальном частном сервере, подключитесь к нему через SSH-клиент.
 Следующим шагом является запись и компиляция команд в файл  .sh  с помощью текстового редактора. Вам понадобится текстовый редактор Unix, такой как VIM или GNU Nano. В этом уроке мы будем использовать  Текстовый редактор Nano , чтобы создать файл, введя следующую команду:
 nano function.sh 
 Это откроет новый файл  .sh  для редактирования. Начните с написания  #!/bin/bash , за которым следуют команды bash.
  Важно!  После завершения работы с текстовым редактором Nano нажмите  Ctrl+X , чтобы закрыть его, затем нажмите  Y  и  Введите , чтобы сохранить изменения.
 Основные команды Bash для вашего первого сценария Bash 
 Чтобы успешно создать свой первый сценарий bash, вам необходимо знать основные команды bash. Они являются основными элементами сценария, и вы должны знать, что они делают и как их правильно написать.
 В Linux существует множество команд bash. Для начала мы рассмотрим семь основных.
 Комментарии содержат описание определенных строк скрипта. Терминал не анализирует комментарии во время выполнения, поэтому они не повлияют на вывод.
 Есть два способа добавления комментариев к скрипту. Первый способ — набрать # в начале однострочного комментария.
 #!/бин/баш
#Command ниже печатает текст Hello World
эхо «Привет, мир!» 
 Второй метод заключается в использовании  :  с последующим  ‘  . Этот метод работает для многострочных комментариев.
 #!/бин/баш
прочитать
: ‘
Следующие команды печатают
Привет, мир!
‘
эхо «Привет, мир!»
 
 2.
 Переменные
 Переменные — это символы, представляющие символы, строки символов или числа. Вам нужно только ввести имя переменной в командной строке, чтобы использовать определенные строки или числа.
 Чтобы назначить переменную, введите имя переменной и строковое значение, как здесь:
 testvar=“Это тестовая переменная” 
 В этом случае  testvar  будет именем переменной, а  Это тест переменная  является строковым значением. При назначении переменной мы рекомендуем использовать имя переменной, которое легко запомнить и которое представляет ее значение.
 Чтобы прочитать значение переменной в командной строке, используйте символ  $  перед именем переменной. Взгляните на пример ниже:
 #!/bin/bash
testvar="Это тестовая переменная"
echo $testvar 
 Вторая командная строка использует  echo  для вывода значения  testvar  . Вывод этого сценария будет следующим:
 Это тестовая переменная 
 Давайте посмотрим, как вы можете ввести строковое значение, используя  чтение введите команду и заставьте скрипт сравнить два строковых значения из разных переменных:
 #!/bin/bash 
 echo «Введите число»  
 read a #Введенные пользователем данные в этой командной строке будут сохранены как переменная a 
 b=50 # Значение переменной b 
 if [[$a -eq $b]] 
 then 
 echo «Тот же номер» 
 else 
 echo «Другой номер» 
 fi 
 Вывод этого скрипта должен быть следующим:
 Enter номер 
 20 
 Другой номер 
 Обратите внимание, что  строка 3  — это значение, которое становится переменной  a .
 Скрипт сравнивает переменную  a  со значением  20  и переменную  b  со значением  50  . Поскольку значения разные, скрипт выводит  Различное число .
 Однако, если пользователь введет  50  , это будет вывод:
 Введите число 
 50 
 Тот же номер 
 В этом примере также используются условные операторы, которые мы обсудим позже.
 3. Команда echo 
  echo  — хорошо известная команда, используемая во многих языках программирования. Существуют различные параметры, которые вы можете использовать с эхом для печати вывода на терминале.
 Первое и наиболее распространенное использование команды echo — вывод стандартного текста:
 #!/bin/bash 
 echo «Привет, мир!» 
 Вывод этой команды:  Hello, World!  По умолчанию при использовании подобной команды echo терминал вводит новую строку под ней. Если вы хотите повторить вывод без новой строки, вы можете сделать это, используя -н  .
 #!/bin/bash 
 echo -n «Привет, мир!» 
 Используйте параметр  \n , чтобы ввести разрыв строки в вывод. Чтобы включить обратную косую черту  (\)  , вам необходимо включить  -e  .
 #!/bin/bash 
 echo -e «Привет, \nмир!» 
 Вывод этой команды будет выглядеть так:
 Привет, мир 
! 
 Параметр  \t  добавляет горизонтальную вкладку:
 #!/bin/bash 
 echo -e «\tHello, world!» 
 Вывод этой команды приведет к отступу текста вправо:
 Привет, мир! 
 Вы также можете комбинировать несколько вариантов. Например, объедините  \n  и  \t , чтобы разбить текст на строки и сделать отступ вправо:
 #!/bin/bash 
 echo -e «\n\tHello, \n\tworld!» 
 Вывод этой команды будет выглядеть следующим образом:
 Здравствуйте!
      мир! 
 4.
 Функции
 Функция объединяет набор команд в группу. Если вам нужно выполнить команду еще раз, просто напишите функцию вместо всего набора команд.
 Существует несколько способов записи функций.
 Первый способ — начать с имени функции, а затем поставить круглые скобки и квадратные скобки:
 имя_функции () { 
 первая команда 
 вторая команда 
 } 
 Или, если вы хотите написать это в одной строке:
 имя_функции () { первая команда; вторая команда; } 
 Второй способ записи функции заключается в использовании зарезервированного слова  function , за которым следует имя функции. Это устраняет необходимость в скобках:
 функция имя_функции { 
 первая команда 
 вторая команда 
 } 
 Этот метод также имеет однострочную версию:
 имя_функции { первая команда; вторая команда; } 
 Например, мы можем написать две функции с несколькими  echo  командами:
 #!/bin/bash 
 hello_world () { 
 echo "Hello, World!" 
 echo "Это тестовая функция" 
 } 
 print_message () { 
 echo "Давайте изучим программирование на bash" 
echo «Наслаждайтесь этим руководством» 
 } 
 Обратите внимание, что запись функций, как в приведенном выше примере, только определяет их и не выполняет содержащиеся в них команды. Чтобы выполнить функцию, введите ее имя в командную строку.
 Теперь давайте воспользуемся двумя приведенными выше примерами в полной функции bash, включая ее выполнение:
 #!/bin/bash 
 #Определить функцию приветствия, мира 
 hello_world () { 
 echo "Hello, World!" 
 echo «Это тестовая функция» 
 } 
 #Определить функцию печати сообщения 
 print_message () { 
 echo "Давайте изучим программирование на bash" 
 echo "Наслаждайтесь этим уроком" 
 } 
 #Выполнить функцию hello world 
 hello_world 
 #Выполнить функцию печати сообщения 
 print_message 
 Это результат работы скрипта выше :
 Привет, мир! 
 Это тестовая функция. 
 Давайте изучим программирование на bash. 
 Наслаждайтесь этим учебным пособием. В bash можно запустить их три типа — 9.0138 для  ,  пока  и  до  . 
 
 Цикл  for  запускает команду для списка элементов: 
 
 #!/bin/bash 
 для элемента в [списке] 
 do 
 [commands] 
 done 
 В следующем примере используется цикл  for  для печати всех дней недели:
 #!/bin/bash 
 для дней в Понедельник Вторник Среда Четверг Пятница Суббота Воскресенье 
 do 
 echo «Day: $days» 
 done 
 On  строка 2  ,  «дни»  автоматически становится переменной со значениями, являющимися названиями дней, которые следуют за ней. Затем в команде  echo  мы используем символ  $ для вызова значений переменных.
 Вывод этого скрипта будет следующим:
 День: Понедельник 
 День: Вторник 
 День: Среда 
 День: Четверг 
 День: Пятница 
 День: Суббота 
 День: Воскресенье 
 Обратите внимание, что даже с одной командой строка в скрипте цикла, она выводит семь  эхо  выходы.
 Следующий тип петли  а  . Скрипт будет оценивать условие. Если условие  true  , он будет продолжать выполнять команды до тех пор, пока вывод не перестанет соответствовать определенному условию.
 #!/bin/bash 
 while [условие] 
 do 
 [команды] 
 done 
 Давайте рассмотрим простой пример, включающий переменную и оператор приращения, обозначенный как  ((++))  :
 #!/бин/баш 
i=0 
 while [ $i -le 5 ] 
 do 
 echo $i 
 ((i++)) 
 done 
 Переменная начинается со значения  0 , и оператор приращения увеличит его на единицу. Набор условий меньше или равен пяти, поэтому команда будет повторять итерацию до тех пор, пока результат не достигнет пяти. Вывод этого сценария будет следующим:
 0 
 1 
 2 
 3 
 4 
 5 
 Последний тип цикла, от  до , противоположен , а . Команда будет повторяться до тех пор, пока условие не станет истинным.
 Если нам нужен тот же вывод, что и в приведенном выше примере , в то время как , используя цикл  до , мы можем написать такой скрипт:
 #!/bin/bash 
 i=0 
 until [ $i -gt 5 ] 
 do 
 echo $i 
 ((i++)) 
 done 
 Теперь эта команда будет выполняться до тех пор, пока выходное значение не достигнет пяти. Вывод будет таким же, как в нашем примере с циклом  while :
 0 
 1 
 2 
 3 
 4 
 5 
 6. Условные операторы 
 Многие языки программирования, включая bash, используют условные операторы, такие как  if  ,  then  и  else  для принятия решений. Они выполняют команды и распечатывают выходные данные в зависимости от условий.
 За оператором  if  следует условное выражение. После этого следует , затем  и команда для определения вывода условия. Скрипт выполнит команду, если условие, выраженное в , если утверждение  истинно.
 Однако, если вы хотите выполнить другую команду, если условие ложно, добавьте в сценарий оператор  else  и следуйте за ним командой.
 Давайте рассмотрим простые операторы  if  ,  then  и  else  . Перед оператором мы включим переменную, чтобы пользователь мог ввести значение:
 #!/bin/bash 
 echo «Введите число» 
 read num 
 if [[$num -gt 10]] 
 then 
 echo «Число больше 10» 
 else 
 echo «Число не больше 10» 
 7. Чтение и запись файлов 
 Существует несколько способов чтения файла, при этом команда  cat  является самый популярный. Обратите внимание, что эта команда считывает  всего содержимого файла .
 Чтобы прочитать содержимое построчно, используйте команду  read  и цикл. Прежде чем писать сценарий для чтения файла, сначала убедитесь, что файл существует.
 В следующем примере у нас есть файл  to-do.txt , содержащий список дел:
 Ответить по электронной почте 
 Завершить отчет 
 Звонить клиентам 
 Оценка команды 
 Мы будем использовать  cat  и  прочитайте  команд в нашей функции bash, чтобы прочитать и распечатать содержимое файла  to-do.txt . Первая часть скрипта будет использовать команду  cat , а вторая часть будет использовать команду  read  в цикле.
 #!/бин/баш 
 echo "Чтение файла с помощью команды cat" 
 content='cat to-do.txt' 
 echo $content 
 echo "Чтение файла с помощью команды чтения и цикла" 
 filename='to-do. txt' 
 во время чтения строка 
 do 
 echo $line 
 done<$filename 
 Вывод сценария будет следующим:
 Чтение файла с помощью команды cat 
 Ответ по электронной почте Завершить отчет Вызов клиентов Командная оценка 
 Чтение файла с помощью команды чтения и цикла 
 Ответить по электронной почте 
 Завершить отчет 
 Вызов клиентов 
 Оценка команды 
 Чтобы записать вывод команды в файл, используйте операторы перенаправления, представленные символами  >  и  >> , и после них укажите имя файла: 
 вывод > имя файла 
 вывод >> имя файла 
 Будьте внимательны при выборе оператора. Если файл существует, оператор  >  перезапишет его содержимое строкой нулевой длины. Это означает, что вы потеряете существующее содержимое файла. Если введенное имя файла не существует, оно будет создано.
 Оператор  >> , с другой стороны, добавит вывод в указанный файл.
 Вот простое перенаправление для записи вывода в текстовый файл:
 echo «Привет, мир!» >> hello_world.txt 
 Перенаправление также работает с командой  read  для записи любого пользовательского ввода. Этот пример скрипта добавит входное значение в файл  name.txt :
 #!/bin/bash 
 echo «Введите ваше имя» 
 read Name 
echo $Name >> name.txt 
 Поскольку сценарий перенаправляет вывод переменной в файл, вы не увидите никаких выводов. Чтобы просмотреть вывод путем печати содержимого файла, добавьте следующую командную строку для чтения файла:
 echo 'cat name.txt' 
 Убедитесь, что у вас есть разрешение на чтение и запись в файл, чтобы предотвратить разрешение . отклонена ошибка . Если вы хотите добавить выходные данные в существующие файлы, обязательно введите правильные имена файлов.
 4 простых функции, которые можно попробовать в вашем первом сценарии Bash 
 Теперь, когда мы знаем некоторые команды bash, мы рассмотрим более простые примеры функций bash для вашего первого сценария.
 Как упоминалось ранее, если вы хотите написать файл сценария bash, используйте команду nano filename.sh, чтобы создать и открыть файл  .sh  и начать писать свои функции bash. Не забудьте выйти и сохранить файл, когда закончите.
 Начните с простой эхо-функции 
 Начнем с простой эхо-функции. Начните с определения имени функции, за которым следует команда echo в следующей строке, как в примере ниже: 
 #!/бин/баш
тестовая функция () {
echo "Моя первая функция"
}
testfunction 
 Сохраните этот скрипт в  testFunction.sh  . Когда вы выполняете сценарий в командной строке, вы должны увидеть следующий вывод:
 Моя первая функция 
 Имейте в виду, что если вы поменяете позицию определения функции на вызов функции, это приведет к ошибке. Давайте посмотрим на пример ниже:
 #!/bin/bash 
 testfunction 
 testfunction(){ 
 echo «Моя первая функция» 
 } 
 Этот фрагмент не будет работать. Он вызывает функцию во второй командной строке и определяет функцию позже. В этом случае интерпретатор не может найти функцию при выполнении сценария, что приводит к ошибке  команда не найдена .
 Используйте несколько параметров 
 Функции Bash принимают любое количество параметров. Пример ниже принимает два параметра:
 #!/bin/bash 
 testfunction () { 
 echo $1 
 echo $2 
 } 
 testfunction "Hello" "World" 
  $1  представляет первый аргумент, а  $2  представляет второй аргумент в строке выполнения функции. Поскольку в качестве аргументов мы использовали  «Hello»  и  «World» , вывод будет выглядеть следующим образом:
 Вы также можете использовать аргументы командной строки и выполнять функции bash. Один из таких примеров показан ниже:
 #!/bin/bash 
 добавление () { 
 sum=$(($1+$2)) 
 return $sum 
 } 
 read -p "Введите число: " int1 
 read -p "Введите число:" int2 
 добавление $int1 $int2 
 echo "Результат: " $? 
 Добавление присваивается переменной  sum  , и это возвращается из функции. Функции Bash всегда возвращают одно единственное значение. Пользовательский ввод осуществляется с использованием , считываемого как  для обоих номеров. Наконец, результат выводится с использованием  $? , в котором хранится возвращаемое значение  $sum  из функции.
 Создание каталогов и изменение путей 
 Теперь давайте рассмотрим другой пример функции, в которой мы сначала создаем каталог, а затем меняем путь, чтобы он указывал на новое место. Эта функция будет содержать  mkdir  и  cd  Команды Linux для создания нового каталога и изменения текущего каталога:
 #!/bin/bash
примерФункция () {
mkdir -p $1
CD $1
}
sampleFunction myDir 
 Функция прочитает первый аргумент и создаст каталог с этим именем. После выполнения скрипта проверьте текущий рабочий путь с помощью команды  pwd  на терминале. Вы увидите, что в настоящее время находитесь во вновь созданном  myDir .
 Объединение циклов и условий 
 Циклы и условные операторы также популярны в сценариях bash. Мы рассмотрим несколько случаев использования обоих в одном скрипте:
 #!/bin/bash 
 isvalid=true 
 count=1 
 while [ $isvalid ] 
 do 
 echo $count 
 if [ $count - ур. 5]; 
 then 
 break 
 fi 
 ((count++)) 
 done 
 В приведенном выше примере используется , тогда как  и  if  операторов. Это выполняет цикл  while  пять раз после проверки условного оператора.
 Вывод этого сценария будет следующим:
 1 
 2 
 3 
 4 
 5 
 Цикл  для  может увеличивать и уменьшать счетчики. Пример цикла  for  показан ниже:
 #!/bin/bash 
 for (( count=10; count>0; count-- )) 
 do 
 echo -n "$count" 
 done 
 Результатом этого цикла for должно быть:
 10 9 8 7 6 5 4 3 2 1 
 С операторами  if  мы также можем определить  else if  с помощью инструкции  elif :
 #!/bin/bash 
 echo "Введите допустимое число" 
 прочитать n 
 if [ $n -eq 101 ]; 
 затем 
 echo "Это первое число" 
 elif [ $n -eq 510 ]; 
 затем 
 echo "Это второе число" 
 elif [ $n -eq 999 ]; 
 затем 
 echo "Это третье число" 
 else 
 echo "Здесь нет чисел" 
 fi 
 Мы также можем написать этот сценарий, используя оператор  case . В случае   заявлений,  ;;  представляет разрыв регистра, поэтому, если значение переменной соответствует любому из условий, оно переходит в конец скрипта:
 #!/bin/bash 
 echo "Введите допустимое число" 
 read n 
 case $n in 
 101) 
 echo "Это первое число" ;; 
 510) 
 echo "Это второе число" ;; 
 999) 
 echo "Это третье число" ;; 
 *) 
 echo "Здесь нет номеров" ;; 
 esac 
 Как запустить скрипт Bash 
 Теперь, когда мы написали скрипт bash, давайте научимся запускать его из терминала. Есть три способа сделать это – с помощью  bash  с помощью команды  ./  и запуска сценария из другого каталога.
 Использование команды Bash 
 Первый способ заключается в использовании команды  bash  из соответствующего каталога. Например, у вас может быть bash-скрипт  function.sh , содержащий простые эхо-функции в каталоге  Test/Bash . Сначала вы должны открыть каталог с помощью этой команды:
 cd Test/Bash 
 Затем выполните следующие  bash  команда для запуска сценария bash:
 bash function.sh 
 Вы должны увидеть следующий вывод:
 Если вы попытаетесь запустить сценарий без команды  bash , вы получите команду  not найдено сообщение об ошибке .
 Использование команды ./ 
 Вы можете запустить сценарий bash без команды  bash . Однако вы должны установить для файла разрешение  выполнить , используя следующую команду из соответствующего каталога:
 chmod +x function.sh 
 Эта команда изменяет права доступа к файлу, чтобы каждый мог выполнить этот файл. После того, как вы это сделаете, выполните сценарий bash с помощью этой команды:
 ./function.sh 
 Если вы не установите разрешение правильно, терминал напечатает сообщение об ошибке  Отказано в доступе :
 Like команда  bash , вы также получите ошибку  command not found , если вы не используете  . /  в своей команде.
 Запустить сценарий из другого каталога 
 Другой вариант — запустить сценарий из другого каталога. После создания сценария bash используйте команду  pwd , чтобы найти текущий каталог. Как только вы узнаете путь, вы можете запустить скрипт из любого каталога. Например, для запуска  function.sh  из домашнего каталога используйте следующую команду: каталога, в котором вы находитесь.
 Заключение 
 Bash читает команды оболочки и взаимодействует с операционной системой для их выполнения. Замечательным аспектом bash является то, что вы можете скомпилировать множество команд и функций bash в один исполняемый скрипт, что поможет вам оптимизировать рабочий процесс.
 Чтобы создать файл сценария bash, необходимо понимать различные команды оболочки и их правильный синтаксис. В этом руководстве мы рассмотрели семь основных команд:
 Комментарии
 Переменные
 Эхо
 Функции
 Петли
 Условные операторы
 Чтение и запись файлов
 Однако, если вы хотите использовать весь потенциал bash, нужно еще многому научиться. Попрактикуйтесь на приведенных нами примерах и продолжайте изучать bash, чтобы вы могли писать более качественные и эффективные сценарии.
 Мы рассмотрели три способа выполнения сценария bash. Если у вас есть какие-либо вопросы или комментарии, оставьте их в разделе ниже.
 Ищете другие руководства по bash? 
 Руководство для начинающих по Bash Array 
 25 Распространенные примеры сценариев Bash для Linux
 Часто задаваемые вопросы по учебному пособию по Bash 
 Легко ли выучить Bash? 
 Bash довольно прост в освоении: многие учащиеся осваивают как базовые, так и расширенные команды примерно за полгода.
 Bash проще, чем Python? 
 Нет, Python остается проще и проще, чем Bash. Поскольку Bash изначально был программной заменой оболочки Bourne, написать Bash по-прежнему сложно по сравнению с Python. Python также более мощный, чем Bash.
 Для чего используется Bash? 
 Bash чаще всего используется для автоматизации задач разработки, таких как компиляция кода, отладка, управление изменениями и тестирование.
This entry was posted in Популярное