Как запустить баш скрипт

Как запустить Bash скрипт в Linux

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

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

В этой статье мы расскажем о всех способах запуска скрипта Bash в Linux.

Подготовка

Прежде чем вы сможете запустить ваш скрипт, вам нужно, чтобы ваш скрипт был исполняемым. Чтобы сделать исполняемый скрипт в Linux, используйте команду chmod и присвойте файлу права execute . Вы можете использовать двоичную или символическую запись, чтобы сделать ее исполняемой.

$ chmod u+x script $ chmod 744 script

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

В некоторых дистрибутивах ваш файл будет выделен другим цветом, когда он исполняемый.

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

Запустить Bash скрипт из пути к скрипту

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

$ /path/to/script .

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

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

# Абсолютный путь $ /home/user/script # Абсолютный путь с аргументами $ /home/user/script "john" "jack" "jim"

Кроме того, вы можете указать относительный путь к скрипту Bash, который вы хотите запустить.

# Относительный путь $ ./script # Относительный путь с аргументами $ ./script "john" "jack" "jim"

Таким образом вы узнали, как легко запустить Bash-скрипт в своей системе.

Запустить Bash скрипт, используя bash

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

$ bash

Кроме того, вы можете использовать sh , если в вашем дистрибутиве установлена утилита sh .

В качестве примера, скажем, вы хотите запустить скрипт Bash с именем script . Чтобы выполнить его с помощью утилиты bash , вы должны выполнить следующую команду

$ bash script This is the output from your script!

Выполнить скрипт Bash, используя sh, zsh, dash

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

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

$ which sh /usr/bin/sh $ which dash /usr/bin/dash

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

Запуск скрипта Bash из любого места

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

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

$ export PATH=":$PATH"

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

$ script This is the output from script!

Кроме того, вы можете изменить переменную среды PATH в вашем файле .bashrc и использовать команду source для обновления вашей текущей среды Bash.

$ sudo nano ~/.bashrc export PATH=":$PATH"

Выйдите из файла и используйте команду source для файла bashrc для внесения изменений.

$ source ~/.bashrc $ echo $PATH /home/user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Отлично! Теперь ваш скрипт может быть запущен из любой точки вашей системы.

Запуск Bash скриптов из графического интерфейса

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

Чтобы запустить ваши скрипты с использованием GNOME, вы должны установить в проводнике Ask what to do для исполняемых файлов.

Закройте это окно и дважды щелкните файл скрипта, который вы хотите выполнить.

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

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

Успех! Ваш скрипт был успешно выполнен

Заключение

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

Учимся писать базовые скрипты в Unix и Linux

Если вы еще не умеете писать скрипты в системах Unix и Linux, эта статья познакомит с основами написания скриптов.

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

Идентификация оболочки.

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

Bash является одной из самых популярных оболочек, но существуют также zsh , csh , tcsh и korn . Есть даже оболочка под названием fish , которая может быть особенно полезна новичкам в Linux благодаря полезным параметрам автозаполнения команд. Чтобы определить, какую оболочку вы используете, используйте эту команду:

$ echo $SHELL /bin/bash

Вы также можете определить свою основную оболочку, просмотрев файл /etc/passwd :

$ grep $USER /etc/passwd nemo:x:1111:1111:Nemo the Fish:/home/nemo:/bin/bash
Один из способов определить, какие оболочки доступны в системе Linux, - это проверить файл /etc/shells .
$ more /etc/shells # /etc/shells: valid login shells /bin/sh /bin/dash /bin/bash /bin/rbash /bin/zsh /usr/bin/zsh /usr/bin/screen /usr/bin/tmux /usr/bin/fish
На выводе видно, что доступно всего девять оболочек.






Какую оболочку выбрать пользователю во многом зависит от того, что он привык использовать, поскольку большая часть синтаксиса в скриптах не представляет команды, которые вы найдете в /bin , /us /bin или /usr/local/bin . Вместо этого они являются частью самой оболочки и называются «встроенными». Сюда входят команды, используемые для цикла (например, for и while ).
Один из простых вариантов создания скриптов - использовать ту оболочку, которую вы используете в командной строке, поскольку, в конце концов, вам будет более или менее комфортно ее пользоваться.
Выбор оболочки
Чтобы определить, какая из доступных оболочек будет выполнять команды вашего скрипта, в первой строке вашего скрипта пропишите одну из строчек, приведенных ниже:
#!/bin/sh #!/bin/dash #!/bin/bash #!/bin/rbash #!/bin/zsh #!/usr/bin/zsh #!/usr/bin/screen #!/usr/bin/tmux #!/usr/bin/fish
Когда первая строка вашего скрипта идентифицирует оболочку, которая будет использоваться, эта оболочка будет выполнять команды в скрипте. Если вы не определите оболочку в первой строке в скрипте, то оболочка, которую вы используете при вызове сценария, будет той, которая его запускает.
Выполнение команд
Любую команду, которую вы запускаете в командной строке Linux, можно запустить в скрипте, если он совместим с указанной оболочкой. Используйте свой любимый текстовый редактор и вводите нужные для исполнения команды. Вот очень простой скрипт, который выводит текущую дату в формате день-месяц-год. Скрипт имеет название today .
#!/bin/bash date +”%d %B %Y”
Чтобы запустить этот скрипт, выполните команду:
$ today 15 April 2021
Добавление комментариев
Рекомендуется добавлять к скриптам комментарии, объясняющие, для чего предназначен скрипт, особенно если скрипт длинный или имеется сложный синтаксис. Просто начните комментарий со знака # . Комментарии могут быть отдельными строками или добавляться в конец команд в скрипте. Например:
#!/bin/bash # циклическое отображение даты/времени while true do echo -n “still running . ” date sleep 300 # sleep 5 minutes done
Делаем файл исполняемым
Чтобы сделать скрипт исполняемым, используйте команду chmod и убедитесь, что предполагаемые пользователи могут его запустить. Например:
$ chmod 700 scriptname # только вы сможете его запустить $ chmod 755 scriptname # запустить его смогут все
Если скрипт не сделан как исполняемый, его все равно можно запустить с помощью символа . Это встроенная функция, которая «выполняет» (т. е. читает и запускает) скрипт.
$ . today 08 April 2021
Использование команды if
Команда if позволяет вам проверять условия или переменные. В примере ниже мы проверяем, запускается ли скрипт в пятницу.
if [ date +”%A” == Friday ];then echo “TGIF!”; fi
Базовый синтаксис команды if - if value == other_value . Знак == выполняет сравнение, и необходимо убедиться, что оболочка видит по одному значению с каждой стороны оператора сравнения. По этой причине часто приходится заключать свои строки в кавычки.
Понятие переменных
Чтобы разобраться в понятии переменной важно понимать, что переменные назначаются одним способом, а на них ссылаются другим. Назначьте переменной только ее имя, но перед именем поставьте знак $ , чтобы ссылаться на нее.






$ date=11 $ echo $date 11
Запрос пользователя на ввод данных
Чтобы пользователь, во время исполнения скрипта, смог ввести некоторую информацию, вам необходимо вывести как подсказку, так и команду, чтобы прочитать, что вводит пользователь. Вы также должны присвоить переменной имя, которое имеет смысловое значение, как в этом примере. Обратите внимание, что использование команды echo -n означает, что пользователь вводит свой ответ в той же строке, что и приглашение.
echo -n “Сколько циклов “ read numloops
Человек, запускающий сценарий, увидит приглашение и введет ответ :
Сколько циклов? 11
Использование аргументов командной строки
Чтобы использовать аргументы, которые пользователь вводит вместе с именем скрипта, необходимо знать, как их идентифицировать. Аргументам скрипта будут присвоены имена $1 , $2 и так далее. Для любого аргумента, который вы собираетесь использовать неоднократно, вы можете рассмотреть возможность присвоения этих значений более значимым именам переменных.
$!/bin/bash if [[ $1 != [0-9]* ]]; then echo “Ошибка: $1 это не число” exit else loops=$1 fi
В этом случае мы проверяем, является ли первый предоставленный аргумент числовым, и закрываем скрипт, если это не так. Если ответ - число, то далее назначаем его переменной $loops , чтобы использовать позже в скрипте.
Еще одна полезная вещь, которую нужно сделать в скрипте, - это сначала проверить наличие аргументов. В противном случае синтаксис, подобный показанному выше, не сработает, потому что оболочка увидит выражение if [[! = [0-9] *]]; , что приведет к синтаксической ошибке.
Чтобы проверить правильность количества предоставленных аргументов, вы можете использовать синтаксис, подобный приведенному ниже, который проверяет, были ли предоставлены по крайней мере два аргумента, и, в противном случае, напоминает пользователю, что требуется как количество строк, так и имя файла:
#!/bin/bash if [ $# -lt 2 ]; then echo “Usage: $0 lines filename” exit 1 fi
Различные способы создания циклов
Есть несколько способов сделать цикл внутри скрипта. Используйте for , если вы хотите повторить действие заданное количество раз. Например:
#!/bin/bash for day in Sun Mon Tue Wed Thu Fri Sat do echo $day done
#!/bin/bash for letter in do echo $letter done
Используйте while , если хотите выполнять какое-то действие, пока условие существует или не существует.
#!/bin/bash n=1 while [ $n -le 4 ] do echo $n ((n++)) done
Использование оператора case
Операторы case позволяют вашим скриптам реагировать по-разному в зависимости от того, какие значения проверяются. В приведенном ниже скрипте используются разные команды для извлечения содержимого файла, предоставленного в качестве аргумента, путем определения типа файла.
#!/bin/bash if [ $# -eq 0 ]; then echo -n “myfile> “ read myfile else myfile=$1 fi if [ ! -f “$myfile” ]; then echo “Файл не найден: $myfile” exit fi case $myfilein *.tar) tar xf $myfile;; *.zip) unzip $myfile;; *.rar) rar x $myfile;; *) echo “Нет опций для извлечения $myfile” esac
Обратите внимание, что этот сценарий также запрашивает имя файла, если оно не было предоставлено, а затем проверяет, действительно ли указанный файл существует. Только после этого выполняется извлечение.
Реакция на ошибки
Вы можете обнаруживать ошибки в скриптах и реагировать на них и тем самым избегать других ошибок. Хитрость заключается в том, чтобы проверять выходные коды после запуска команд. Если код выхода имеет значение, отличное от нуля, произошла ошибка. В этом скрипте проверяется, запущен ли Apache, но отправляем результат проверки в /dev/null . Затем проверяем, не равен ли код выхода нулю, поскольку это означает, что команда ps не получила ответа. Если код выхода не равен нулю, сценарий сообщает пользователю, что Apache не запущен.
#!/bin/bash ps -ef | grep apache2 > /dev/null if [ $? != 0 ]; then echo Apache is not running exit fi
Аргументы командной строки Bash
Функциональность интерпретатора Bash позволяет работать не только со статистическими данными, записанными в скриптах. Иногда возникает необходимость добавить сценарию интерактивности, позволяя принимать внешние параметры скрипта для манипуляции ими в коде.






В этой статье будет рассмотрено, как принимать аргументы командной строки bash, способы его обработки, проверка опций, а также известные особенности при работе с ними.
Параметры скрипта Bash
Интерпретатор Bash присваивает специальным переменным все параметры, введённые в командной строке. В их состав включено название сценария, выполняемого интерпретатором. Такие переменные называются ещё числовыми переменными, так как в их названии содержится число:
Ниже приведён пример использования одного параметра скрипта Bash:
#!/bin/bash 
factorial=1 
for (( number = 1; number do 
factorial=$[ $factorial * $number ] 
done 
echo "Факториал числа $1 равен $factorial"
Результат работы кода:

Переменная $1 может использоваться в коде точно так же, как и любая другая. Скрипт автоматически присваивает ей значение из параметра командой строки — пользователю не нужно делать это вручную.
Если необходимо ввести дополнительные параметры, их следует разделить в командной строке пробелами.
#!/bin/bash 
total=$[ $1 * $2 ] 
echo "Первый параметр равен $1." 
echo "Второй параметр равен $2." 
echo "Произведение параметров равно $total."
Пример работы кода:

Командный интерпретатор присвоил числа 5 и 10 соответствующим переменным — $1 и $2.






Также параметрами могут быть и текстовые строки. Однако, если есть необходимость передать параметр, содержащий пробел (например имя и фамилию), его нужно заключить в одинарные или двойные кавычки, так как по умолчанию пробел служит разделителем параметров командной строки:
#!/bin/bash 
echo "Добро пожаловать, $1"
Пример работы кода:


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

Если необходимо использовать больше 9 параметров для скрипта, то названия переменных немного изменятся. Начиная с десятой переменной, число, стоящее после знака $, необходимо заключать в квадратные скобки (без внутренних пробелов):
#!/bin/bash 
total=$[ $[10] * $[11] ] 
echo "Десятый параметр равен $[10]" 
echo "Одиннадцатый параметр равен $[11]" 
echo "Произведение этих параметров равно $total"
Пример работы кода:

Получение названия скрипта Bash
Как уже упоминалось, имя сценария является самым первым параметром скрипта. Чтобы определить название программы, используется переменная $0. Такая необходимость возникает, например, при написании скрипта, который может выполнять несколько функций. Однако при этом возникает одна особенность, которую нужно учитывать на практике:
#!/bin/bash 
echo "Имя сценария: $0"
Пример работы кода:







Как видно, если строкой, фактически переданной в переменную $0, является весь путь к сценарию, то на вывод будет идти весь путь, а не только название программы.
Если нужен скрипт, выполняющий различные функции с учётом того, под каким именем он был вызван из командной строки, придётся проделать дополнительную работу: удалить сведения о пути, который использовался для его вызова.
Для этого специально предусмотрена небольшая команда. Команда basename возвращает только название скрипта без абсолютного или относительного пути к нему:
#!/bin/bash 
name=`basename $0` 
echo "Имя запущенной программы: $name"
Результат работы кода:

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

Чтобы предотвращать подобные ситуации, необходимо действовать на упреждение — проверять аргументы скрипта на наличие значений. Это настоятельная рекомендация при использовании параметров в командной строке, и только после ревизии стоит пускать их в дело:
#!/bin/bash 
if [ -n "$1" ] 
then 
echo "Добро пожаловать, $1" 
else 
echo "Простите, вы не представились" 
fi






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

В данном случае использовалась опция -n из предыдущей статьи о сравнении строк в Bash для проверки на наличие значения в переменной, которая считала параметр.
Обработка неизветсного числа параметров
Для начала рассмотрим один из часто используемых инструментов при работе с параметрами Bash — команду shift. Её прямое назначение заключается в сдвиге параметров на одну позицию влево. Таким образом, значение из переменной $3 переместится в $2, а из $2 — в $1. Но из $1 значение просто отбросится и не сместится в $0, так как там неизменно хранится название запущенной программы.
Эта команда является эффективным способом обработки всех параметров, переданных сценарию, особенно, когда нельзя заранее узнать их количество. Достаточно лишь обработать $1, сделать сдвиг и повторить процедуру.
#!/bin/bash 
count=1 
while [ -n "$1" ] 
do 
echo "Параметр №$count = $1" 
count=$[ $count + 1 ] 
shift 
done
Пример работы кода:

Этот скрипт выполняет цикл while, в условии которого указана проверка первого параметра на длину. И если она равна нулю, цикл прерывает свою работу. При положительном результате проверки команда shift сдвигает все параметры влево на одну позицию.
Ещё один вариант использование shift — смещать на несколько позиций. Для этого достаточно через пробел указать количество, на которое будет смещён ряд параметров скрипта.
#!/bin/bash 
echo "Первый параметр из переданных: $1" 
shift 2 
echo "Теперь первый параметр: $1"
Пример работы скрипта:








На заметку: при использовании shift нужно быть осторожным, ведь сдвинутые за пределы $1 параметры не восстанавливаются в период работы программы.

Обработка опций в Bash
Помимо параметров скрипт может принимать опции — значения, состоящие из одной буквы, перед которыми пишется дефис. Рассмотрим 3 метода работы с ними в скриптах. Сперва кажется, что при работе с опциями не должно возникать каких-либо сложностей. Они должны быть заданы после имени запускаемой программы, как и параметры. При необходимости можно сделать обработку опций командной строки по такому же принципу, как это делается с параметрами.
По примеру выше можно применять shift для обработки простых опций. С помощью инструкции case можно определять, являются ли аргументы Bash опциями:
#!/bin/bash 
while [ -n "$1" ] 
do 
case "$1" in 
-a | -b | -c) echo "Найдена опция $1" ;; 
*) echo "$1 не опция" ;; 
esac 
shift 
done
Пример работы программы:

Блок case работает правильно вне зависимости от того, как расположены аргументы командной строки bash.
Выводы
Для того, чтобы сделать свою программу более интерактивной, можно использовать параметры Bash. Встроенные переменные, в названиях которых фигурирует число, обозначают порядок указанных для программы параметров.
Команда basename используется для обрезания пути запущенного сценария, что часто необходимо для создания гибких программ. Использование команды shift позволяет эффективно проходить по переданным скрипту параметрам, особенно когда их количество неизвестно.
Bash-скрипты: начало
Сегодня поговорим о 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 Проверяет строки на равенство, возвращает истину, если строки идентичны. 
s tr1 != 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-программирования рассказать о том, как они добрались до вершин мастерства, поделиться секретами, а от тех, кто только что написал свой первый скрипт, ждём впечатлений.


Похожие публикации:

Bmf41425 abb как проверить
Charity engine что это за программа
Как вставить симкарту в айфон 11
Что такое отражение звука в физике