Lt bash: Проверка условий в bash

Проверка условий в bash

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

Это немного подправленная выдержка из этой статьи.

Скобки

[ — является специальной встроенной командой test воспринимающей свои аргументы как выражение сравнения или файловую проверку […..].

[[ — расширенный вариант от «[«, является зарезервированным словом, а не командой, его bash выполняет как один элемент с кодом возврата. Внутри «[[….]]» разрешается выполнение операторов &&, || которые приводят к ошибке в обычных скобках «[….]» тем самым вариант с двойной скобкой более универсален.

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

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

-z – строка пуста

-n – строка не пуста

=, ( == ) – строки равны

!= – строки неравны

-eq – равно

-ne – неравно

-lt,(< ) – меньше

-le,(<=) – меньше или равно

-gt,(>) – больше

-ge,(>=) — больше или равно

! — отрицание логического выражения

-a,(&&) – логическое «И»

-o,(||) -логическое «ИЛИ»

Конструкции простой проверки if|then

1
2
3

if [[ condition ]]; then
commands
fi

Другими словами:

если проверяемое_выражение_или_команды_верны; то выполняем команды закрываем если

Пример 1

1
2
3
4

#!/bin/bash
if echo Тест; then 
echo 0 
fi

Часто встречается в скриптах проверка — «существует ли файлы или каталоги» на их примере покажу работу

Пример 2

1
2
3
4

#!/bin/bash 
if [ -f $HOME/.bashrc ]; then 
echo "Файл существует!"
fi

где:

$HOME/.bashrc – путь до файла
echo – печатает сообщение в консоль

Пример 3

1
2
3
4

#!/bin/bash
if [[ -f $HOME/.bashrc && -f /usr/bin/nano ]]; then 
echo "Все впорядке, можно редактировать!" 
fi

где:

&& — логическое «и», если первый путь «истина» проверяем второй, если он тоже «истина», то выполняем команды (echo)
-f – ключ проверки на существования файла (о них чуть ниже)

Конструкции простой проверки if|then|else

1
2
3
4
5

if [[ condition ]]; then 
    commands 1 
else 
    commands 2 
fi

другими словами:

если проверяемое_выражение_или_команды_верны; то команды 1 иначе команды 2 закрываем если

Пример 4

Возможно не лучший пример, нас интересует именно ответ 0 или 1. В результате печатается в консоль «Тест» и «0» потому что команда «echo Тест» успешна и это «истина».

1
2
3
4
5
6

#!/bin/bash 
if echo Тест; 
    then echo 0 
else 
    echo 1 
fi

Намерено допустите ошибку изменив echo, в результате получите «1» и сообщение о том что «команда echo не существует» и это «ложь».

1
2
3
4
5
6

#!/bin/bash 
if echo Тест; then 
    echo 0 
else 
    echo 1 
fi

Примеры «существуют ли файл?»

Пример 5

Если файл bashrc существует, то печатает в консоль «Файл существует!», иначе печатает «Файл не существует!»

1
2
3
4
5
6

#!/bin/bash 
if [ -f "$HOME/.bashrc" ]; then 
    echo "Файл существует!" 
else 
    echo "Файл не существует!" 
fi

Поиграйте с именем проверяемого файла

Пример 6

1
2
3
4
5
6

#!/bin/bash 
if [[ -f "$HOME/.bashrc" && -f "/usr/bin/nano" ]]; then 
    echo "Все в порядке, можно редактировать!" 
else 
    echo "Ошибка!" 
fi

Ключи к файлам и каталогам

[ -ключ “путь” ]
[ -e “путь каталогу_или_файлу”] – существует ли файл или каталог.

[ -r “путь к файлу/каталогу”] – доступен ли файл/каталог для чтения.

[ -f “путь к файлу/каталогу”] – существует ли файл.

[ -d “путь к каталогу”] – существует ли каталог.

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

Арифметика

Пример 7

Если оператор > использовать внутри [[….]], он рассматривается как оператор сравнения строк, а не чисел. Поэтому операторам > и < для сравнения чисел лучше заключить в круглые скобки.

Используем круглые скобки для математического сравнение. Если «3» меньше «6» печатаем «Да».

1
2
3
4

#!/bin/bash 
if (( 3 < 6));then 
    echo Да 
fi

Пример 8

Использование команды test, коей являются квадратные скобки. Если «3» меньше «6» печатаем «Да».

1
2
3

#!/bin/bash if [ 3 -lt 6 ]; then 
    echo Да 
fi

Можно использовать и двойные квадратные скобки, это расширенный вариант команды test, эквивалентом которой является «[ ]». Если «3» меньше «6» печатаем «Да».

1
2
3
4

#!/bin/bash 
if [[ 3 -lt 6 ]]; then 
    echo Да 
fi

Пример 9

Используем двойные квадратные скобки, потому что применяем оператор «&&». Если первое выражение 2 = 2 (истина) тогда выполняем второе, и если оно тоже 2=2 (истина), печатаем «Верно»

1
2
3
4
5
6
7
8

#!/bin/bash 
a="2" 
b="2" 
if [[ 2 = "$a" && 2 = "$b" ]] ; then 
    echo Верно 
else 
    echo Не верно 
fi

Если первое выражение 2 = 2 (истина) тогда выполняем второе, и если переменная «b» не равна двум (ложь), печатаем «Не верно»

1
2
3
4
5
6
7
8

#!/bin/bash 
a="2" 
b="3" 
if [[ 2 = "$a" && 2 = "$b" ]] ; then 
    echo Верно 
else 
    echo Не верно 
fi

Можно конечно сделать проще, нам главное понять принцип if|then и else, не стесняйтесь менять, подставляя свои значения.

Вложение нескольких проверок

Bash позволяет вкладывать в блок несколько блоков

1
2
3
4
5
6
7
8
9
10

#!/bin/bash 
if [[ condition 1 ]]; then 
    if [[ condition 2 ]]; then 
        command 1 
    else 
        command 2 
    fi 
else 
    command 3 
fi

Построения многоярусных конструкций

Для построения многоярусных конструкции, когда необходимо выполнять множество проверок лучше использовать elif — это краткая форма записи конструкции else if.

1
2
3
4
5
6
7
8
9

if [[ condition 1 ]]; then 
    command 1 
    command 2 
elif [[ condition 2 ]]; then 
    command 3 
    command 4 
else 
    command 5 
fi

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

При написании сценариев на 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 есть определённые нюансы, которые стоит понять для предотвращения ошибок работы сценариев. Но таких ситуаций на практике встречает много, поэтому запомнить все (и тем более, описать) не получится.

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

Оцените статью:

Загрузка…

Как сравнивать числа в оболочке Bash в Linux

В сценариях оболочки Bash мы можем выполнить сравнение чисел. Для выполнения операции сравнения чисел в Bash необходимо использовать состояние “test” в пределах if или loop. В этом посте мы расскажем вам, как сравнить числа в bash.

Операторы для Баш сравнения чисел

Примеры в деталях операторов сравнения числа в Bash:

1. оператор -eq

Этот оператор сравнивает числа, будет проверять значение равно или нет. Если оно равно, то возвращается 0.

Исполнение:

В приведенном выше примере мы взяли числа 2 и 3 в первый раз и система возвратила значение 1, однако, когда мы приняли одинаковые значения для а и б, переменная возвращает нулевое значение.

2. оператор -ge

Этот оператор сравнивает числа и проверяет значения на больше или равно. Если значение больше или равно, то он возвращаемое значение 0.

3. оператор -gt

Этот оператор сравнения чисел будет проверять число на большее. Если значение больше, то возвращает 0.

[root@destroyer ~]# cat test2.sh
#!/bin/bash
#программа сравнения для -gt
b=100
echo "введите значение больше 100"
read a
if [ $a -gt $b ]
then
echo "Очень хорошо"
else
echo "Не очень хорошо"
fi

4. оператор -le

Этот оператор сравнения числа будет проверять значения на меньше или равно. Если оно меньше или равно, то возвращаемое значение 0.

5. оператор -lt

Этот оператор сравнения числа будет проверять значения на меньшее. Если число меньше, то возвращаемое значение 0.

[root@destroyer ~]# cat test4.sh
#!/bin/bash
#программа сравнения для -lt
b=0
echo "введите число с минусом"
read a
if [ $a -lt $b ]
then
echo "Правильное число"
else
echo "Ввели не верное число"
fi
[root@destroyer ~]#

6. оператор -ne

Этот оператор сравнения числа будет проверять значения на не равно. Если числа не равны, то возвращаемое значение равно 0.

Исполнение:

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

BASH: Операции сравнения — Bash и скрипты — Каталог статей — Системный администратор г.Харьков

сравнение целых чисел

-eq

равно

if [ «$a» -eq «$b» ]

-ne

не равно

if [ «$a» -ne «$b» ]

-gt

больше

if [ «$a» -gt «$b» ]

-ge

больше или равно

if [ «$a» -ge «$b» ]

-lt

меньше

if [ «$a» -lt «$b» ]

-le

меньше или равно

if [ «$a» -le «$b» ]

<

меньше (внутри двойных круглых скобок )

((«$a» < «$b»))

<=

меньше или равно (внутри двойных круглых скобок)

((«$a» <= «$b»))

>

больше (внутри двойных круглых скобок)

((«$a» > «$b»))

>=

больше или равно (внутри двойных круглых скобок)

((«$a» >= «$b»))

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

=

равно

if [ «$a» = «$b» ]

==

равно

if [ «$a» == «$b» ]

Синоним оператора =.

[[ $a == z* ]] # истина, если $a начинается с символа "z" (сравнение по шаблону)
[[ $a == "z*" ]] # истина, если $a равна z*

[ $a == z* ] # имеют место подстановка имен файлов и разбиение на слова
[ "$a" == "z*" ] # истина, если $a равна z*

# Спасибо S.C.

 

!=

не равно

if [ «$a» != «$b» ]

Этот оператор используется при поиске по шаблону внутри [[ … ]].

<

меньше, в смысле величины ASCII-кодов

if [[ «$a» < «$b» ]]

if [ «$a» \< «$b» ]

Обратите внимание! Символ «<» необходимо экранировать внутри [ ].

>

больше, в смысле величины ASCII-кодов

if [[ «$a» > «$b» ]]

if [ «$a» \> «$b» ]

Обратите внимание! Символ «>» необходимо экранировать внутри [ ].

См. Пример 25-6 относительно применения этого оператора сравнения.

-z

строка «пустая», т.е. имеет нулевую длину

-n

строка не «пустая».

Оператор -n требует, чтобы строка была заключена в кавычки внутри квадратных скобок. Как правило, проверка строк, не заключенных в кавычки, оператором ! -z, или просто указание строки без кавычек внутри квадратных скобок (см. Пример 7-6), проходит нормально, однако это небезопасная, с точки зрения отказоустойчивости, практика. Всегда заключайте проверяемую строку в кавычки.

Пример 7-5. Операции сравнения

#!/bin/bash

a=4
b=5

# Здесь переменные "a" и "b" могут быть как целыми числами, так и строками.
# Здесь наблюдается некоторое размывание границ
#+ между целочисленными и строковыми переменными,
#+ поскольку переменные в Bash не имеют типов.

# Bash выполняет целочисленные операции над теми переменными,
#+ которые содержат только цифры
# Будьте внимательны!

echo

if [ "$a" -ne "$b" ]
then
 echo "$a не равно $b"
 echo "(целочисленное сравнение)"
fi

echo

if [ "$a" != "$b" ]
then
 echo "$a не равно $b."
 echo "(сравнение строк)"
 # "4" != "5"
 # ASCII 52 != ASCII 53
fi

# Оба варианта, "-ne" и "!=", работают правильно.

echo

exit 0

Пример 7-6. Проверка — является ли строка пустой

#!/bin/bash
# str-test.sh: Проверка пустых строк и строк, не заключенных в кавычки,

# Используется конструкция if [ ... ]


# Если строка не инициализирована, то она не имеет никакого определенного значения.
# Такое состояние называется "null" (пустая) (это не то же самое, что ноль).

if [ -n $string1 ] # $string1 не была объявлена или инициализирована.
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi
# Неверный результат.
# Выводится сообщение о том, что $string1 не пустая,
#+не смотря на то, что она не была инициализирована.


echo


# Попробуем еще раз.

if [ -n "$string1" ] # На этот раз, переменная $string1 заключена в кавычки.
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi # Внутри квадратных скобок заключайте строки в кавычки!


echo


if [ $string1 ] # Опустим оператор -n.
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi
# Все работает прекрасно.
# Квадратные скобки -- [ ], без посторонней помощи определяют, что строка пустая.
# Тем не менее, хорошим тоном считается заключать строки в кавычки ("$string1").
#
# Как указывает Stephane Chazelas,
# if [ $string 1 ] один аргумент "]"
# if [ "$string 1" ] два аргумента, пустая "$string1" и "]"



echo



string1=initialized

if [ $string1 ] # Опять, попробуем строку без ничего.
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi
# И снова получим верный результат.
# И опять-таки, лучше поместить строку в кавычки ("$string1"), поскольку...


string1="a = b"

if [ $string1 ] # И снова, попробуем строку без ничего..
then
 echo "Строка \"string1\" не пустая."
else
 echo "Строка \"string1\" пустая."
fi
# Строка без кавычек дает неверный результат!

exit 0
# Спвсибо Florian Wisser, за предупреждение.

Пример 7-7. zmost

#!/bin/bash

#Просмотр gz-файлов с помощью утилиты 'most'

NOARGS=65
NOTFOUND=66
NOTGZIP=67

if [ $# -eq 0 ] # то же, что и: if [ -z "$1" ]
# $1 должен существовать, но может быть пустым: zmost "" arg2 arg3
then
 echo "Порядок использования: `basename $0` filename" >&2
 # Сообщение об ошибке на stderr.
 exit $NOARGS
 # Код возврата 65 (код ошибки).
fi

filename=$1

if [ ! -f "$filename" ] # Кавычки необходимы на тот случай, если имя файла содержит пробелы.
then
 echo "Файл $filename не найден!" >&2
 # Сообщение об ошибке на stderr.
 exit $NOTFOUND
fi

if [ ${filename##*.} != "gz" ]
# Квадратные скобки нужны для выполнения подстановки значения переменной
then
 echo "Файл $1 не является gz-файлом!"
 exit $NOTGZIP
fi

zcat $1 | most

# Используется утилита 'most' (очень похожа на 'less').
# Последние версии 'most' могут просматривать сжатые файлы.
# Можно вставить 'more' или 'less', если пожелаете.


exit $? # Сценарий возвращает код возврата, полученный по конвейеру.
# На самом деле команда "exit $?" не является обязательной,
# так как работа скрипта завершится здесь в любом случае,

построение сложных условий проверки

-a

логическое И (and)

exp1 -a exp2 возвращает true, если оба выражения, и exp1, и exp2 истинны.

-o

логическое ИЛИ (or)

exp1 -o exp2 возвращает true, если хотябы одно из выражений, exp1 или exp2 истинно.

Они похожи на операторы Bash && и ||, употребляемые в двойных квадратных скобках.

[[ condition1 && condition2 ]]

Операторы -o и -a употребляются совместно с командой test или внутри одинарных квадратных скобок.

if [ "$exp1" -a "$exp2" ]

Чтобы увидеть эти операторы в действии, смотрите Пример 8-3 и Пример 25-11.

Источник: https://www.opennet.ru/docs/RUS/bash_scripting_guide/x2565.html

Как сравнить строки в Bash

При написании сценариев Bash вам часто нужно сравнивать две строки, чтобы проверить, равны они или нет. Две строки равны, если они имеют одинаковую длину и содержат одинаковую последовательность символов.

Эта статья описывает, как сравнивать строки в Bash.

Операторы сравнения

Операторы сравнения – это операторы, которые сравнивают значения и возвращают true или false. При сравнении строк в Bash вы можете использовать следующие операторы:

• string1 = string2 и string1 == string2- Оператор равенства возвращает true, если операнды равны.
  • Используйте =оператор с test командой [.
  • Используйте ==оператор с командой [[ для сопоставления с образцом.
• string1 != string2 – Оператор неравенства возвращает true, если операнды не равны.
• string1 =~ regex- Оператор регулярного выражения возвращает true, если левый операнд соответствует расширенному регулярному выражению справа.
• string1 > string2 – Оператор «больше чем» возвращает истину, если левый операнд больше правого, отсортированного по лексикографическому (алфавитному) порядку.
• string1 < string2 – Оператор less than возвращает true, если правый операнд больше правого, отсортированного по лексикографическому (алфавитному) порядку.
• -z string – Истина, если длина строки равна нулю.
• -n string – Истина, если длина строки не равна нулю.

Ниже следует отметить несколько моментов при сравнении строк:

• Пустое пространство должно быть использовано между бинарным оператором и операндами.
• Всегда используйте двойные кавычки вокруг имен переменных, чтобы избежать каких-либо проблем с разделением слов или сбоев.
• Bash не разделяет переменные по «типу», переменные обрабатываются как целое число или строка в зависимости от контекста.

Проверьте, равны ли две строки

В большинстве случаев при сравнении строк вы хотите проверить, равны ли строки или нет.

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

#!/bin/bash

VAR1="AndreyEx"
VAR2="AndreyEx"

if [ "$VAR1" = "$VAR2" ]; then
    echo "Строки равны."
else
    echo "Строки не равны."
fi

Когда скрипт выполнится, он выведет следующий вывод.

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

#!/bin/bash

read -p "Введите первую строку: " VAR1
read -p "Введите вторую строку: " VAR2

if [[ "$VAR1" == "$VAR2" ]]; then
    echo "Строки равны."
else
    echo "Строки не равны."
fi

Запустите скрипт и введите строки при появлении запроса:

Введите первую строку: AndreyEx
Введите вторую строку: Ubuntu
Строки не равны.

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

[[ "string1" == "string2" ]] && echo "Равны" || echo "Не равны"

Проверьте, содержит ли строка подстроку

Есть несколько способов проверить, содержит ли строка подстроку.

Один из подходов заключается в использовании подстроки с символами звездочки *, что означает совпадение всех символов.

#!/bin/bash

VAR='GNU / Linux - это операционная система'
if [[ $VAR == *"Linux"* ]]; then
  echo "Здесь присутствует"
fi

Скрипт отобразит следующее:

Здесь присутствует

Другой вариант – использовать оператор регулярного выражения =~, как показано ниже:

#!/bin/bash

VAR='GNU / Linux - это операционная система'
if [[ $VAR =~ .*Linux.* ]]; then
  echo "Здесь присутствует"
fi

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

Проверьте, пуста ли строка

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

#!/bin/bash

VAR=''
if [[ -z $VAR ]]; then
  echo "Строка пуста."
fi

#!/bin/bash

VAR=='AndreyEx'
if [[ -n $VAR ]]; then
  echo "Строка не пуста."
fi

Строка не пуста.

Сравнение строк с помощью оператора Case

Вместо использования тестовых операторов вы также можете использовать оператор case для сравнения строк:

#!/bin/bash

VAR="Arch Linux"

case $VAR in

  "Arch Linux")
    echo -n "AndreyEx matched"
    ;;

  Fedora | CentOS)
    echo -n "Red Hat"
    ;;
esac

Лексикографическое сравнение

Лексикографическое сравнение – это операция, в которой две строки сравниваются в алфавитном порядке путем сравнения символов в строке последовательно слева направо. Этот вид сравнения используется редко.

Следующие сценарии сравнивают две строки лексикографически:

#!/bin/bash

VAR1="AndreyEx"
VAR2="Ubuntu"

if [[ "$VAR1" > "$VAR2" ]]; then
    echo "${VAR1} лексикографически больше, чем ${VAR2}."
elif [[ "$VAR1" < "$VAR2" ]]; then
    echo "${VAR2} лексикографически больше, чем ${VAR1}."
else
    echo "Строки равны"
fi

Скрипт выведет следующее:

Ubuntu лексикографически больше, чем AndreyEx.

Заключение

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

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Циклы Bash | Losst

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

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

Содержание статьи:

Циклы Bash

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

• for — позволяет перебрать все элементы из массива или использует переменную-счетчик для определения количества повторений;
• while — цикл выполняется пока условие истинно;
• until — цикл выполняется пока условие ложно.

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

Цикл for

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

Цикл for имеет несколько синтаксисов и может вести себя по разному. Для перебора элементов списка удобно использовать такой синтаксис:

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

Каждый цикл for независимо от типа начинается с ключевого слова for. Дальше все зависит от типа. В этом случае после for указывается имя переменной, в которую будет сохранен каждый элемент списка, затем идет ключевое слово in и сам список. Команды, которые нужно выполнять в цикле размещаются между словами do и done.

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

vi for1.sh

!/bin/bash
for number in 1 2 3 4 5
do
echo $number
done

Дайте скрипту права на выполнение и запустите его:

chmod +x for1.sh
./for1.sh

Вы увидите, что все выполняется так, как и предполагалось. Программа выведет цифры от 1 до 5, которые мы перечислили в массиве. Вы можете передать циклу любой массив, например, вывод какой-либо другой команды:

!/bin/bash

for iface in $(ls /sys/class/net/)
do
echo $iface
done

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

Следующий тип цикла for похож на его реализацию в языках программирования Си и С++. Он состоит из трех частей, инициализатора счетчика, условия продолжения выполнения и действия над счетчиком. Вот синтаксис:

for ((счетчик=1; счетчик < 10; счетчик++))
do
команда1
команда2
done

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

!/bin/bash
for ((i=1; i < 10; i++))
do
echo $i
done

Результат странный, правда? Обратите внимание, как выполняется проверка условия. Значение счетчика сравнивается с эталоном. Действие с переменной счетчиком выполняется сразу же после завершения основного блока команд, а уже потом делается сравнение. Таким образом, у нас при первом выполнении i равно 1, а после него уже два 2. Теперь к завершению девятого прохода значение счетчика будет увеличено на единицу и станет 10. Условие сравнения 10 < 10 не верно, поэтому цикл дальше не выполняется.

С помощью этого же синтаксиса можно сделать бесконечные циклы bash linux:

!/bin/bash
for ((;;))
do
echo "Бесконечный цикл, нажмите CTRL+C для выхода"
done

Если необходимо, вы можете выйти из цикла преждевременно. Но так делать не рекомендуется. Для выхода используйте команду break:

!/bin/bash
for (i=1;i<10;i++)
do
echo Значение счетчика $i
if [[ i -gt 5]]
break
fi
done

Со циклами for мы завершили, теперь вы знаете как они выглядят и что с ними делать. Дальше мы рассмотрим циклы while и until. Они намного проще и более универсальны.

Цикл While

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

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

Это работает так: сначала выполняется проверка на правильность условия, если true, выполняется набор команд, затем снова выполняется проверка, и так пока условие не вернет отрицательный результат. Это нам тоже нужно сделать вручную. Рассмотрим пример:

vi while.sh

!/bin/bash
x=1
while [ $x -lt 5 ]
do
echo "Значение счетчика: $x"
x=$(( $x + 1 ))
done

Здесь сначала мы устанавливаем значение счетчика в единицу, затем, в условии сравниваем его с 5, пока счетчик меньше пяти будут выполняться команды из блока do-done. Но еще в этом блоке нам нужно увеличивать значение счетчика на единицу, что мы и делаем.

Также с помощью while мы можем прочитать несколько строк из стандартного ввода:

vi while.sh

!/bin/bash
hile read line
do
echo $line
done

Программа будет запрашивать новые строки пока вы не передадите ей символ конца файла с помощью сочетания клавиш Ctrl+D. Бесконечный цикл while bash с помощью while еще проще организовать:

vi while.sh

while :
do
echo "Бесконечный цикл bash, для выхода нажмите Ctrl+C"
done

Цикл until

Нам осталось рассмотреть последний цикл. Это цикл until. Он очень похож на while и отличается от него только работой условия. Если в первом нужно чтобы условие всегда было истинным, то здесь все наоборот. Цикл будет выполняться пока условие неверно. Синтаксис:

until [ условие ]
do
команда1
команда2
done

Думаю после рассмотрения реального примера со счетчиком будет намного понятнее как это работает:

!/bin/bash
count=1
until [ $count -gt 10 ]
do
echo "Значение счетчика: $count"
count=$(( $count + 1 ))
done

Мы задаем значение счетчика 1 и увеличиваем его на единицу при каждом проходе. Как только условие счетчик больше 10 выполнится, сразу цикл будет остановлен. В циклах while и until тоже можно использовать команды break и continue для выхода из цикла и завершения текущего прохода, но мы не будем это очень подробно рассматривать.

Выводы

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

Команда test. Категория: ОС Linux • Команды

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

test выражение

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

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

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

#!/bin/bash
if [ -f "$HOME/.bashrc" ]; then
    echo "Файл существует!"
else
    echo "Файл не существует!"
fi

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

• -z string — истина, если длина string равна нулю
• -n string — истина, если длина string не ноль
• string1 = string2 — истина, если строки равны
• string1 != string2 — истина, если строки не равны

Сравнение целых чисел

• число1 -eq число2 — истина, если число1 равно число2
• число1 -gt число2 — истина, если число1 больше число2
• число1 -ge число2 — истина, если число1 больше или равно число2
• число1 -lt число2 — истина, если число1 меньше число2
• число1 -le число2 — истина, если число1 меньше или равно число2
• число1 -ne число2 — истина, если число1 не равно число2

#!/bin/bash
if [ 3 -lt 6 ]; then
    echo "Истина"
else
    echo "Ложь"
fi

Операции AND и OR

• expr1 -a expr2 — истина, если оба выражения expr1 и expr2 истина (операция AND)
• expr1 -o expr2 — истина, если хотя бы одно из выражений expr1 или expr2 истина (операция OR)
• ! expr — истина, если выражение expr ложно

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

$ [ \( "$count" -ge 0 \) -a \( "$count" -lt 10 \) ]

«[[…]]» — расширенный вариант от «[…]», оболочка выполняет его как один элемент с кодом возврата. Внутри «[[…]]» разрешается выполнение операторов &&, || которые приводят к ошибке в обычных скобках «[…]».

#!/bin/bash
if [[ -f "$HOME/.bashrc" && -f "/usr/bin/nano" ]]; then
    echo "Все в порядке, можно редактировать!"
else
    echo "Ошибка!"
fi

Поиск:
Bash • CLI • Linux • test • Команда

Проект документации Linux

.

Проект документации Linux

.