Синонимом команды test являются

7.1. ����������� ��������
�������

• �������� if/then ��������� — �������� ��
  ��� ���������� ������
  ������ 0 (��������� 0 �������� «�����»), � ���� ��� ���,
  �� ��������� ����, ��� �����, ������, ��������� �� ������
  then.

• ���������� ����������� ������� — [ (����� ���������� ������).
  ��� �������� ��������� ������� test, � �������� ���������� �������� (�.�.
  ����� �����������, � ������ ������������������). ���
  ������� ������������ ���� ��������� ��� ��������� ���������
  ��� ��� �������� �������� � ���������� ��� ���������� �
  ������������ � ������������ �������� (0 — ������, 1 —
  ����).

• ������� � ������ 2.02, Bash ������������� � ������������
  ������������ ����������� [[ … ]] ����������� ������� �������
  test, ������� ��������� ��������� ��������
  ����� �������� �������������, ������� �� ������ ������
  ����������������. �������� ��������: [[ — ��� ����������������� �����,
  � �� �������.

  Bash ��������� [[ $a -lt $b ]]
  ��� ���� �������, ������� ����� ��� ��������.

  ������� ������ (( … )) � ����������� let … ��� �� ���������� ���
  0, ���� �����������
  ��������������� ��������� �������� ��������� ��������.
  ����� �������, ��������������
  ��������� ����� ������������ � ��������� ���������.

  ����������� let "1<2" ���������� 0 (��� ��� ��������� ��������� "1<2" -- "1", ��� "������")
  (( 0 && 1 )) ���������� 1 (��� ��� ��������� �������� "0 && 1" -- "0", ��� "����")
  

• �������� �������� if ��������� ��� ���������� �����
  �������, � �� ������ ��������� ���������, ������������ �
  ���������� ������.

  if cmp a b &> /dev/null  # ���������� ������.
  then echo "����� a � b ���������."
  else echo "����� a � b ����� ��������."
  fi
  
  if grep -q Bash file
  then echo "���� ��������, ��� �������, ���� ����� Bash."
  fi
  
  if COMMAND_WHOSE_EXIT_STATUS_IS_0_UNLESS_ERROR_OCCURRED
  then echo "������� ��������� �������."
  else echo "���������� ������ ��� ���������� �������."
  fi
  

• �������� if/then ��������� �������
  ��������� ��������.

  if echo "��������� *if* ��������� ������ ������� *if*."
  
    if [[ $comparison = "integer" ]]
      then (( a < b ))
    else
      [[ $a < $b ]]
    fi
  
  then
    echo '$a ������ $b'
  fi
  

  ��� ��������� �������� ����������� «if-test» �������
  ������������� Stephane Chazelas.

#!/bin/bash

echo

echo "����������� "0""
if [ 0 ]      # ����
then
  echo "0 -- ��� ������."
else
  echo "0 -- ��� ����."
fi            # 0 -- ��� ������.

echo

echo "����������� "1""
if [ 1 ]      # �������
then
  echo "1 -- ��� ������."
else
  echo "1 -- ��� ����."
fi            # 1 -- ��� ������.

echo

echo "Testing "-1""
if [ -1 ]     # ����� ����
then
  echo "-1 -- ��� ������."
else
  echo "-1 -- ��� ����."
fi            # -1 -- ��� ������.

echo

echo "����������� "NULL""
if [ ]        # NULL (������ �������)
then
  echo "NULL -- ��� ������."
else
  echo "NULL -- ��� ����."
fi            # NULL -- ��� ����.

echo

echo "����������� "xyz""
if [ xyz ]    # ������
then
  echo "��������� ������ -- ��� ������."
else
  echo "��������� ������ -- ��� ����."
fi            # ��������� ������ -- ��� ������.

echo

echo "����������� "$xyz""
if [ $xyz ]   # ��������, ���� $xyz ��� null, ��...
              # ������ ��� �������������������� ����������.
then
  echo "�������������������� ���������� -- ��� ������."
else
  echo "�������������������� ���������� -- ��� ����."
fi            # �������������������� ���������� -- ��� ����.

echo

echo "����������� "-n $xyz""
if [ -n "$xyz" ]            # ����� ���������� �������.
then
  echo "�������������������� ���������� -- ��� ������."
else
  echo "�������������������� ���������� -- ��� ����."
fi            # �������������������� ���������� -- ��� ����.

echo


xyz=          # ���������������� ������ ���������.

echo "����������� "-n $xyz""
if [ -n "$xyz" ]
then
  echo "������ ���������� -- ��� ������."
else
  echo "������ ���������� -- ��� ����."
fi            # ������ ���������� -- ��� ����.


echo


# ����� "����" �������?

echo "����������� "false""
if [ "false" ]              #  ��� ������� ������ "false".
then
  echo ""false" -- ��� ������." #+ � ��� �������.
else
  echo ""false" -- ��� ����."
fi            # "false" -- ��� ������.

echo

echo "����������� "$false""  # ����� �������������������� ����������.
if [ "$false" ]
then
  echo ""$false" -- ��� ������."
else
  echo ""$false" -- ��� ����."
fi            # "$false" -- ��� ����.
              # ������ �� �������� ��������� ���������.


echo

exit 0

����������. ��������� ����������,
���������� � ������ 7-1.

if [ condition-true ]
then
   command 1
   command 2
   ...
else
   # �������������� ����� (����� ��������, ���� � ��� ��� �������������).
   # �������������� ���� ����,
   # ����������� � ������, ����� ��������� �������� -- "����".
   command 3
   command 4
   ...
fi

����� if � then ������������� � ����� ������, �� ����������� if ������ ����������� ������ � �������. � if, � then — ��� ����������������� �����. ����������������� ����� �������� ����������, ������� ������ ���� ��������� ������, ��� � ��� �� ������ �������� ����� ����������. if [ -x "$filename" ]; then

����������� if test condition-true
�������� ������ ������������ ����������� if [ condition-true ],
��� ����� ���������� ������ [ ��������� �� �� ��������, ��� �
������� test. ����������� ������ ����������
������ ] �� �������� ��������� �����������,
������, ����� ����� ������ Bash ������� �� �������.

������� test — ��� ���������� ������� Bash, ������� ��������� �������� ������ � ���������� ��������� �����. ����� �������, � Bash-��������, ������� test �� �������� ������� (/usr/bin/test) �������, ������� �������� ������ ������ sh-utils. ����������, [ �� ���������� ����� ������� /usr/bin/[, ������� �������� ������������� ������� �� /usr/bin/test. bash$ type test test is a shell builtin bash$ type '[' [ is a shell builtin bash$ type '[[' [[ is a shell keyword bash$ type ']]' ]] is a shell keyword bash$ type ']' bash: type: ]: not found

#!/bin/bash

echo

if test -z "$1"
then
  echo "��������� ��������� ������ �����������."
else
  echo "������ �������� ��������� ������: $1."
fi

echo

if /usr/bin/test -z "$1"      # ���� ��� �� ���������, ��� � ���������� ������� "test".
then
  echo "��������� ��������� ������ �����������."
else
  echo "������ �������� ��������� ������: $1."
fi

echo

if [ -z "$1" ]                # ������������� ��������� ���������������� ����� ����.
#   if [ -z "$1"                ��� ����������� ������ ��������, ��...
#+  Bash ������ ��������� �� ������������� ����������� ������.
then
  echo "��������� ��������� ������ �����������."
else
  echo "������ �������� ��������� ������: $1."
fi

echo

if /usr/bin/[ -z "$1"         # ������������� ��������� ���������������� ����� ����.
# if /usr/bin/[ -z "$1" ]     # ��������, �� ������ ��������� �� ������.
then
  echo "��������� ��������� ������ �����������."
else
  echo "������ �������� ��������� ������: $1."
fi

echo

exit 0

����������� [[ ]] ����� ������������, �� ��������� �
[ ]. ���� ����������� ������� ������� test
����������� � Bash �� ksh88.

������ ���� ����������� �� ������������ ������� �������������� ������������� ���� ������ � �� ������������ ��������� ���������� �� ��������� �����, �� ����������� ����������� ���������� � ������.

file=/etc/passwd

if [[ -e $file ]]
then
  echo "���� ������� ������."
fi

����������� [[ … ]] ����� ���������������, ������ [ … ], ��������� ������� �������� ��������� ���������� ������. ��������, ��������� &&, ||, < � > ������ [[ ]] ������ ���������, � �� ����� ��� ������ [ ] ��������� ��������� �� �������.

������ ������, ����� ��������� if, �� ������� test, �� ���������� ������ ( [ ] ��� [[ ]] ) �� �������� �������������. dir=/home/bozo if cd "$dir" 2>/dev/null; then # "2>/dev/null" ���������� ������ ��������� �� �������. echo "������� � ������� $dir ��������." else echo "���������� ������� � ������� $dir." fi ���������� «if COMMAND» ���������� ��� �������� ������� COMMAND. ����� ��� ��, �������, ����������� ������ ���������� ������ ����� ���� ��������� ��� ������������� ��������� if. var1=20 var2=22 [ "$var1" -ne "$var2" ] && echo "$var1 �� ����� $var2" home=/home/bozo [ -d "$home" ] || echo "������� $home �� ������."

������ (( )) ������������ ����������
��������������� ���������. ���� ����������� ���������� ��������
����, �� ������������ 1, ��� «����». ��������� ���������
���� ��� �������� 0, ��� «������». �� ���� ������
����������������� ����������� test � [ ], ������������� ����.

#!/bin/bash
# �������� �������������� ���������.

# ���������� (( ... )) ��������� �������������� ���������.
# ��� �������� �������������� ���� �������� ���������� [ ... ] !

(( 0 ))
echo "��� �������� "(( 0 ))":  $?."         # 1

(( 1 ))
echo "��� �������� "(( 1 ))":  $?."         # 0

(( 5 > 4 ))                                   # true
echo "��� �������� "(( 5 > 4 ))":  $?."     # 0

(( 5 > 9 ))                                   # false
echo "��� �������� "(( 5 > 9 ))":  $?."     # 1

(( 5 - 5 ))                                   # 0
echo "��� �������� "(( 5 - 5 ))":  $?."     # 1

(( 5 / 4 ))                                   # �������, ��� � �������
echo "��� �������� "(( 5 / 4 ))":  $?."     # 0

(( 1 / 2 ))                                   # ��������� ������� < 1.
echo "��� �������� "(( 1 / 2 ))":  $?."     # ����������� �� 0.
                                              # 1

(( 1 / 0 )) 2>/dev/null                       # ������� �� 0.
echo "��� �������� "(( 1 / 0 ))":  $?."     # 1

# ��� ���� ����� ���������� "2>/dev/null" ?
# ��� ����������, ���� �� ������?
# ���������� ������ �� � ��������� ��������.

exit 0

Предназначена для проверки типа файла и сравнения чисел и строк. Возвращает код возврата 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 • Команда

Изучаем Bash: Команда test и ее аналоги. Проверка файлов и сравнение строк

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

file=/etc/fstab # Объявляем переменную

if test -e $file # Используем команду test

echo «Файл fstab найден.»

echo «Что-то нету такого файла»

Как мы видим, мы использовали знакомые нам операторы if / then , которые я уже описывал ранее.

После оператора if стоит команда test которая и и производит проверку нашего файла, который мы объявили в переменной. Также, команду test мы использовали с опцией «-e», данная опция возвращает значение «true», если файл найден.

В случае «true» запускается оператор then и выводит строку echo, если же файл не найдет, что означает «false», то запускается оператор else и выводит сообщение «Что-то нету такого файла».

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

file=/etc/fstab # Объявляем перменную

if /usr/bin/[ -e $file ] # Используем команду «[«, также мы закрыли ее правой ], потому bash требует ее наличие

echo «Файл fstab найден.»

echo «Что-то нету такого файла»

Использовали вместо команды test, команду «[» с закрытой правой «]». Вообще, старые версии bash не требовали наличие правой закрывающейся ]. Теперь это необходимо, чтобы избежать ошибок.

Я рекомендую вместо [ ] использовать конструкцию [[ ]]:

file=/etc/fstab # Объявляем перменную

if [[ -e $file ]] # Используем конструкцию [[ ]]

echo «Файл fstab найден.»

echo «Что-то нету такого файла»

Почему [[ ]] лучше, чем [ ]? Потому что внутри [[ ]] вы можете использовать например такие операторы, как: &&, ||, , в то время как внутри [ ] будут сообщения об ошибках.

Кстати, вы можете использовать [ ] и [[ ]] без if / then / else. Те команды как бы заменяют данные операторы:

[[ «$var1» -ne «$var2» ]] && echo «$var1 не равно $var2»

Давайте разберем, что мы тут написали.

Итак, мы объявили две переменные var1 и var2 с числовыми значениями. Далее, мы вместо if / then / else использовали [[ ]], «-ne», которая находится между «$var1» и «$var2» означает «не ровно». Оператор && — and (и).

Вот так вот 🙂 Любые вопросы приветствуются! 🙂 С следующих статьях мы рассмотрим операции сравнения чисел и строк.

у меня вопрос, а арифметические операции делать можно в [[ ]]?

нет, для этого существует оператор (( )), о котором я напишу обязательно 🙂

спасибо! :=) мне это нужно :=)

Так. Вы хотите сказать что, пример, конвеер cat file | grep 123 лучше всего помещать в [[ ]] ?

Эксперт — зто человек, который совершил все возможные ошибки в очень узкой специальности.

это у тебя кусок кода или это весь скрипт? В этом случае не надо, потому что у тебя тут нету ни какого сравнения, не тестирования. обычный вывод информации и поиск grep. Мое мнение 🙂

Конечно это вырезка из скрипта, придуманная на ходу, но у меня реально есть скрипты с похожими условиями. Условия такие:
[ cat file | grep 123 ] ; then
rm file
fi
продолжение скрипта допустим break

Эксперт — зто человек, который совершил все возможные ошибки в очень узкой специальности.

в твоем случае ты можешь вместо [ ], использовать оператор if, то есть:

if cat file | grep 123; then
rm file
fi

действие будет аналогичным 🙂

Едрен батом, прошу прощения. Я не верно написал
[ `cat file | grep 123` = 123 ]
Но ваш способ кажется еще лучше, попробую.

Эксперт — зто человек, который совершил все возможные ошибки в очень узкой специальности.

что значит grep 123 = 123 и зачем тут используешь одинарные ковычки?

P.S. Александр, я настолько простой, что лучше ко мне на «ты» 😉

Все просто. любую команду имеющую параметры через пробел нужно помещать в « иначе shell не понимает. А вообще смысл у моего примера такой: если в текстовом файле появится строчка имеющая 123, это для примера, на самом деле в реальном скрипте ищется #####, так вот если это в файле есть, то файл не обрабатывать, а удалить и перейти к следующему циклу. Возможно я забыл еще что-то но смысл такой и он у меня работает. Есть правда у меня косяк: если попадется 2 строчки с тем что я ищю, то скрипт пишет: test argument expected и завершается полность, пока это еще не побарол, не могу понять почему ему 2 значения в поиске не устраивает, благо такое случается раз в пол года.

А я понял. Можно либо в ` ` либо в [[ ]] вот и весь ответ. Блин как обычно не дочитал совсем немного. Спасибо, но я привык «.

Эксперт — зто человек, который совершил все возможные ошибки в очень узкой специальности.

я имел ввиду, почему два раза у тебя 123 в скрипте? 🙂

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

Эксперт — зто человек, который совершил все возможные ошибки в очень узкой специальности.

отличная работа, Максим, я тоже присоединюсь к написанию статей по bash, хорошая тема

Источник

Команда test

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

Для сокращения кода сценария используют парный оператор [ как синоним 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

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

• -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

Операции AND и OR

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

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

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

Источник

Функции сравнения и тестирования в Bash

Пояснения по конструкциям test , [, [[, ((, и if-then-else

Серия контента:

Этот контент является частью # из серии # статей: Подсказки по Linux

Этот контент является частью серии: Подсказки по Linux

Следите за выходом новых статей этой серии.

Bash shell сгодня доступен на многих Linux® и UNIX® системах и является по умолчанию основным shell-кодом в Linux. Bash предоставляет широчайшие возможности для программирования, в том числе расширенное число фунций для тестирования типов файлов и атрибутов, равно как и всяческие возможности для сравнения строк и чисел, доступные в большинстве языков программирования. Для продвинутого пользователя shell крайне важно разбираться в различных типах тестов и знать то, что shell может интерпретировать некоторые операторы как свои метасимволы. Эта статья представляет собой извлечение из руководства developerWorks LPI exam 102 prep: Shells, scripting, programming, and compiling (exam 102 prep: Shell-коды, написание скриптов, программирование и компилирование) и показывает, как разобраться в использовании операций проверки и сравнения в Bash shell.

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

Тесты

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

test и [

Встроенная команда test возвращает 0 (True) или 1 (False), в зависимости от определения выражения expr. Также вы можете использовать квадратные скобки: test expr и [expr] представляют из себя эквивалентные выражения. Вы можете просмотреть возвращаемое значение с помощью $? ; вы можете использовать возвращаемое значение с помощью && и ||; вы можете также протестировать это значение с помощью различных условных конструкций, которые рассматриваются далее в этом руководстве.

Листинг 1. Некоторые простые тесты

В первом примере листинга 1, оператор -gt выполняет арифметическое сравнение двух строковых значений. Во втором примере с помощью альтернативной тестовой формы [ ] оценивается (не)равенство двух строк. В последнем примере значение переменной HOME проверяется с целью увидеть, папка это или нет, при этом используется унарный оператор -d .

Вы можете сравнивать два числовых значения с помощью операторов -eq , — ne , -lt , — le , — gt , or — ge , означающих соответственно «равно», «неравно», «меньше», «меньше либо равно», «больше» и «больше либо равно».

Вы можете сравнивать строки на равенство и неравенство, а также на то, будет ли первая строка поставлена до или после второй при сортировке. Для всего этого используются, соответственно, операторы = , != , и > . Унарный оператор -z проверяет, не пуста ли строка, тогда как оператор -n или вообще отсутствие оператора возвращает True если строка не пуста.

Замечание: операторы и > также используются shell для перенаправления. Этого надо избегать с помощью или > . Листинг 2 содержит в себе еще несколько примеролв тестов строк. Проверьте, как они работают.

Листинг 2. Некоторые тесты строк

Некоторые наиболее часто используемые тесты файлов показаны в таблице 1. Результат теста это True, если тестируемый файл существует и имеет указанные характеристики.

Кроме представленных выше унарных тестов существуют бинарные операторы для сравнения двух файлов. Они показаны в таблице 2.

Некоторые другие тесты позволят вам проверять другие вещи, например права доступа к файлу. Для более детального ознакомления посмотрите страницы с руководствами по bash или используйте команду help test , чтобы получить краткую информацию по встроенной команде test. Вы можете использовать команду help и для других встроенных команд.

Оператор -o позволяет вам тестировать различные опции shell, которые могут быть установлены командой set -o option , которая возвращает True (0), если опция установлена и False (1) в противном случае, как показано в листинге 3.

Листинг 3. Тестирование опций shell

Наконец, опции -a и -o соединяют выражения как логическое И и ИЛИ соответственно, а унарный оператор ! делает смысл теста противоположным. Вы можете использовать круглые скобки, чтобы группировать выражения и выполнять операции не по порядку установленного по умолчанию старшинства. Помните, что shell, как правило, запускает выражение в скобках в электронной подоболочке, поэтому вам придется вместо просто скобок писать ( и ) или заключать описанные выше операторы в одиночные или двойные кавычки. Листинг 4 показывает применение к выражению законов де Моргана.

Листинг 4. Конъюнкция и дизъюнкция тестов

Команда test предоставляет широчайшие возможности, но является несколько неудобной в использовании из-за необходимости делать переходы в коде с помощью и из-за различиях в сравнениях строк и чисел. К счастью, bash располагает двумя другими способами тестирования, которые покажутся более естественными для тех, кто знаком с синтаксисом C, C++ или Java®.

Составная команда (( )) оценивает арифметическое выражение и устанавливает статус выдачи равный 1, если выражение равно 0, или статус выдачи равный 0, если выражение имеет ненулевое значение. Вам ненужно ставить перед операторами между (( и )) . Арифметика работает с целыми числами. Деление на 0 вызывает ошибку, но переполнение этого не делает. Вы выполняете обычные для языка C арифметические, логические и побитовые операции. Команда let также может запускать одно или несколько арифметических выражениий. Она обычно используется для того, чтобы приписывать значения арифметическим переменным.

Листинг 5. Присваивание и тестирование арифметических выражений

Как и в случае с (( )) , составная команда [[ ]] позволяет вам использовать более естественный синтаксис для тестирования имен файлов и строк. Вы можете объединять тесты, которые разрешены для команды test с помощью круглых скобок и логических операторов.

Листинг 6. Использование составного оператора [[

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

Листинг 7. Тесты с [[ и групповым символом

Вы можете даже делать арифметические тесты внутри составных операторов с [[ , но делайте это с осторожностью. Если только они не находятся внутри составного оператора (( , операторы и > будут сравнивать операнды как строки и проверять их порядок в зависимости от текущей последовательности сортировки. Листинг 8 дает некоторые примеры этого.

Листинг 8. Осуществление арифметических тестов с помощью [[

Условные конструкции

С помощью описанных выше тестов и операторов контроля && и || вы можете решить немало задач программирования. Кроме всего этого bash включает в себя и более привычные конструкции с if, then, else и с case. Когда вы ознакомитесь с ними, можно будет перейти к конструкциям с циклами, что существенно расширит набор средств, которые вы сможете использовать.

Консрукции с if, then, else

Команда if в bash является составной командой которая проверяет выдаваемое значение теста или команды ( $? ), а затем ветвится в зависимости от того равно ли это проверяемое значение True (0) или False (не 0). Вышеописанные тесты возвращают только значения 0 или 1, но команды могут возвращать и другие значения. Больше вы узнаете об этом в руководстве LPI exam 102 prep: Shells, scripting, programming, and compiling (LPI exam 102 prep: Shell-коды, написание скриптов, программирование и компилирование.

Составная команда if в bash всегда содержит в себе предложение с then со списком команд которые должны быть выполнены, если тест или команда сразу после if возвращает 0. Команда if также может содержать одно или несколько предложений с elif , каждое из которых содержит в себе дополнительный тест и предложение с then и списком команд. Далее if может содержать завершающее предложение с else и списком команд, оторые надо выполнить, если ни изначальный тест, ни все тесты в предложениях с elif не дали результат True. Наконец, if завершается выражением fi , обозначающим окончание этой конструкции.

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

Листинг 9. Вычисление выражений с if, then, else

Калькулятор использует выражение local , чтобы объявить x локальной переменной, которая используется только внутри функции mycalc . Функция let имеет несколько возможных опций, как и родственная ей функция declare . Для более детального ознакомления посмотрите страницы с руководствами по bash или используйте команду help let .

Как вы видели в листинге 9, необходимо ставить перед выражениями, содержащими метасимволы shell, такие как (, ), *, > и else и на два последних примера в листинге 9. Как вы видите, передавать xyz на вход функции mycalc не будет ошибкой, но такое выражение будет вычислено как 0. Эта функция не умеет определять значения символов в последнем примере и не может выдать пользователю предупреждение. Вы можете использовать тест для сопоставления строк с образцом, например
[[ ! («$*» == *[a-zA-Z]* ]]
(или в другой форме в зависимости от вашей локали), чтобы распознавать выражения, содержащие алфавитные символы, но это также не даст вам испльзовать шестнадцатиричную запись вводных данных (вы могли бы, например, записать 15 как 0x0f в шестнадцатиричной записи). Вообще shell позволяет использовать основания систем счисления вплоть до 64 (с использованием нотации base#value , где base — основание, а value — значение), так что вы можете использовать любой алфавитный символ, а также _ и @ для записи вводных данных. Для восьмеричной и шестнадцатеричной систем счисления используется обычная нотация со стоящими перед записью числа символамим 0 и 0x (или 0X) соответственно. Листинг 10 дает некоторые примеры этого.

Листинг 10. Числовые вычисления с различными основаниями системы счисления

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

Выражение elif очень удобно. Оно помогает вам в написании скриптов тем, что усеньшает количество отступов в программе. Возможно, вас удивит выдача команды type для функции mycalc , показанная в листинге 11.

Листинг 11. Type mycalc

Конечно, вы можете делать арифметические вычисления с помощью shell просто с помощью команды $(( expression )) , где expression — арифметическое выражение, вместе с командой echo , как это показано в листинге 12. Для этого вам не нужно было изучать различные функции и тесты. Отметьте все же, что shell не интерпретирует обычным образом метасимволы, такие как *, когда они стоят внутри выражения типа (( expression )) или [[ expression ]] .

Листинг 12. Числовые вычисления в shell с помощью команд echo и $(( ))

Узнайте об этом больше

Если вы захотите узнать больше о Bash скриптинге в Linux, прочитайте руководство «LPI exam 102 prep: Shells, scripting, programming, and compiling (LPI exam 102 prep: Shell-коды, написание скриптов, программирование и компилирование)» из которого была взята данная статья, или обратитесь к другим ресурсам ниже. Не забудьте оценить эту страницу.

Ресурсы для скачивания

Похожие темы

• Оригинал этой статьи
• Просмотрите руководство «LPI exam 102 prep: Shells, scripting, programming, and compiling» (developerWorks, Январь 2007), чтобы найти более подробную информацию про кастомизацию Bash shell и скриптпнг в Linux. Оно является частью серии LPI exam prep tutorial series (Серии руководств LPI exam prep), которая рассказывает об основах Linux и помогает в подготовке к аттестации по специальности системного администратора.
• Прочитайте на developerWorks эти статьи, чтобы узнать о других способах работы с Bash:
  • Bash в примерах, Часть 1: Основы программирования в Bourne again shell (bash)
  • Bash в примерах, Часть 2: Дальнейшие основы bash программирования
  • Bash в примерах, часть 3: О системе ebuild
  • System Administration Toolkit: Get the most out of bash(Набор инструментов системного администрирования: добейтесь лучшего результата с bash)
  • Working in the bash shell
• «Shell Command Language(Язык команд Shell)» — здесь вы найдете язык команд shell в формате The Open Group и IEEE.
• Найдите еще больше руководств для разработчиков Linux в разделе Linux на developerWorks .
• Скачайте испытываемое программное обеспечение IBM прямо с developerWorks.

Комментарии

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

Источник

Синтаксис

• [«$ 1» = «$ 2»] #A «[» Скобка — это фактически команда. Из-за этого требуется пространство для него и после него.
• test «$ 1» = «$ 2» #Test является синонимом команды «[»

параметры

замечания

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

Если утверждение

if [[ $1 -eq 1 ]]; then
    echo "1 was passed in the first parameter"
elif [[ $1 -gt 2 ]]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

Замыкание fi необходимо, но предложения elif и / или else могут быть опущены.

Точки с запятой до then являются стандартным синтаксисом для объединения двух команд в одну строку; они могут быть опущены , если только then перемещается на следующую строку.

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

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

if grep "foo" bar.txt; then
    echo "foo was found"
else
    echo "foo was not found"
fi

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

if (( $1 + 5 > 91 )); then
    echo "$1 is greater than 86"
fi

Вы также можете столкнуться , if заявления с одиночными скобками. Они определены в стандарте POSIX и гарантированно работают во всех POSIX-совместимых оболочках, включая Bash. Синтаксис очень похож на синтаксис в Bash:

if [ "$1" -eq 1 ]; then
    echo "1 was passed in the first parameter"
elif [ "$1" -gt 2 ]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

Пока цикл

#! /bin/bash

i=0

while [ $i -lt 5 ] #While i is less than 5
do
    echo "i is currently $i"
    i=$[$i+1] #Not the lack of spaces around the brackets. This makes it a not a test expression
done #ends the loop

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

Эта петля выводит:

i is currently 0
i is currently 1
i is currently 2
i is currently 3
i is currently 4

Для цикла

#! /bin/bash

for i in 1 "test" 3; do #Each space separated statement is assigned to i
    echo $i
done

Другие команды могут генерировать операторы для перебора. См. Пример «Использование для цикла для ввода чисел».

Эти результаты:

1
test
3

Использование цикла для перебора Iterate Over Numbers

#! /bin/bash

for i in {1..10}; do # {1..10} expands to "1 2 3 4 5 6 7 8 9 10"
    echo $i
done

Это обеспечивает следующее:

1
2
3
4
5
6
7
8
8
10

Для цикла с синтаксисом C-стиля

Основной формат C-стиль for петли:

for (( variable assignment; condition; iteration process ))

Заметки:

• Назначение переменной внутри цикла C-стиля for цикла может содержать пробелы, в отличие от обычного назначения
• Переменным внутри цикла C for цикла не предшествует $ .

Пример:

for (( i = 0; i < 10; i++ ))
do
    echo "The iteration number is $i"
done

Также мы можем обрабатывать несколько переменных внутри цикла C for цикла:

for (( i = 0, j = 0; i < 10; i++, j = i * i ))
do
    echo "The square of $i is equal to $j"
done

До цикла

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

i=5
until [[ i -eq 10 ]]; do #Checks if i=10
    echo "i=$i" #Print the value of i
    i=$((i+1)) #Increment i by 1
done

Выход:

i=5
i=6
i=7
i=8
i=9

Когда i достигает 10, условие до тех пор, пока цикл не станет истинным, и цикл закончится.

продолжить и разбить

Пример продолжения

for i in [series]
do
    command 1
    command 2
    if (condition) # Condition to jump over command 3
            continue # skip to the next value in "series"
    fi
    command 3
done

Пример разрыва

for i in [series]
do
    command 4
    if (condition) # Condition to break the loop
    then
            command 5 # Command if the loop needs to be broken
            break
    fi
    command 6 # Command to run if the "condition" is never true 
done

Зацикливание по массиву

for цикла:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
done

Или же

for ((i=0;i<${#arr[@]};i++));do
    echo "${arr[$i]}" 
done

while loop:

i=0
while [ $i -lt ${#arr[@]} ];do
    echo "${arr[$i]}"
    i=$(expr $i + 1)
done

Или же

i=0
while (( $i < ${#arr[@]} ));do
    echo "${arr[$i]}"
    ((i++))
done

Перерыв петли

Разрыв нескольких циклов:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break 2
    done
done

Выход:

a
a

Разрыв одного цикла:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break
    done
done

Выход:

a
a
b
a
c
a
d
a
e
a
f
a

Оператор switch с футляром

С помощью оператора case вы можете сопоставлять значения с одной переменной.

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

Если совпадение найдено, команды upto ;; выполняются.

case "$BASH_VERSION" in
 [34]*)
    echo {1..4}
    ;;  
  *)
    seq -s" " 1 4
esac

Шаблон — это не регулярные выражения, а совпадение шаблонов (aka globs).

Для Loop без параметра списка слов

for arg; do
    echo arg=$arg
done

В цикле for без параметра списка слов вместо этого будут выполняться итерация по позиционным параметрам. Другими словами, приведенный выше пример эквивалентен этому коду:

for arg in "[email protected]"; do
    echo arg=$arg
done

Другими словами, если вы поймете, что пишете for i in "[email protected]"; do ...; done , просто перенесите in части, а просто писать for i; do ...; done .

Условное выполнение списков команд

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

Любая встроенная команда, выражение или функция, а также любая внешняя команда или скрипт могут выполняться условно с использованием && (и) и || (или) операторов.

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

cd my_directory && pwd

Аналогично, это приведет к выходу из строя команды cd , предотвращая катастрофу:

cd my_directory || exit
rm -rf *

При объединении нескольких операторов таким образом важно помнить, что (в отличие от многих языков C-стиля) эти операторы не имеют приоритета и являются лево-ассоциативными .

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

cd my_directory && pwd || echo "No such directory"

• Если cd завершается успешно, выполняется && pwd и печатается текущее имя рабочего каталога. Если pwd не сработает (редкость) || echo ... не будет выполняться.
• Если cd не удастся, && pwd будет пропущен, а значение || echo ... будет работать.

Но это не будет (если вы думаете, if...then...else ) …

cd my_directory && ls || echo "No such directory"

• Если cd терпит неудачу, && ls пропущен и || echo ... выполняется.
• Если cd завершается успешно, выполняется && ls .
  • Если ls преуспеет, || echo ... игнорируется. (Все идет нормально)
  • НО … если ls терпит неудачу, то || echo ... также будет выполнено.
    

    Это команда ls , а не cd , это предыдущая команда .

Зачем использовать условное выполнение списков команд

Условное исполнение — это волосы быстрее, чем if...then но его главное преимущество — позволить функциям и сценариям выходить рано или «короткое замыкание».

В отличие от многих языков, таких как C где ядро ​​явно выделяется для структур и переменных и таких (и, следовательно, должно быть освобождено), bash обрабатывает это под обложками. В большинстве случаев нам не нужно ничего убирать, прежде чем покидать эту функцию. Оператор return освобождает все локальные функции и выполнение записи на обратном адресе в стеке.

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

my_function () {

    ### ALWAYS CHECK THE RETURN CODE

    # one argument required. "" evaluates to false(1)
    [[ "$1" ]]             || return 1

    # work with the argument. exit on failure
    do_something_with "$1" || return 1
    do_something_else      || return 1

    # Success! no failures detected, or we wouldn't be here
    return 0
}

Глава 7. Проверка условий

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

7.1. Конструкции проверки условий

Оператор if/then проверяет — является ли код завершения списка команд 0 (поскольку 0 означает «успех» ), и если это так, то выполняет одну, или более, команд, следующие за словом then.

Существует специальная команда — [ (левая квадратная скобка). Она является синонимом команды test, и является встроенной командой (т.е. более эффективной, в смысле производительности). Эта команда воспринимает свои аргументы как выражение сравнения или как файловую проверку и возвращает код завершения в соответствии с результатами проверки (0 — истина, 1 — ложь).

Начиная с версии 2.02, Bash предоставляет в распоряжение программиста конструкцию [[ . ]] расширенный вариант команды test , которая выполняет сравнение способом более знакомым программистам, пишущим на других языках программирования. Обратите внимание: [[ — это зарезервированное слово, а не команда.

Bash исполняет [[ $a -lt $b ]] как один элемент, который имеет код возврата.

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

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

Оператор if/then допускает наличие вложенных проверок.

Это детальное описание конструкции «if-test» любезно предоставлено Stephane Chazelas.

Пример 7-1. Что есть «истина»?

Упражнение. Объясните результаты, полученные в Пример 7-1.

Когда if и then располагаются в одной строке, то конструкция if должна завершаться точкой с запятой. И if , и then — это зарезервированные слова. Зарезервированные слова начинают инструкцию, которая должна быть завершена прежде, чем в той же строке появится новая инструкция.

Else if и elif

elif — это краткая форма записи конструкции else if . Применяется для построения многоярусных инструкций if/then .

Конструкция if test condition-true является точным эквивалентом конструкции if [ condition-true ], где левая квадратная скобка [ выполняет те же действия, что и команда test. Закрывающая правая квадратная скобка ] не является абсолютно необходимой, однако, более новые версии Bash требуют ее наличие.

Команда test — это встроенная команда Bash, которая выполняет проверки файлов и производит сравнение строк. Таким образом, в Bash-скриптах, команда test не вызывает внешнюю ( /usr/bin/test) утилиту, которая является частью пакета sh-utils . Аналогично, [ не производит вызов утилиты /usr/bin/[, которая является символической ссылкой на /usr/bin/test.

Пример 7-2. Эквиваленты команды test — /usr/bin/test, [ ] , и /usr/bin/[

Конструкция [[ ]] более универсальна, по сравнению с [ ] . Этот расширенный вариант команды test перекочевал в Bash из ksh88 .

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

Конструкция [[ . ]] более предпочтительна, нежели [ . ], поскольку поможет избежать некоторых логических ошибок. Например, операторы && , || , и > внутри [[ ]] вполне допустимы, в то время как внутри [ ] порождают сообщения об ошибках.

Строго говоря, после оператора if, ни команда test, ни квадратные скобки ( [ ] или [[ ]] ) не являются обязательными.

Инструкция «if COMMAND» возвращает код возврата команды COMMAND.

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

Внутри (( )) производится вычисление арифметического выражения. Если результатом вычислений является ноль, то возвращается 1 , или «ложь» . Ненулевой результат дает код возврата 0 , или «истина» . То есть полная противоположность инструкциям test и [ ] , обсуждавшимся выше.

Пример 7-3. Арифметические выражения внутри (( ))

Источник

Linux test command

On Unix-like operating systems, the test command checks file types and compares values.

This page covers the GNU/Linux version of test.

For information about the test command in bash see our bash test command page.

Description

test is used as part of the conditional execution of shell commands.

test exits with the status determined by EXPRESSION. Placing the EXPRESSION between square brackets ([ and ]) is the same as testing the EXPRESSION with test. To see the exit status at the command prompt, echo the value «$?» A value of 0 means the expression evaluated as true, and a value of 1 means the expression evaluated as false.

Syntax

Expressions

Expressions take the following forms:

Except for -h and -L, all FILE-related tests dereference symbolic links. Beware that parentheses need to be escaped (e.g., by backslashes) for shells. INTEGER may also be -l STRING, which evaluates to the length of STRING.

NOTE: your shell may have its own version of test, which usually supersedes the version described here. Please refer to your shell’s documentation for details about the options it supports.

Examples

This command prints the text «Yes, that’s true.» because 100 is greater than 99.

This command prints the text «No.» because 100 is not less than 99.

This command prints «0» because the expression is true; the two strings are identical.

This command prints «1» because the expression is false; 5 does not equal 6.

Источник

Linux команда test пример

Как уже говорилось выше, для построения произвольных алгоритмов необходимо иметь операторы проверки условий. Оболочка bash поддерживает операторы выбора if … then … else и case , а также операторы организации циклов for , while , until , благодаря чему она превращается в мощный язык программирования.

5.8.1 Операторы if и test (или [ ])

Конструкция условного оператора в слегка упрощенном виде выглядит так:

if list1 then list2 else list3 fi

где list1 , list2 и list3 — это последовательности команд, разделенные запятыми и оканчивающиеся точкой с запятой или символом новой строки. Кроме того, эти последовательности могут быть заключены в фигурные скобки: .

Оператор if проверяет значение, возвращаемое командами из list1 . Если в этом списке несколько команд, то проверяется значение, возвращаемое последней командой списка. Если это значение равно 0, то будут выполняться команды из list2 ; если это значение не нулевое, будут выполнены команды из list3 . Значение, возвращаемой таким составным оператором if , совпадает со значением, выдаваемым последней командой выполняемой последовательности.

Полный формат команды if имеет вид:

if list then list [ elif list then list ] . [ else list ] fi

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

В качестве выражения, которое стоит сразу после if или elif , часто используется команда test , которая может обозначаться также квадратными скобками [ ]. Команда test выполняет вычисление некоторого выражения и возвращает значение 0, если выражение истинно, и 1 в противном случае. Выражение передается программе test как аргумент. Вместо того, чтобы писать

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

Заметьте, что test и [ — это два имени одной и той же программы, а не какое-то магическое преобразование, выполняемое оболочкой bash (только синтаксис [ требует, чтобы была поставлена закрывающая скобка). Заметьте также, что вместо test в конструкции if может быть использована любая программа.

В заключение приведем пример использования оператора if :

if [ -e textmode2.htm ] ; then

Об операторе test (или […]) надо бы поговорить особо.

5.8.2 Оператор test и условные выражения

Условные выражения, используемые в операторе test , строятся на основе проверки файловых атрибутов, сравнения строк и обычных арифметических сравнений. Сложные выражения строятся из следующих унарных или бинарных операций («элементарных кирпичиков»):

Верно, если файл с именем file существует.

Верно, если file существует и является специальным файлом блочного устройства.

Верно, если file существует и является специальным файлом символьного устройства.

Верно, если file существует и является каталогом.

Верно, если файл с именем file существует.

Верно, если файл с именем file существует и является обычным файлом.

Верно, если файл с именем file существует и для него установлен бит смены группы.

Верно, если файл с именем file существует и является символической ссылкой.

Верно, если файл с именем file существует и для него установлен «sticky» bit.

Верно, если файл с именем file существует и является именованным каналом (FIFO).

Верно, если файл с именем file существует и для него установлено право на чтение

Верно, если файл с именем file существует и его размер больше нуля .

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

Верно, если файл с именем file существует и для него установлен бит смены пользователя.

Верно, если файл с именем file существует и для него установлено право на запись.

Верно, если файл с именем file существует и является исполняемым .

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

Верно, если файл с именем file существует и принадлежит группе, определяемой эффективным идентификатором группы.

Верно, если файл с именем file существует и является сокетом.

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

Верно, если файл file1 имеет более позднее время модификации, чем file2 .

Верно, если файл file1 старше , чем file2 .

Верно, если файлы file1 и file2 имеют одинаковые номера устройств и индексных дескрипторов (inode).

Верно, если задействована опция оболочки optname . Пояснения см. на странице man bash.

Верно, если длина строки равна нулю.

Верно, если длина строки не равна нулю.

Верно, если строки совпадают. Вместо == может использоваться = .

Верно, если строки не совпадают.

Верно, если строка string1 лексикографически предшествует строке string2 (для текущей локали).

Верно, если строка string1 лексикографически стоит после строки string2 (для текущей локали).

Здесь OP — э то одна из операций арифметического сравнения: -eq (равно), -ne (не равно), -lt (меньше чем), -le (меньше или равно), -gt (больше), -ge (больше или равно). В качестве аргументов могут использоваться положительные или отрицательные целые.

Из этих элементарных условных выражений можно строить сколь угодно сложные с помощью обычных логических операций ОТРИЦАНИЯ, И и ИЛИ:

Булевский оператор отрицания.

• expression1 -a expression2

Булевский оператор AND (И). Верен, если верны оба выражения.

• expression1 -o expression2

Булевский оператор OR (ИЛИ). Верен, если верно любое из двух выражений.

Такие же условные выражения используются и в операторах while и until , которые мы рассмотрим чуть ниже.

5.8.3 Оператор case

Формат оператора case таков:

case word in [ [(] pattern [ | pattern ] . ) list ;; ] . esac

Команда case вначале производит раскрытие слова word , и пытается сопоставить результат с каждым из образцов pattern поочередно. После нахождения первого совпадения дальнейшие проверки не производятся, выполняется список команд, стоящий после того образца, с которым обнаружено совпадение. Значение, возвращаемое оператором, равно 0, если совпадений с образцами не обнаружено. В противном случае возвращается значение, выдаваемое последней командой из соответствующего списка.

Следующий пример использования оператора case заимствован из системного скрипта /etc/rc.d/rc.sysinit.

Если переменная принимает значение yes или true, то будет выполнена первая пара команд, а если ее значение равно no или false – вторая пара.

5.8.4 Оператор select

Оператор select позволяет организовать интерактивное взаимодействие с пользователем. Он имеет следующий формат:

select name [ in word; ] do list ; done

Вначале из шаблона word формируется список слов, соответствующих шаблону. Этот набор слов выводится в стандартный поток ошибок, причем каждое слово сопровождается порядковым номером. Если шаблон word пропущен, таким же образом выводятся позиционные параметры. После этого выдается стандартное приглашение PS3, и оболочка ожидает ввода строки на стандартном вводе. Если введенная строка содержит число, соответствующее одному из отображенных слов, то переменной name присваивается значение, равное этому слову. Если введена пустая строка, то номера и соответствующие слова выводятся заново. Если введено любое другое значение, переменной name присваивается нулевое значение. Введенная пользователем строка запоминается в переменой REPLY . Список команд list выполняется с выбранным значением переменной name .

Вот небольшой скрипт:

echo «Какую ОС Вы предпочитаете?»

select var in «Linux» «Gnu Hurd» «Free BSD» «Other»; do

echo «Вы бы выбрали $var»

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

Какую ОС Вы предпочитаете?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#?

Нажмите любую из 4 предложенных цифр (1,2,3,4). Если вы, например, введете 1, то увидите собщение:

“Вы бы выбрали Linux”

5.8.5 Оператор for

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

for name in words do list done.

Правила построения списков команд ( list ) такие же, как и в операторе if .

Пример . Следующий скрипт создает файлы foo_1, foo_2 и foo_3:

for a in 1 2 3 ; do

В общем случае оператор for имеет формат:

for name [ in word; ] do list ; done

Вначале производится раскрытие слова word в соответствии с правилами раскрытия выражений, приведенными выше. Затем переменной name поочередно присваиваются полученные значения, и каждый раз выполняется список команд l ist . Если » in word » пропущено, то список команд list выполняется один раз для каждого позиционного параметра, который задан.

В Linux имеется программа seq , которая воспринимает в качестве аргументов два числа и выдает последовательность всех чисел, расположенных между заданными. С помощью этой команды можно заставить for в bash работать точно так же, как аналогичный оператор работает в обычных языках программирования. Для этого достаточно записать цикл for следующим образом:

for a in $( seq 1 10 ) ; do

Эта команда выводит на экран содержимое 10-ти файлов: » file_1″, . «file_10».

5.8.6 Операторы while и until

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

while list1 do list2 done.

while [ -d mydirectory ] ; do

ls -l mydirectory >> logfile

echo — SEPARATOR — >> logfile

Такая программа будет протоколировать содержание каталога «mydirectory» ежеминутно до тех пор, пока директория существует.

Оператор until аналогичен оператору while :

until list1 do list2 done.

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

5.8.7 Функции

Синтаксис

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

Причем слово function не обязательно, name определяет имя функции, по которому к ней можно обращаться, а тело функции состоит из списка команд list , находящегося между < и >. Этот список команд выполняется каждый раз, когда имя name задано как имя вызываемой команды. Отметим, что функции могут задаваться рекурсивно, так что разрешено вызывать функцию, которую мы задаем, внутри нее самой.

Функции выполняются в контексте текущей оболочки: для интерпретации функции новый процесс не запускается (в отличие от выполнения скриптов оболочки).

Аргументы

Когда функция вызывается на выполнение, аргументы функции становятся позиционными параметрами (positional parameters) на время выполнения функции. Они именуются как $n , где n — номер аргумента, к которому мы хотим получить доступ. Нумерация аргументов начинается с 1, так что $1 — это первый аргумент. Мы можем также получить все аргументы сразу с помощью $* , и число аргументов с помощью $# . Позиционный параметр 0 не изменяется.

Если в теле функции встречается встроенная команда return , выполнение функции прерывается и управление передается команде, стоящей после вызова функции. Когда выполнение функции завершается, позиционным параметрам и специальному параметру # возвращаются те значения, которые они имели до начала выполнения функции.

Локальные переменные (local)

Если мы хотим создать локальный параметр, можно использовать ключевое слово local . Синтаксис ее задания точно такой же, как и для обычных параметров, только определению предшествует ключевое слово local: local name=value .

Вот пример задания функции, реализующей упоминавшуюся выше команду seq :

while [ $2 != $I ]; do

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

Функция вычисления факториала fact

Еще один пример:

echo $(( $1 * $( fact $(( $1 — 1 )) ) ))

Это функция факториала, пример рекурсивной функции. Обратите внимание на арифметическое расширение и подстановку команд.

Источник