8.1. Операторы | Популярный Linux

присваивание

variable
assignment

Инициализация переменной или изменение ее значения

=

Универсальный оператор присваивания, пригоден как для сравнения целых чисел, так и для сравнения строк.

1. var=27
2. category=minerals  # Пробелы до и после оператора «=» — недопустимы.

Пусть вас не смущает, что оператор присваивания («=»), по своему внешнему виду, совпадает с оператором сравнения (=). #    Здесь знак «=»  выступает в качестве оператора сравнения if [ «$string1« = «$string2« ] # if [ «X$string1» = «X$string2» ] более отказоустойчивый вариант, # предохраняет от «сваливания» по ошибке в случае, когда одна из переменных пуста. # (добавленные символы «X» компенсируют друг друга.) then    command fi

арифметические операторы

+

сложение

—

вычитание

*

умножение

/

деление

**

возведение в степень

1. # В Bash, начиная с версии 2.02, был введен оператор возведения в степень — «**».
2. let «z=5**3»
3. echo «z = $z«   # z = 125

%

модуль (деление по модулю), возвращает остаток от деления

1. bash$ echo `expr 5 % 3`
2. 2
3.        

Этот оператор может применяться в алгоритмах генерации псевдослучайных чисел в заданном диапазоне (см. Пример 9-23 и Пример 9-26), для форматирования вывода на экран (см. Пример 25-15 и Пример A-7), и даже для генерации простых чисел (см. Пример A-18). На удивление часто операцию деления по модулю можно встретить в различных численных алгоритмах.

Пример 8-1. Наибольший общий делитель

1. #!/bin/bash
2. # gcd.sh: поиск наибольшего общего делителя
3. #         по алгоритму Эвклида
4. #  Под «наибольшим общим делителем» (нод) двух целых чисел
5. #+ понимается наибольшее целое число, которое делит оба делимых без остатка.
6. #  Алгоритм Эвклида выполняет последовательное деление.
7. #  В каждом цикле,
8. #+ делимое  <—  делитель
9. #+ делитель <—  остаток
10. #+ до тех пор, пока остаток не станет равным нулю (остаток = 0).
11. #+ The gcd = dividend, on the final pass.
12. #
13. #  Замечательное описание алгоритма Эвклида можно найти
14. #  на сайте Jim Loy, <a href=»http://www.jimloy.com/number/euclids.htm.
15. #» title=»http://www.jimloy.com/number/euclids.htm.
16. #»>http://www.jimloy.com/number/euclids.htm.
17. #</a> ——————————————————
18. # Проверка входных параметров
19. ARGS=2
20. E_BADARGS=65
21. if [ $# -ne «$ARGS« ]
22. then
23.   echo «Порядок использования: `basename $0` первое-число второе-число»
24.   exit $E_BADARGS
25. fi
26. # ——————————————————
27. gcd ()
28. {
29.                                  #  Начальное присваивание.
30.   dividend=$1                    #  В сущности, не имеет значения
31.   divisor=$2                     #+ какой из них больше.
32.                                  #  Почему?
33.   remainder=1                    #  Если переменные неинициализировать,
34.                                  #+ то работа сценария будет прервана по ошибке
35.                                  #+ в первом же цикле.
36.   until [ «$remainder« -eq 0 ]
37.   do
38.     let «remainder = $dividend % $divisor«
39.     dividend=$divisor            # Повторить цикл с новыми исходными данными
40.     divisor=$remainder
41.   done                           # алгоритм Эвклида
42. }                                # последнее $dividend и есть нод.
43. gcd $1 $2
44. echo; echo «НОД чисел $1 и $2 = $dividend«; echo
45. # Упражнение :
46. # ———
47. #  Вставьте дополнительную проверку входных аргументов,
48. #+ и предусмотрите завершение работы сценария с сообщением об ошибке, если
49. #+ входные аргументы не являются целыми числами.
50. exit 0

+=

«плюс-равно» (увеличивает значение переменной на заданное число)

let "var += 5" значение переменной var будет увеличено на 5.

-=

«минус-равно» (уменьшение значения переменной на заданное число)

*=

«умножить-равно» (умножить значение переменной на заданное число, результат записать в переменную)

let "var *= 4" значение переменной var будет увеличено в 4 раза.

/=

«слэш-равно» (уменьшение значения переменной в заданное число раз)

%=

«процент-равно» (найти остаток от деления значения переменной на заданное число, результат записать в переменную)

Арифметические операторы очень часто используются совместно с командами expr и let.

Пример 8-2. Арифметические операции

1. #!/bin/bash
2. # От 1 до 6 пятью различными способами.
3. n=1; echo -n «$n «
4. let «n = $n + 1″   # let «n = n + 1»   тоже допустимо
5. echo -n «$n «
6. : $((n = $n + 1))
7. # оператор «:» обязателен, поскольку в противном случае, Bash будет
8. #+ интерпретировать выражение «$((n = $n + 1))» как команду.
9. echo -n «$n «
10. n=$(($n + 1))
11. echo -n «$n «
12. : $[ n = $n + 1 ]
13. # оператор «:» обязателен, поскольку в противном случае, Bash будет
14. #+ интерпретировать выражение «$[ n = $n + 1 ]» как команду.
15. # Не вызывает ошибки даже если «n» содержит строку.
16. echo -n «$n «
17. n=$[ $n + 1 ]
18. #  Не вызывает ошибки даже если «n» содержит строку.
19. #* Старайтесь избегать употребления такой конструкции,
20. #+ поскольку она уже давно устарела и не переносима.
21. echo -n «$n «; echo
22. # Спасибо Stephane Chazelas.
23. exit 0

битовые операции. Битовые операции очень редко используются в сценариях командного интерпретатора. Их главное назначение, на мой взгляд, установка и проверка некоторых значений, читаемых из портов ввода-вывода и сокетов. «Битовые операции» гораздо более уместны в компилирующих языках программирования, таких как C и C++.

битовые операции

<<

сдвигает на 1 бит влево (умножение на 2)

<<=

«сдвиг-влево-равно»

let "var <<= 2" значение переменной var сдвигается влево на 2 бита (умножается на 4)

>>

сдвиг вправо на 1 бит (деление на 2)

>>=

«сдвиг-вправо-равно» (имеет смысл обратный <<=)

&

по-битовое И (AND)

&=

«по-битовое И-равно»

|

по-битовое ИЛИ (OR)

|=

«по-битовое ИЛИ-равно»

~

по-битовая инверсия

!

По-битовое отрицание

^

по-битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)

^=

«по-битовое ИСКЛЮЧАЮЩЕЕ-ИЛИ-равно»

логические операции

&&

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

1. if [ $condition1 ] && [ $condition2 ]
2. # То же самое, что:  if [ $condition1 -a $condition2 ]
3. # Возвращает true если оба операнда condition1 и condition2 истинны…
4. if [[ $condition1 && $condition2 ]]    # То же верно
5. # Обратите внимание: оператор && не должен использоваться внутри [ … ].

оператор &&, в зависимости от контекста, может так же использоваться в И-списках для построения составных команд.

||

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

1. if [ $condition1 ] || [ $condition2 ]
2. # То же самое, что:  if [ $condition1 -o $condition2 ]
3. # Возвращает true если хотя бы один из операндов истинен…
4. if [[ $condition1 || $condition2 ]]    # Also works.
5. # Обратите внимание: оператор || не должен использоваться внутри [ … ].

Bash производит проверку кода возврата КАЖДОГО из операндов в логических выражениях.

Пример 8-3. Построение сложных условий, использующих && и ||

1. #!/bin/bash
2. a=24
3. b=47
4. if [ «$a« -eq 24 ] && [ «$b« -eq 47 ]
5. then
6.   echo «Первая проверка прошла успешно.»
7. else
8.   echo «Первая проверка не прошла.»
9. fi
10. # ОКА:  if [ «$a» -eq 24 && «$b» -eq 47 ]
11. #          пытается выполнить  ‘ [ «$a» -eq 24 ‘
12. #          и терпит неудачу наткнувшись на ‘]’.
13. #
14. #    if [[ $a -eq 24 && $b -eq 24 ]]   это правильный вариант
15. #    (в строке 17 оператор «&&» имеет иной смысл, нежели в строке 6.)
16. #    Спасибо Stephane Chazelas.
17. if [ «$a« -eq 98 ] || [ «$b« -eq 47 ]
18. then
19.   echo «Вторая проверка прошла успешно.»
20. else
21.   echo «Вторая проверка не прошла.»
22. fi
23. #  Опции -a и -o предоставляют
24. #+ альтернативный механизм проверки условий.
25. #  Спасибо Patrick Callahan.
26. if [ «$a« -eq 24 -a «$b« -eq 47 ]
27. then
28.   echo «Третья проверка прошла успешно.»
29. else
30.   echo «Третья проверка не прошла.»
31. fi
32. if [ «$a« -eq 98 -o «$b« -eq 47 ]
33. then
34.   echo «Четвертая проверка прошла успешно.»
35. else
36.   echo «Четвертая проверка не прошла.»
37. fi
38. a=rhino
39. b=crocodile
40. if [ «$a« = rhino ] && [ «$b« = crocodile ]
41. then
42.   echo «Пятая проверка прошла успешно.»
43. else
44.   echo «Пятая проверка не прошла.»
45. fi
46. exit 0

Операторы && и || могут использоваться и в арифметических вычислениях.

1. bash$ echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0))
2. 1 0 1 0
3.        

прочие операции

,

запятая

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

1. let «t1 = ((5 + 3, 7 — 1, 15 — 4))»
2. echo «t1 = $t1«               # t1 = 11
3. let «t2 = ((a = 9, 15 / 3))»  #  Выполняется присваивание «a» = 9,
4.                               #+ а затем вычисляется «t2».
5. echo «t2 = $t2    a = $a«     # t2 = 5    a = 9

Оператор запятая чаще всего находит применение в циклах for. См. Пример 10-12.