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

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

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

В системе GNU/Linux каждый объект является файлом. Это правило работает также для процессов ввода/вывода. Каждый файловый объект в системе обозначается дескриптором файла — неотрицательным числом, однозначно определяющим открытые в сеансе файлы. Один процесс может открыть до девяти дескрипторов.

В командном интерпретаторе Bash первые три дескриптора зарезервированы для специального назначения:

Их предназначение — обработка ввода/вывода в сценариях. По умолчанию стандартным потоком ввода является клавиатура, а вывода — терминал. Рассмотрим подробно последний.

Вывод в файл Bash

1. Перенаправление стандартного потока вывода

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

#!/bin/bash
echo "Строка 1"
echo "Промежуточная строка" > file
echo "Строка 2" > file

Как результат, "Строка 1" выводится в терминале, а в файл file записывается только "Строка 2":

Связано это с тем, что > перезаписывает файл новыми данными. Для того, чтобы дописать информацию в конец файла, используется два знака «больше» (>>).

#!/bin/bash
echo "Строка 1"
echo "Промежуточная строка" > file
echo "Строка 2" >> file

Здесь "Промежуточная строка" перезаписала предыдущее содержание file, а "Строка 2" дописалась в его конец.

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

#!/bin/bash
ls badfile > file2
echo "Строка 2" >> file2

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

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

2. Перенаправление потока ошибок

В командном интерпретаторе для обработки сообщений об ошибках предназначен дескриптор STDERR, который работает с ошибками, сформированными как от работы интерпретатора, так и самим скриптом.

По умолчанию STDERR указывает в то же место, что и STDOUT, хотя для них и предназначены разные дескрипторы. Но, как было показано в примере, использование перенаправления заставляет Bash разделить эти потоки.

Чтобы выполнить перенаправление вывода в файл Linux для ошибок, следует перед знаком«больше» указать дескриптор 2.

#!/bin/bash
ls badfile 2> errors
echo "Строка 1" > file3
echo "Строка 2" >> file3

В результате работы скрипта создан файл errors, в который записана ошибка выполнения команды ls, а в file3 записаны предназначенные строки. Таким образом, выполнение сценария не сопровождается выводом информации в терминал.

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

ls -lh test badtest 2> errors

Команда ls попыталась показать наличие файлов test и badtest. Первый присутствовал в текущем каталоге, а второй — нет. Но сообщение об ошибке было записано в отдельный файл.

Если возникает необходимость выполнить вывод команды в файл Linux, включая её стандартный поток вывода и ошибки, стоит использовать два символа перенаправления, перед которыми стоит указывать необходимый дескриптор.

ls -lh test test2 badtest 2> errors 1> output

Результат успешного выполнения записан в файл output, а сообщение об ошибке — в errors.

По желанию можно выводить и ошибки, и обычные данные в один файл, используя &>.

ls -lh test badtest &> output

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

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

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

#!/bin/bash
echo "Это сообщение об ошибке" >&2
echo "Это нормальное сообщение"

При выполнении программы обычно нельзя будет обнаружить отличия:

Вспомним, что GNU/Linux по умолчанию направляет вывод STDERR в STDOUT. Но если при выполнении скрипта будет перенаправлен поток ошибок, то Bash, как и полагается, разделит вывод.

Этот метод хорошо подходит для создания собственных сообщений об ошибках в сценариях.

Постоянные перенаправления в скриптах

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

#!/bin/bash
exec 1> testout
echo "Это тест перенаправления всего вывода"
echo "из скрипта в другой файл"
echo "без использования временного перенаправления"

Вызов команды exec запускает новый командный интерпретатор и перенаправляет стандартный вывод в файл testout.

Также существует возможность перенаправлять вывод (в том числе и ошибок) в произвольном участке сценария:

#!/bin/bash
exec 2> testerror
echo "Это начально скрипта"
echo "И это первые две строки"
exec 1> testout
echo "Вывод сценария перенаправлен"
echo "из с терминала в другой файл"
echo "но эта строка записана в файл ошибок" >&2

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

Выводы

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

Использование временного и постоянного перенаправлений в сценариях позволяет создавать собственные сообщения об ошибках для записи в отличное от STDOUT место.

В операционных системах GNU/Linux любые объекты системы являются файлами. И проверка существования файла bash - наиболее мощный и широко применяемый инструмент для определения и сравнения в командном интерпретаторе.

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

Проверка существования файла Bash

Начать стоит с простого и более общего метода. Параметр -e позволяет определить, существует ли указанный объект. Не имеет значения, является объект каталогом или файлом.

#!/bin/bash
# проверка существования каталога
if [ -e $HOME ]
then
echo "Каталог $HOME существует. Проверим наличие файла"
# проверка существования файла
if [ -e $HOME/testing ]
then
# если файл существует, добавить в него данные
echo "Строка для существующего файла" >> $HOME/testing
echo "Файл существует. В него дописаны данные."
else
# иначе — создать файл и сделать в нем новую запись
echo "Файл не существует, поэтому создается."
echo "Создание нового файла" > $HOME/testing
fi
else
echo "Простите, но у вас нет Домашнего каталога"
fi

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

Вначале команда test проверяет параметром -e, существует ли Домашний каталог пользователя, название которого хранится системой в переменной $HOME. При отрицательном результате скрипт завершит работу с выводом сообщения об этом. Если такой каталог обнаружен, параметр -е продолжает проверку. На этот раз ищет в $HOME файл testing. И если он есть, то в него дописывается информация, иначе он создастся, и в него запишется новая строка данных.

Проверка наличия файла

Проверка файла Bash на то, является ли данный объект файлом (то есть существует ли файл), выполняется с помощью параметра -f.

#!/bin/bash
if [ -f $HOME ]
then
echo "$HOME — это файл"
else
echo "$HOME — это не файл"
if [ -f $HOME/.bash_history ]
then
echo "А вот .bash_history — файл"
fi
fi

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

В сценарии проверяется, является ли $HOME файлом. Результат проверки отрицательный, после чего проверяется настоящий файл .bash_history, что уже возвращает истину.

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

Проверка файла на пустоту

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

#!/bin/bash
file=t15test
touch $file
if [ -s $file ]
then
echo "Файл $file содержит данные."
else
echo "Файл $file пустой."
fi
echo "Запись данных в $file..."
date > $file
if [ -s $file ]
then
echo "Файл $file содержит данные."
else
echo "Файл $file все еще пустой."
fi

Результат работы программы:

В этом скрипте файл создаётся командой touch, и при первой проверке на пустоту возвращается отрицательный результат. Затем в него записываются данные в виде команды date, после чего повторная проверка файла возвращает истину.

Выводы

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

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

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

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

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

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

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

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

set

Результат:

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

#!/bin/bash
echo "Информация о пользователе $USER:"
echo UID: $UID
echo Домашний каталог: $HOME

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

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

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

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

#!/bin/bash
echo "Неправильная цена вещи: $15"
echo "Правильная цена вещи: \$15"

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

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

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

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

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

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

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

var1=50
var2=-120
var3=test
var4="текстовая строка"


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

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

Выводы

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

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

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

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

Интерпретатор Bash присваивает специальным переменным все параметры, введённые в командной строке. В их состав включено название сценария, выполняемого интерпретатором. Такие переменные называются ещё числовыми переменными, так как в их названии содержится число:

• $0 — название сценария;
• $1 — первый параметр;
• ...
•  $9 — девятый параметр сценария.

Ниже приведён пример использования одного параметра скрипта Bash:

#!/bin/bash
factorial=1
for (( number = 1; 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, а также некоторые нюансы по использованию операций сравнения и решению часто встречающихся ошибок.

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

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

• = - равно, например if [ "$x" = "$y" ]
• == - синоним оператора "=", например  if [ "$x" == "$y" ]
• != - не равно, например if [ "$x" != "$y" ]

Пример:

#!/bin/bash
testuser=anton
if [ $USER = $testuser ]
then
echo "Добро пожаловать, $testuser"
fi


Результат работы сценария:

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

Некоторые особенности сравнения строк с шаблонами:

# возвращает истину, если строка, содержащаяся в $x, начинается с символа "y"
[[ $x == y* ]]
# возвращает истину, если строка из $x равна конкретно двум символам "y*"
[[ $x == "y*" ]]
# возвращает истину, если $x содержит название файла, содержащегося в текущем каталоге, которое начинается с "y"
[ $x == y* ]
# возвращает истину, если строка $x равна двум символам "y*"
[ "$x" == "y*" ]

Например проверка строки bash на то, начинается ли она с символа y:

#!/bin/bash
x=yandex
[[ $x == y* ]]
echo $?


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

Сценарий вывел 0 (ноль), так как мы потребовали вывести код ошибки последней выполненной инструкции. А код 0 означает, что сценарий выполнился без ошибок. И действительно — переменная $x содержит строку yandex, которая начинается с символа "y". В противном случае может писаться "1". Это довольно удобный способ отладки сценариев.

Сравнение строк по алфавиту на Bash

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

Во-первых, символы "больше" и "меньше" нужно экранировать, добавив перед ними обратный слэш (\), потому что в противном случае в командном интерпретаторе они будут расцениваться как символы перенаправления, а строки — как имена файлов. Это один из тех случаев, когда отследить ошибку достаточно сложно.

Пример:

#!/bin/bash
# неправильное использование операторов сравнения строк
val1=baseball
val2=hockey
if [ $val1 > $val2 ]
then
echo "$val1 больше, чем $val2"
else
echo "$val1 меньше, чем $val2"
fi


Что получится, если сравнить строки bash:

Как видно, один лишь символ "больше" в своём непосредственном виде привёл к неправильным результатам, хотя и не было сформировано никаких ошибок. В данном случае этот символ привёл к перенаправлению потока вывода, поэтому никаких синтаксических ошибок не было обнаружено и, как результат, был создан файл с именем hockey:

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

...
if [ $val1 \> $val2 ]
...


Тогда результат работы программы будет правильным:

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

#!/bin/bash
val1=Testing
val2=testing
if [ $val1 \> $val2 ]
then
echo "$val1 больше, чем $val2"
else
echo "$val1 меньше, чем $val2"
fi

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

В команде test строки с прописными буквами вначале будут предшествовать строкам со строчными буквами. Но если эти же данные записать в файл, к которому потом применить команду sort, то строки со строчными буквами будут идти раньше:

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

Проверка строки на пустое значение

Сравнение с помощью операторов -z и -n применяется для определения наличия содержимого в переменной. Таким образом, вы можете найти пустые строки bash. Пример:

#!/bin/bash
val1=testing
val2=''
# проверяет, не пустая ли строка
if [ -n $val1 ]
then
echo "Строка '$val1' не пустая"
else
echo "Строка '$val1' пустая"
fi
# проверяет, пустая ли строка
if [ -z $val2 ]
then
echo "Строка '$val2' пустая"
else
echo "Строка '$val2' не пустая"
fi
if [ -z $val3 ]
then
echo "Строка '$val3' пустая"
else
echo "Строка '$val3' не пустая"
fi

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

В этом примере создаются две строковые переменные — val1 и val2. Операция -n определяет, имеет ли переменная val1 ненулевую длину, а -z проверяет val2 и val3 на нулевую. Примечательно то, что последняя не была определена до момента сравнения, но интерпретатор считает, что её длина всё же равна нулю. Такой нюанс следует учитывать при различных проверках сценариев. И, если нет уверенности в том, какое значение содержится в переменной и задано ли оно вообще, стоит проверить её с помощью оператора -n или -z и лишь затем использовать по назначению.

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

...
if [ -n "$val1" ]
...

Выводы

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

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

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

Время шло, импровизированный “будильник” великолепно справлялся с задачей, хотя и оставался при этом не самым удобным в плане эксплуатации, все-таки для изменения его приходилось править конфиги, а команду на засыпание вводить в терминал напрямую. Так продолжалось почти год, но совсем недавно один знакомый, недавно перешедший на Ubuntu Linux, попросил рассказать ему о таком чудесном явлении, как командная строка и ее интерпретаторе bash. Поскольку обучение даже самым азам программирование в отрыве от практики по моему глубокому убеждению бесполезно, была написана написана статья, которую я представляю вашему вниманию.

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

Что такое Bash

Одной из самых интересных особенностей операционных систем на базе GNU/Linux является bash. Bash это интерпретатор командной строки, по сути, скриптовый язык программирования, на котором вполне возможно писать достаточно сложные программы, так называемы shell-скрипты или сценарии. Естественно, что на фоне более “серьезных” собратьев по семейству интерпретируемых языков, подобных java или python, функциональность bash  смотрится куда более бедно, но зато он плотно интегрирован в саму систему, а это означает, что значительно проще наладить взаимодействие между ним и многими системными утилитами.

Что нам необходимо

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

Инструменты:

• Bash - это, я думаю, понятно любому, интерпретатор командной строки, часть любого Linux - дистрибутива.
• rtcwake  - встроенный в ядро инструмент, позволяющий использовать драйвер для RTC (Real Time Clock), поддерживающий стандартные флаги для просыпания.
• cron - планировщик задач. Уже установлен в большинстве дистрибутивов.

Создание будильника на Bash

Для начала изготовим скрипт, представляющий собой сигнал будильника. Создаем папку wakeupdude (название строго индивидуально и отражает ваше чувство юмора (да, у меня все с ним плоховато) и серьезность отношения к поставленной задаче), в этой папке создаем файл alarm.sh.

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

#! /bin/bash

cromium-browser https://radio.yandex.ru/user/zmeigorynych3

Сохраняем. Открываем терминал в этой же папке и прописываем:

sudo chmod +x alarm.sh

Вообще, советую запомнить эту команду, поскольку она позволяет, используя терминал присвоить любому файлу любые права доступа ( “+x” означает, что файл отныне будет исполняемым).

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

Сигнал готов, теперь приступаем к написанию основного скрипта, который будет отвечать за “завод” нашего будильника. Сперва создаем в нашей папке файл wake.sh , в котором записываем следущее:


#! /bin/bash
#Задаем имя первой переменной, отвечающей за дату пробуждения
d=''
#просим ввести эту переменную ( текст внутри кавычек можно изменять по собственному желанию, однако, советую оставить подсказку в скобках, поскольку именно в таком формате необходимо вводить дату, почему объясню чуть ниже)
echo -n "В какой день вас разбудить? (гггг-мм-дд)"
#Просим компьютер считать введенную выше переменную
read d
#вводим следующую переменную,которая будет отвечать за час пробуждения согласно той же схеме
h=''
echo -n "В какой час вас разбудить? (чч)"
read h
# С третьей переменной, отвечающей за минуты пробуждения, будет немного сложнее, поскольку установить одновременно время пробуждения и время срабатывания нашего будильника мы не сможет (не сработает), нам нужно выполнить с ней простое арифметическое действие, поэтому наша следующая переменная должна быть целым числом, а не строкой, как остальные. В этом нам поможет команда declare -i. В остальном, действует точно так же, ка ки с предыдущими переменными.
declare -i m=''
echo -n "Во сколько минут избранного часа вас разбудить? (мм)"
read m
# как я писал выше, просто так взять и назначить время пробуждение и срабатывание будильника на одну и ту же минуту нельзя, поэтому мы укажем компьютеру, что срабатывание будильника должно быть через одну минуту после пробуждения.
declare -i z=0
z=$m+1
#По причине того, что я стремился упростить всю имеющуюся структуру и не усложнять ее лишними конструкциями, в ней имеется один довольно существенный баг: при установке переменной “m”, то есть минутпробуждения на 59, наш будильник не сработает.
#В следующих двух строках выводится отладочная информация, позволяющая еще раз взглянуть на данные, которые мы ввели и еще раз проверить их.
echo "$d $h:$m"
echo "$z"
#даем себе время проверить данные ( в примере 20 секунд)
sleep 20
#теперь преобразовываем  понятный нам формат даты в формат, который поймет rtcwake (помните, я говорил, что важно вводить данные именно так, как указано в шаблоне? Так вот, это именно потому, что следующая утилита по-другому их просто не воспримет)
u=$(date +%s -d "$d $h:$m")
#снова отладочная информация, нужная только для того, чтобы понять, что введенные нами данные распознаны успешно.
echo "$u"
#следующая команда вписываетв ремя пробуждение в cron. ВАЖНО!!! ПОМНИТЕ, ПРЕДАСТАВЛЕННАЯ НИЖЕ КОМАНДА СОСТАВЛЕНА ИМЕННО ТАК, ЧТОБЫ ПОЛНОСТЬЮ ПЕРЕПИСАТЬ СОДЕРЖИМОЕ CRONTAB.Это сделано для того, чтобы в нем не скапливалось огромное количество конфликтующих задач. Однако, если вы используете его для других задач, выполняемых, по расписанию, они будут затерты.
echo "DISPLAY=:0
$m $h * * *  /home/USERNAME/wakeupdude/alarm.sh" |crontab -
# естественно, что /home/USERNAME/wakeupdude/alarm.sh это путь к вашему файлу, в котором записан ваш сигнал.
#Ну и последняя часть - приказ компьютеру на засыпание.
sudo rtcwake -m mem -t $u
#При исполнении команды компьютер затребует пароль администратора, в принципе, это можно отключить через файл sudoers, но я не советую, поскольку дает нам возможность отказаться от выключения компьютера, если обстоятельства изменились.


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

В нужной папке создадим файл с расширением .desktop, откроем этот файл в редакторе, где и пропишем следующее:

[Desktop Entry]
Name=Будильник
Terminal=true
Icon=/путь/до/картинки/которая/нам/нравится.png
Exec=/путь/до/нашего/скрипта
Type=Application

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