Как сравнивать числа в оболочке bash в linux

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

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

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

С помощью значка обратного апострофа «

С помощью конструкции $()

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

mydir=

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

mydir=$(pwd)

1	mydir=$(pwd)

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

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

1
2
3

#!/bin/bash

mydir=$(pwd)

echo$mydir

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

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

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

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

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

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

#!/bin/bash
mydir=/home/likegeeks
if
then
echo «The $mydir directory exists»
cd $ mydir
ls
else
echo «The $mydir directory does not exist»
fi

1
2
3
4
5
6
7
8
9
10

#!/bin/bash

mydir=homelikegeeks

if-d$mydir

then

echo»The $mydir directory exists»

cd$mydir

ls
else

echo»The $mydir directory does not exist»

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

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

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

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

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

#!/bin/bash
val1=testing
val2=»»
# проверяет, не пустая ли строка
if
then
echo «Строка «$val1″ не пустая»
else
echo «Строка «$val1″ пустая»
fi
# проверяет, пустая ли строка
if
then
echo «Строка «$val2″ пустая»
else
echo «Строка «$val2″ не пустая»
fi
if
then
echo «Строка «$val3″ пустая»
else
echo «Строка «$val3″ не пустая»
fi

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

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

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

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

…
if
…

if

Условия Bash могут иметь разные формы. Самое основное утверждение принимает следующую форму:

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

Если оценивается как , выполняется. Если возвращается , ничего не происходит, игнорируется.

Как правило, рекомендуется всегда делать отступы для вашего кода и отделять блоки кода пустыми строками. Большинство людей предпочитают использовать отступы с 4 или 2 пробелами. Отступы и пустые строки делают ваш код более читабельным и упорядоченным.

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

Сохраните код в файле и запустите его из командной строки:

Скрипт предложит вам ввести номер. Например, если вы введете 15, команда выполнит оценку, потому что 15 больше 10, и команда внутри условия будет выполнена.

Тестовые операторы

В Bash команда принимает одну из следующих синтаксических форм:

Чтобы сделать скрипт переносимым, предпочтите использовать старую команду test, которая доступна во всех оболочках POSIX. Новая обновленная версия команды (двойные скобки) поддерживается в большинстве современных систем, использующих Bash, Zsh и Ksh в качестве оболочки по умолчанию.

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

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

— Истина, если длина больше нуля.
— Правда, если пусто.
— Правда, если и равны.
— Правда если и не равны.
— Правда, если и равны.
— Верно, если больше чем .
— Правда, если меньше, чем .
— Истинно, если равно или больше, чем INTEGER2.
— Верно, если равно или меньше чем .
— Истина, если существует и является символической ссылкой.
— Истинно, если существует и доступно для чтения.
— Истина, если существует и доступна для записи.
— True, если существует и является исполняемым.
— True, если существует и является каталогом.
— Истинно, если существует и является файлом, независимо от типа (узел, каталог, сокет и т. Д.).
— True, если существует и является обычным файлом (не каталогом или устройством).

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

оператор	что делает	пример
-eq	сравнить цифры в bash для равенства, возвращает 0, если равно	if then
-ge	сравнения чисел в bash, если больше или равно. Результат возвращает 0, если больше или равно	if then
-gt	сравнивает числа в bash, если больше.	if then
-le	сравнивает числа в bash, если меньше или равно.	if then
-lt	сравнивает числа в bash, если меньше.	if then
-ne	сравнивает числа в bash, если не равно или нет.	if then

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

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

# cat test.sh
#!/bin/bash
echo "введите значение переменной"
read a
echo "введите значение переменной"
read b
if 
then
echo "Возвращаемое значение:: $?"
echo "a и b равны"
else
echo "Возвращаемое значение:: $?"
echo "a и b не равны"
fi
#

Исполнение:

# sh test.sh
введите значение переменной
2
введите значение переменной
3
Возвращаемое значение:: 1
a и b не равны
# sh test.sh
введите значение переменной
2
введите значение переменной
2
Возвращаемое значение:: 0
a и b равны
#

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

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

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

# cat test1.sh
#!/bin/bash
#программа сравнения для -ge
echo "введите значение переменной"
read a
echo "введите значение для переменной b"
read b
if 
then
echo "возвращаемое значение:: $?"
echo "a больше или равно b"
else
echo "возвращаемое значение:: $?"
echo "a не больше или равно b"
fi
#

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

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

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

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

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

#программа сравнения для -le
b=5
echo "введите значение меньше или равно 5"
read a
if 
then
echo "все верно"
else
echo "не верно"
fi
#

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

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

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

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

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

# cat test5.sh
#!/bin/bash
#программа сравнения для -ne
b=0
echo "введите любое не нулевое значение"
read a
if 
then
echo "Отлично!!!"
else
echo "вы ввели нулевое значение"
fi
#

Исполнение:

	
# sh test5.sh
введите любое не нулевое значение
2
Отлично!!!
# sh test5.sh
введите любое не нулевое значение
0
вы ввели нулевое значение

Основные команды

Отображает руководства по командам. К примеру, последующая команда выдаст вам все данные о команде cat:

$ man cat

Команда интерпретатора Bash cat

Cчитывает файл, переданный в качестве аргумента, с выводом его содержимого по стандартному каналу вывода. При передаче нескольких файлов в виде аргумента происходит вывод конкатенированного содержимого всех файлов.

Команда интерпретатора Bash echo

Осуществляет вывод своих аргументов по стандартному каналу вывода.

$ echo Hello World
  Hello World

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

Команда интерпретатора Bash head

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

$ head -50 test.txt

Команда интерпретатора Bash tail

Работает аналогично head, однако читает строки с конца:

$ tail -50 test.txt

Дополнительно есть возможность просматривания добавляемых к файлу строк в режиме реального времени, используя флаг -f:

$ tail -f test.txt

Команда интерпретатора Bash less

Позволяет перемещаться куску текста либо переданному файлу в обоих направлениях.

$ less test.txt
$ ps aux | less

Кстати, о символе | мы расскажем ниже в блоке про команду интерпретатора Bash history.

Команды интерпретатора Bash true и false

Первая всегда возвращает ноль в качестве выходного статуса для индикации успеха, вторая, соответственно, не ноль в качестве выходного статуса для индикации неудачи.

$?

$? — это переменная, содержащая выходной статус последней запущенной команды. Выходной статус — код возврата программы. В нашем случае 0 будет означать успешное выполнение программы, а любое значение, которое больше нуля, будет отражать факт возникновения ошибок в процессе выполнения. Кстати, именно по этой причине в интерпретаторе Bash истиной (true) считается 0, а ложью (false) — всё, что не ноль.

$ true
$ echo $?
  
$ false
$ echo $?
  1

Команда интерпретатора Bash grep

Служит для поиска переданной строки в указанном файле:

$ cat users.txt
  user:student password:123
  user:teacher password:321
$ grep 'student` file1.txt
  user:student password:123

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

Команда интерпретатора Bash sed

Потоковый редактор, который преобразует входные текстовые данные. Используется для замены выражений следующим образом: s/regexp/replacement/g. К примеру, в следующем коде произойдёт замена всех слов «Hello» на «Hi»:

$ cat test.txt
  Hello World
$ sed 's/Hello/Hi/g' test.txt
  Hi World

Руководство по sed.

Команда интерпретатора Bash history

Выводит историю командной строки. Часто используется совместно с grep при поиске конкретной команды. В коде ниже будут найдены все команды, которые содержат строку g++:

$ history | grep g++
  155  g++ file1.txt
  159  g++ file2.txt

Кстати, здесь тоже можно увидеть символ | — это конвейер (pipe). С его помощью происходит перенаправление вывода одной команды на вход другой. Так, в вышеописанном примере вся история (в обычном режиме она выводится с помощью history непосредственно в вывод терминала), перенаправляется в grep в качестве входных данных. То есть мы не увидим вывод команды history, зато увидим вывод команды grep.

Команда интерпретатора Bash export

Устанавливает переменные окружения для их передачи дочерним процессам. Допустим, так мы можем передать переменную name, имеющую значение student:

$ export name=student

Команда интерпретатора Bash ps

Выводит данные о запущенных процессах.

$ ps
  PID TTY          TIME CMD
  35346 pts/2    00:00:00 bash

В результате выведутся 4 элемента:
— PID (ID процесса),
— TTY (тип терминала),
— TIME (время работы процесса),
— CMD (имя команды, запустившей процесс).

Закачивает файлы из интернета, помещая их в текущий каталог.

$ wget https://github.com/mikeizbicki/ucr-cs100

Команда интерпретатора Bash ping

Служит для тестирования сетевого подключения.

$ ping google.com
  PING google.com (74.125.224.34) 56(84) bytes of data.
  64 bytes from lax17s01-in-f2.1e100.net (74.125.224.34): icmp_req=1 ttl=57 time=7.82 ms
  --- google.com ping statistics ---
  1 packets transmitted, 1 received, % packet loss, time 8ms
  rtt min/avg/max/mdev = 7.794/8.422/10.792/0.699 ms

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

Статья написана специально для курса по Linux на основании материалов Bash-Cheatsheet.

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

Операторы сравнения – это операторы, которые сравнивают значения и возвращают 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 не разделяет переменные по «типу», переменные обрабатываются как целое число или строка в зависимости от контекста.

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

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

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

1
2
3
4

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

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

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

1
2
3
4
5

#!/bin/bash

ifpwd

then

echo»It works»

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

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

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

1
2
3
4
5
6

#!/bin/bash

user=likegeeks

ifgrep$useretcpasswd

then

echo»The user $user Exists»

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

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

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

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

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

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

1
2
3

#!/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»

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

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

echo «I have \$1 in my pocket»

1	echo»I have \$1 in my pocket»

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

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

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

#!/bin/bash
# неправильное использование операторов сравнения строк
val1=baseball
val2=hockey
if
then
else
fi

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

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

…
if
…

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

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

#!/bin/bash
val1=Testing
val2=testing
if
then
echo «$val1 больше, чем $val2»
else
echo «$val1 меньше, чем $val2»
fi

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

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

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

Переменные

Переменные в могут содержаться в 3х областях видимости:

Локальные переменные; Простая переменная внутри конкретного сценария. Например, определение переменной, доступ к значению и удаление:
Также, вы можете объявить локальную переменную внутри функции. Такая переменная будет доступна только внутри этой ф-ции:
Переменные окружения (подробнее); Этот тип переменных доступен любой программе (сценарию), которая запущена из данной оболочки. Разместить переменную в окружении можно командой :
Переменные оболочки; Это переменные имеют имена порядкового номера (, , ..) и содержат аргументы, переданные сценарию при запуске, например:

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

Механизм подстановки команды (заключенная в апострофы или круглые скобки команды вернет значение в переменную, завершающие символы новой строки удаляются):

Получить результат значение переменной в другую переменную:

Примечание

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

Арифметика:

Раскрытие фигурных скобок — это механизм, с помощью которого можно генерировать строки произвольного вида. Генерация строки по шаблону (фигурные скобки могут быть вложенными):

3 ответа

Лучший ответ

Вы можете использовать арифметическое расширение.

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

С его помощью вывести строку «true» или «false» немного сложнее. Обычно я использую то же самое, что и @Inian, но использую , потому что я обычно пишу в :

Но мы можем быть умными и сделать массив:

Но я не вижу никакой разницы, печатая только или .

KamilCuk
26 Ноя 2018 в 08:55

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

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

Таким образом, в вы делаете сравнение и вам нужно явно установить строки , что-то вроде

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

Также обратите внимание, что является расширением ключевого слова оболочки для доступной конструкции POSIX. Первый из них добавляется в оболочку Bourne Again и может не быть доступным в других POSIX-совместимых оболочках

Если вы ищете переносимый способ сделать это, используйте с конструкцией как

Inian
26 Ноя 2018 в 08:50

Я не думаю, что это можно сделать напрямую в bash.

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

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

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

Который буквально печатает код возврата ранее выполненной команды

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

В этом случае переменная одинакова.

Davide Spataro
26 Ноя 2018 в 08:49

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

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

= — равно, например if
== — синоним оператора «=», например if
!= — не равно, например if

Пример:

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

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

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

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

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

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

Цветной терминал (консоль) в Linux

В Debian 8 достаточно для root раскоментировать строки в /root/.bashrc

# You may uncomment the following lines if you want `ls' to be colorized:
export LS_OPTIONS='--color=auto'
eval "`dircolors`"
alias ls='ls $LS_OPTIONS'
alias ll='ls $LS_OPTIONS -l'
alias l='ls $LS_OPTIONS -lA'

Для пользовательской консоли включить force_color_prompt=yes в файле /home/<username>/.bashrc

Позиционные переменные (параметры запуска скрипта)

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

$0 … $9 — при запуске допускается не более 9 параметров передавать в скрипт. Переменная $0 является именем скрипта и путь к скрипту. Для получения только имени скрипта смотрите код ниже:

#!/bin/bash
 
echo
echo "# arguments called with ---->  ${@}     "
echo "# \$1 ---------------------->  $1       "
echo "# \$2 ---------------------->  $2       "
echo "# path to me --------------->  ${0}     "
echo "# parent path -------------->  ${0%/*}  "
echo "# my name ------------------>  ${0##*/} "
echo
exit

$# — количество параметров переданных скрипту
$? — код возврата программы. echo $? — вывести ошибку с которой закончил выполняться предыдущий скрипт (программа), например, выведет 0 (true) если имя пользователя root
```
test "root" = "$USER" ; echo $?
```
$* и $@ — все параметры командной строки. echo $* — выведет все значения параметров.
$! — PID программы, запущенной в background режиме.
$$ — PID процесса shell.

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

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

set -x — (set -o xtrace) показывать команды и параметры, которые выполняются;
set -v — (set -o verbose) печатает входные строки сразу по мере их считывания;
set -f — (set -o noglob) отключается генерация имени файла с помощью метасимволов (подстановка).

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

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

#!/bin/bash
clear

# включаем режим отладки
set -x
for i in 0 1 2 3 4
do
echo "Console number is $i" 
# выключаем режим отладки
set +x
done

exit 0

Массивы bash

#!/bin/bash
car=(bmw mers lada audi)

# вывести второй элемент массива
echo ${car}
# вывести все элементы массива
echo ${car}

Сравнение чисел

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

В качестве примера опробуем один из операторов сравнения

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

#!/bin/bash
val1=6
if
then
echo «The test value $val1 is greater than 5»
else
echo «The test value $val1 is not greater than 5»
fi

1
2
3
4
5
6
7
8

#!/bin/bash

val1=6

if$val1-gt5

then

echo»The test value $val1 is greater than 5″

else

echo»The test value $val1 is not greater than 5″

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

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

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

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

оператор	что делает	пример
-eq	сравнить цифры в bash для равенства, возвращает 0, если равно	if then
-ge	сравнения чисел в bash, если больше или равно. Результат возвращает 0, если больше или равно	if then
-gt	сравнивает числа в bash, если больше.	if then
-le	сравнивает числа в bash, если меньше или равно.	if then
-lt	сравнивает числа в bash, если меньше.	if then
-ne	сравнивает числа в bash, если не равно или нет.	if then

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

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

# cat test.sh
#!/bin/bash
echo «введите значение переменной»
read a
echo «введите значение переменной»
read b
if
then
echo «Возвращаемое значение:: $?»
echo «a и b равны»
else
echo «Возвращаемое значение:: $?»
echo «a и b не равны»
fi
#

Исполнение:

# sh test.sh
введите значение переменной
2
введите значение переменной
3
Возвращаемое значение:: 1
a и b не равны
# sh test.sh
введите значение переменной
2
введите значение переменной
2
Возвращаемое значение:: 0
a и b равны
#

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

# cat test1.sh
#!/bin/bash
#программа сравнения для -ge
echo «введите значение переменной»
read a
echo «введите значение для переменной b»
read b
if
then
echo «возвращаемое значение:: $?»
echo «a больше или равно b»
else
echo «возвращаемое значение:: $?»
echo «a не больше или равно b»
fi
#

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

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

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

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

#программа сравнения для -le
b=5
echo «введите значение меньше или равно 5»
read a
if
then
echo «все верно»
else
echo «не верно»
fi
#

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

Условие if-else применяется в скриптах BASH
очень часто. Само условие имеет несколько странный вид ]

Обратите внимание на отступы. Без них условие работать не будет

Привожу список логических операторов для условия ]:

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

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

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

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