Я спробував оголосити булеву змінну в сценарії оболонки, використовуючи наступний синтаксис:

variable=$false

variable=$true

Це правильно? Крім того, якщо я хотів би оновити цю змінну, я використовував би той самий синтаксис? Нарешті, чи правильний наступний синтаксис використання булевих змінних як виразів?

if [ $variable ]

if [ !$variable ]

Переглянута відповідь (12 лютого 2014 р.)

the_world_is_flat=true
# ...do something interesting...
if [ "$the_world_is_flat" = true ] ; then
    echo 'Be careful not to fall off!'
fi

Оригінальний відповідь

Застереження: https://stackoverflow.com/a/21210966/89391

the_world_is_flat=true
# ...do something interesting...
if $the_world_is_flat ; then
    echo 'Be careful not to fall off!'
fi

Від: Використання булевих змінних у Bash

Причина, до якої включена оригінальна відповідь, полягає в тому, що коментарі до редакції 12 лютого 2014 року стосуються лише оригінальної відповіді, і багато коментарів помиляються, коли асоціюються з переглянутою відповіддю. Наприклад, коментар Денніса Вільямсона про баш, побудований true2 червня 2010 року, стосується лише оригінальної відповіді, а не переглянутої.

TL; DR

bool=true

if [ "$bool" = true ]

Питання з відповіді Міку ( оригінальна )

Я не рекомендую приймати відповідь ¹ . Його синтаксис досить, але він має деякі недоліки.

Скажімо, у нас є така умова.

if $var; then
  echo 'Muahahaha!'
fi

У наступних випадках ² ця умова буде оцінена як справжня та виконана вкладена команда.

# Variable var not defined beforehand. Case 1
var=''  # Equivalent to var="".        Case 2
var=    #                              Case 3
unset var  #                           Case 4
var='<some valid command>'  #          Case 5

Зазвичай ви хочете, щоб ваша умова оцінювалась справжньою лише тоді, коли ваша "булева" змінна varв цьому прикладі явно встановлена ​​на істинне. Усі інші випадки небезпечно оманливі!

Останній випадок (№5) особливо неслухняний, оскільки він буде виконувати команду, що міститься в змінній (саме тому умова оцінюється як істинна для дійсних команд ^{3, 4} ).

Ось нешкідливий приклад:

var='echo this text will be displayed when the condition is evaluated'
if $var; then
  echo 'Muahahaha!'
fi

# Outputs:
# this text will be displayed when the condition is evaluated
# Muahahaha!

Цитування ваших змінних безпечніше, наприклад if "$var"; then. У вищезазначених випадках вам слід отримати попередження про те, що команда не знайдена. Але ми все ще можемо зробити краще (див. Мої рекомендації внизу).

^{Також див. Пояснення оригінальної відповіді Міку Майка Холта.}

Питання з відповіддю Гбара

Цей підхід також має несподівану поведінку.

var=false
if [ $var ]; then
  echo "This won't print, var is false!"
fi

# Outputs:
# This won't print, var is false!

Ви б очікували, що вищевказана умова оцінюється як хибна, таким чином, ніколи не виконуючи вкладене твердження. Сюрприз!

Цитуючи значення ( "false"), цитуючи змінну ( "$var"), використовуючи testабо [[замість [, не змінювати.

Те , що я дійсно рекомендую:

Ось такі способи рекомендую вам перевірити свої "булеві". Вони працюють, як очікувалося.

bool=true

if [ "$bool" = true ]; then
if [ "$bool" = "true" ]; then

if [[ "$bool" = true ]]; then
if [[ "$bool" = "true" ]]; then
if [[ "$bool" == true ]]; then
if [[ "$bool" == "true" ]]; then

if test "$bool" = true; then
if test "$bool" = "true"; then

Всі вони майже рівнозначні. Вам доведеться набрати ще кілька натискань клавіш, ніж підходи в інших відповідях ⁵ , але ваш код буде більш захисним.

Виноски

1. Відповідь Міку відтоді було відредаговано і більше не містить (відомих) вад.
2. Не вичерпний список.
3. Дійсна команда в цьому контексті означає команду, яка існує. Не має значення, правильно чи неправильно використовується команда. Напр., Як man womanі раніше, вважатимуться дійсною командою, навіть якщо такої сторінки не існує.
4. Що стосується недійсних (неіснуючих) команд, Bash просто скаржиться, що команду не знайдено.
5. Якщо ви дбаєте про довжину, перша рекомендація найкоротша.

Тут, мабуть, є деякі непорозуміння щодо вбудованого Bash true, а точніше, щодо того, як Bash розширює та інтерпретує вирази всередині дужок.

Код у відповіді miku абсолютно не має нічого спільного з вбудованим Bash true, а /bin/trueтакож будь-яким іншим ароматом trueкоманди. У цьому випадку trueце не що інше, як звичайна символьна рядок, і жоден виклик trueкоманди / вбудованого не робиться ні за призначенням змінної, ні за допомогою оцінки умовного виразу.

Наступний код функціонально ідентичний коду у відповіді miku:

the_world_is_flat=yeah
if [ "$the_world_is_flat" = yeah ]; then
    echo 'Be careful not to fall off!'
fi

Тільки різниця полягає в тому , що чотири символи порівнюваних «у», «е», «а» і «ч» замість «т», «г», «і», і «е». Це воно. Немає спроб викликати команду чи вбудовану назву yeah, а також немає (на прикладі Міку) ніяких спеціальних операцій, коли Bash розбирає маркер true. Це просто рядок і зовсім довільний.

Оновлення (19.02.2014): Після переходу за посиланням у відповіді Міку, тепер я бачу, звідки йде певна плутанина. У відповіді Міку використовуються одинарні дужки, але фрагмент коду, на який він посилається, не використовує дужки. Це просто:

the_world_is_flat=true
if $the_world_is_flat; then
  echo 'Be careful not to fall off!'
fi

Обидва фрагменти коду будуть вести себе однаково, але дужки повністю змінюють те, що відбувається під капотом.

Ось що робить Bash у кожному випадку:

Немає дужок:

1. Розгорніть змінну $the_world_is_flatдо рядка "true".
2. Спроба проаналізувати рядок "true"як команду.
3. Знайдіть і запустіть trueкоманду (вбудовану або /bin/trueзалежно від версії Bash).
4. Порівняйте код виходу trueкоманди (який завжди дорівнює 0) з 0. Згадайте, що у більшості оболонок вихідний код 0 вказує на успіх, а все інше вказує на невдачу.
5. Так як код виходу був 0 (успіх), виконати в ifзаяві , в thenположення

Дужки:

1. Розгорніть змінну $the_world_is_flatдо рядка "true".
2. Розбираємо тепер повністю розширений умовний вираз, який має форму string1 = string2. =Оператор в Bash порівняння рядків оператора. Тому...
3. Зробіть порівняння рядків на "true"та "true".
4. Так, дві струни були однаковими, тому значення умовного є істинним.
5. Виконайте пункт ifзаяви then.

Код без дужок працює, тому що trueкоманда повертає вихідний код 0, що вказує на успіх. Скорочений код працює, тому що значення $the_world_is_flatідентичне буквеному trueрядку праворуч від =.

Для того, щоб повернути точку додому, розгляньте наступні два фрагменти коду:

Цей код (якщо він працює з root правами) перезавантажить ваш комп'ютер:

var=reboot
if $var; then
  echo 'Muahahaha! You are going down!'
fi

Цей код просто друкує "Приємна спроба". Команда перезавантаження не викликається.

var=reboot
if [ $var ]; then
  echo 'Nice try.'
fi

Оновлення (2014-04-14) Щоб відповісти на запитання у коментарях щодо різниці між =та ==: AFAIK, різниці немає. ==Оператор є Bash-специфічний синонім =, і, наскільки я бачив, вони працюють точно так же у всіх контекстах.

Однак зауважте, що я конкретно говорю про оператори порівняння =і ==рядків, що використовуються в [ ]або [[ ]]тестах. Я не стверджую , що =і ==є взаємозамінними всюди в Баш.

Наприклад, ви, очевидно, не можете виконати присвоєння змінної ==, наприклад var=="foo"((технічно це ви можете зробити, але значення varбуде "=foo", тому що Bash тут не бачить ==оператора, він бачить оператора =(призначення), а потім буквальне значення ="foo", яке щойно стає "=foo").

Крім того, хоча вони =і ==взаємозамінні, ви повинні мати на увазі, що те, як працюють ці тести , залежить від того, використовуєте ви його всередині, [ ]або [[ ]], а також від того, цитуються операнди чи ні. Докладніше про це можна прочитати в Посібнику з розширеного сценарію Bash: 7.3 Інші оператори порівняння (прокрутіть до обговорення =та ==).

Використовуйте арифметичні вирази.

#!/bin/bash

false=0
true=1

((false)) && echo false
((true)) && echo true
((!false)) && echo not false
((!true)) && echo not true

Вихід:

справжній
не хибний

Довга історія:

Булів немає в Баші

Bash має булеві вирази щодо порівняння та умов. Це означає, що ви можете оголосити та порівняти в Bash - це рядки та цифри. Це воно.

Де б ви не бачили trueабо falseв Bash, це або рядок, або команда / вбудований, який використовується лише для його вихідного коду.

Цей синтаксис ...

if true; then ...

по суті ...

if COMMAND; then ...

Ця умова справедлива щоразу, коли команда повертає код виходу 0. trueІ falseє вбудованими Bash, а іноді й окремими програмами, які не роблять нічого, крім повернення відповідного коду виходу.

Умовне вище є еквівалентним:

COMMAND && ...

Використовуючи квадратні дужки або testкоманду, ви покладаєтесь на код виходу цієї конструкції. Майте на увазі , що [ ]і [[ ]]також в декількох команд / вбудовані функції, як і будь-який інший. Тому ...

if [[ 1 == 1 ]]; then echo yes; fi

відповідає

if COMMAND; then echo yes; fi

і COMMANDось це[[ 1 == 1 ]]

if..then..fiКонструкція просто синтаксичний цукор. Ви завжди можете просто запустити команди, розділені подвійною амперсом та для того ж ефекту:

[[ 1 == 1 ]] && echo yes

Під час використання trueта falseв цих тестових конструкціях ви фактично передаєте лише рядок "true"або "false"команду тестування. Ось приклад:

Вірите чи ні, але всі ці умови дають однаковий результат :

if [[ false ]]; then ...
if [[ "false" ]]; then ...
if [[ true ]]; then ...
if [[ "true" ]]; then ...

TL; DR; завжди порівнюйте з рядками або числами

Щоб зробити це зрозумілим майбутнім читачам, я б рекомендував завжди використовувати цитати навколо trueта false:

ДО

if [[ "${var}" == "true" ]]; then ...
if [[ "${var}" == "false" ]]; then ...
if [[ -n "${var:-}" ]]; then echo "var is not empty" ...

НЕ ДАЙТЕ

if [ ... ]; then ...  # Always use double square brackets in bash!
if [[ "${var}" ]]; then ...  # This is not as clear or searchable as -n
if [[ "${var}" != true ]]; then ...  # Creates impression of Booleans
if [[ "${var}" -eq "true" ]]; then ...  # `-eq` is for numbers and doesn't read as easy as `==`

Можливо

if [[ "${var}" != "true" ]]; then ...  # Creates impression of Booleans. It can be used for strict checking of dangerous operations. This condition is false for anything but the literal string "true".

Давним-давно, коли все, що у нас було sh, булеви, де оброблялися, покладаючись на конвенцію testпрограми, де testповертає помилковий статус виходу, якщо працювати без будь-яких аргументів.

Це дозволяє думати про змінну, яка не встановлена ​​як помилкова та змінна, встановлена ​​на будь-яке значення як істинне. Сьогодні testце вбудований в Bash і широко відомий своїм односимвольним псевдонімом [(або виконуваним файлом для використання в оболонках, яких не вистачає, як зазначає dolmen):

FLAG="up or <set>"

if [ "$FLAG" ] ; then
    echo 'Is true'
else
    echo 'Is false'
fi

# Unset FLAG
#    also works
FLAG=

if [ "$FLAG" ] ; then
    echo 'Continues true'
else
    echo 'Turned false'
fi

Через цитування умов, сценаристи вважають за краще використовувати складну команду, [[яка імітує test, але має приємніший синтаксис: змінні з пробілами не потрібно цитувати; можна використовувати &&і ||як логічні оператори із дивним пріоритетом, і в обмеженнях кількості термінів немає обмежень POSIX.

Наприклад, щоб визначити, чи встановлено FLAG, а COUNT - число більше 1:

FLAG="u p"
COUNT=3

if [[ $FLAG  && $COUNT -gt '1' ]] ; then
    echo 'Flag up, count bigger than 1'
else
    echo 'Nope'
fi

Цей матеріал може заплутатися, коли потрібні пробіли, рядки нульової довжини та нульові змінні, а також коли ваш сценарій повинен працювати з декількома оболонками.

Як я можу оголосити і використовувати булеві змінні в сценарії оболонки?

На відміну від багатьох інших мов програмування, Bash не відокремлює свої змінні за "типом". [1]

Тож відповідь досить зрозуміла. У Bash немає жодної булевої змінної .

Однак:

За допомогою заяви заяви ми можемо обмежити присвоєння значення змінним. [2]

#!/bin/bash
declare -ir BOOL=(0 1) # Remember BOOL can't be unset till this shell terminates
readonly false=${BOOL[0]}
readonly true=${BOOL[1]}

# Same as declare -ir false=0 true=1
((true)) && echo "True"
((false)) && echo "False"
((!true)) && echo "Not True"
((!false)) && echo "Not false"

rВаріант в declareі readonlyвикористовується для стану явно , що змінні тільки для читання . Сподіваюся, мета зрозуміла.

Замість того, щоб підробляти булеві та залишати пастку для майбутніх читачів, чому б просто не використати кращу цінність, ніж істинна та хибна?

Наприклад:

build_state=success
if something-horrible; then
  build_state=failed
fi

if [[ "$build_state" == success ]]; then
  echo go home; you are done
else
  echo your head is on fire; run around in circles
fi

POSIX (інтерфейс портативної операційної системи)

Я пропускаю тут ключовий момент, який полягає в мобільності. Тому мій заголовок має POSIX у собі.

За суті, все голосували відповіді правильні, за винятком вони Bash -специфічні занадто багато.

В основному я хочу лише додати більше інформації про портативність.

1. [ і ] дужки типу in [ "$var" = true ]не потрібні, і ви можете їх опустити і використовувати testкоманду безпосередньо:

   test "$var" = true && yourCodeIfTrue || yourCodeIfFalse

   Важлива примітка: я більше не рекомендую це робити, оскільки це повільно застаріло і складніше поєднувати кілька заяв.

2. Уявіть собі , що ці слова trueі falseозначає оболонки, тест самі:

   echo $(( true ))

   0

   echo $(( false ))

   1

   Але використовуючи лапки:

   echo $(( "true" ))

   bash: "true": syntax error: operand expected (error token is ""true"")
   sh (dash): sh: 1: arithmetic expression: expecting primary: ""true""

   Те саме стосується:

   echo $(( "false" ))

   Оболонка не може інтерпретувати її, крім рядка. Я сподіваюся, що ви отримуєте уявлення про те, наскільки добре це використання належного ключового слова без лапок .

   Але ніхто не говорив про це у попередніх відповідях.

3. Що це означає? Ну, кілька речей.

   • Ви повинні звикнути до булевих ключових слів, насправді трактуються як числа, тобто true= 0і false= 1, пам’ятайте, що всі ненульові значення трактуються якfalse .

   • Оскільки вони розглядаються як числа, ви також повинні ставитися до них так, тобто якщо ви визначаєте змінну, скажімо:

     var_bool=true
     echo "$var_bool"

      true

     ви можете створити протилежне його значення за допомогою:

     var_bool=$(( 1 - $var_bool ))  # same as $(( ! $var_bool ))
     echo "$var_bool"

     1

   Як ви самі бачите, оболонка робить друкований trueрядок вперше, коли ви його використовуєте, але з тих пір це все працює через число, що 0представляє trueабо 1представляє falseвідповідно.

Нарешті, що слід робити з усією цією інформацією

• По-перше, одна добра звичка буде призначати 0замість true; 1замістьfalse .

• Другою доброю звичкою було б перевірити, чи змінна є / не дорівнює нулю:

  if [ "$var_bool" -eq 0 ]; then
       yourCodeIfTrue
  else
       yourCodeIfFalse
  fi

Щодо синтаксису, то це проста методика, яку я використовую (на прикладі) для послідовного та добросовісного управління булевою логікою:

# Tests
var=
var=''
var=""
var=0
var=1
var="abc"
var=abc

if [[ -n "${var}" ]] ; then
    echo 'true'
fi
if [[ -z "${var}" ]] ; then
    echo 'false'
fi

# Results
# var=        # false
# var=''      # false
# var=""      # false
# var=0       # true
# var=1       # true
# var="abc"   # true
# var=abc     # true

Якщо змінна ніколи не оголошується, відповідь така: # false

Отже, простим способом встановити змінну в true (використовуючи цю методологію синтаксису) було б var=1; навпаки,var='' .

Довідка:

-n = Вірно, якщо довжина рядка var не дорівнює нулю.

-z = Вірно, якщо довжина рядка var дорівнює нулю.

У багатьох мовах програмування булівський тип є або реалізується як підтип цілого числа, де він trueповодиться як 1і falseповодиться як 0:

• Булева в С

• Булева в Python

• Булева мова на Java

Математично булева алгебра нагадує цілочисельну арифметичну модуль 2. Тому, якщо мова не забезпечує рідний булевий тип, найбільш природним та ефективним рішенням є використання цілих чисел. Це працює майже з будь-якою мовою. Наприклад, у Bash ви можете:

# val=1; ((val)) && echo "true" || echo "false"
true
# val=0; ((val)) && echo "true" || echo "false"
false

man bash :

((вираз))

Вираз оцінюється за правилами, описаними нижче в АРИТМЕТИЧНІЙ ОЦІНКІ. Якщо значення виразу не дорівнює нулю, стан повернення дорівнює 0; інакше статус повернення дорівнює 1. Це абсолютно рівнозначно вираженню "вираз".

Білл Паркер отримує голосування , оскільки його визначення відмінені від звичайної конвенції коду. Як правило, true визначається як 0, а false - ненульовий. 1 буде працювати для помилкових, як 9999 та -1. Те саме з функціями повернення значень - 0 - це успіх, і все, що не має нуля, - це збій. Вибачте, я ще не маю довіри на вулиці, щоб проголосувати або відповісти на нього безпосередньо.

Bash рекомендує використовувати подвійні дужки як звичку замість одинарних дужок, а посилання, яке надав Майк Холт, пояснює відмінності в тому, як вони працюють. 7.3. Інші оператори порівняння

З одного боку, -eqце чисельний оператор, тому маючи код

#**** NOTE *** This gives error message *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

видасть заяву про помилку, очікуючи цілого виразу. Це стосується будь-якого параметра, оскільки жодне не є цілим значенням. Однак якщо ми поставимо навколо нього подвійні дужки, він не видасть заяву про помилку, але дасть неправильне значення (ну, у 50% можливих перестановок). Він оцінюватиметься як [[0 -eq true]] = успіх, але також і [[0 -eq false]] = успіх, що невірно (хммм .... як щодо цього вбудованого чисельного значення?).

#**** NOTE *** This gives wrong output *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then

Є й інші умовні перестановки, які також дадуть неправильний вихід. В основному, що завгодно (крім переліченої вище умови помилки), яка встановлює змінну чисельному значенню та порівнює її з істинним / хибним вбудованим, або встановлює змінну істинним / хибним вбудованим і порівнює її з числовим значенням. Крім того, все, що встановлює змінну на справжній / хибний вбудований і робить порівняння, використовуючи -eq. Тому уникайте -eqбулевих порівнянь та уникайте використання числових значень для булевих порівнянь. Ось підсумок перестановок, які дадуть недійсні результати:

# With variable set as an integer and evaluating to true/false
# *** This will issue error warning and not run: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

# With variable set as an integer and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then
#
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" == true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then


# With variable set as an true/false builtin and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = 0 ]; then
#
if [[ "${The_world_is_flat}" = 0 ]]; then
#
if [ "${The_world_is_flat}" == 0 ]; then
#
if [[ "${The_world_is_flat}" == 0 ]]; then

Отже, тепер до того, що працює. Використовуйте справжні / хибні вбудовані для порівняння та оцінок (як зазначив Майк Хант, не вкладайте їх у лапки). Потім використовуйте або один, або подвійний знак рівності (= або ==) і одно- або подвійні дужки ([] або [[]]). Особисто мені подобається знак подвійних рівностей, тому що він нагадує мені логічні порівняння в інших мовах програмування, і подвійні лапки лише тому, що мені подобається вводити текст. Отже, ці роботи:

# With variable set as an integer and evaluating to true/false
# *** These statements will work properly: *****
#
The_world_is_flat=true/false;
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then

Там у вас є.

Мої висновки та пропозиції дещо відрізняються від інших публікацій. Я виявив, що я можу в основному використовувати "булі", як в будь-якій "звичайній" мові, без запропонованих "стрибків з обручем" ...

Немає потреби в []явних порівняннях рядків ... Я спробував декілька дистрибутивів Linux. Я протестував Bash, Dash і BusyBox . Результати завжди були однаковими. Я не впевнений, про що говорять у первинних голосуючих публікаціях. Можливо, часи змінилися, і це все, що там є?

Якщо встановити змінну true, вона згодом оцінюється як "стверджувальна" в умовному режимі. Встановіть його false, і він оцінить як "негатив". Дуже прямо! Єдине застереження - це те, що невизначена змінна також оцінює як істинну ! Було б добре, якби це зробило навпаки (як це було б у більшості мов), але це трюк - вам просто потрібно явно ініціалізувати свої булеві на істинне чи хибне .

Чому це працює саме так? Ця відповідь у два рази. A) true / false в оболонці справді означає "без помилки" проти "помилки" (тобто 0 проти будь-чого іншого). B) true / false не є значеннями, а швидше твердженнями в сценарії оболонок! Щодо другої точки, виконання trueабо falseна рядку самостійно встановлює значення повернення для блоку, в якому ви знаходитесь, до цього значення, тобто falseє оголошенням "помилки, що виникає", де справжня "очищує" це. Використовуючи його з присвоєнням змінній "повертає" цю змінну. An невизначені змінні оцінює , як trueв умовному тому , що в рівній мірі має значення 0 або «ні» сталася помилка.

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

#!/bin/sh

# Not yet defined...
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=true
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=false
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

Врожайність

when set to
it evaluates to true
when set to true
it evaluates to true
when set to false
it evaluates to false

Ось простий приклад, який працює для мене:

temp1=true
temp2=false

if [ "$temp1" = true ] || [ "$temp2" = true ]
then
    echo "Do something." 
else
    echo "Do something else."
fi

Ось реалізація короткої руки if true.

# Function to test if a variable is set to "true"
_if () {
    [ "${1}" == "true" ] && return 0
    [ "${1}" == "True" ] && return 0
    [ "${1}" == "Yes" ] && return 0
    return 1
}

Приклад 1

my_boolean=true

_if ${my_boolean} && {
    echo "True Is True"
} || {
    echo "False Is False"
}

Приклад 2

my_boolean=false
! _if ${my_boolean} && echo "Not True is True"

Я вважав наявні відповіді заплутаними.

Особисто мені просто хочеться мати щось подібне до C.

Цей фрагмент працює багато разів на день у виробництві:

snapshotEvents=true

if ($snapshotEvents)
then
    # Do stuff if true
fi

і щоб все було щасливим, я перевірив:

snapshotEvents=false

if !($snapshotEvents)
then
    # Do stuff if false
fi

Що також добре працювало.

$snapshotEventsОцінює вміст значення змінної. Тож вам потрібна $.

Дуже не потрібні дужки, я просто вважаю їх корисними.

• Тестовано на: GNU Bash, версія 4.1.11 (2) -випуск

• Посібник Баша для початківців , Machtelt Garrels, v1.11, 2008

Ось покращення щодо оригінальної відповіді Міку, яка стосується занепокоєння Денніса Вільямсона щодо випадку, коли змінна не встановлена:

the_world_is_flat=true

if ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

І перевірити, чи є змінна false:

if ! ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

Щодо інших випадків із неприємним вмістом у змінній, це проблема з будь-яким зовнішнім входом, який подається програмі.

Будь-який зовнішній вхід повинен бути підтверджений, перш ніж довіряти йому. Але цю перевірку потрібно зробити лише один раз, коли цей вхід буде отримано.

Це не повинно впливати на ефективність програми, роблячи це при кожному використанні змінної, як пропонує Денніс Вільямсон .

Ви можете використовувати shFlags .

Це дає можливість визначити: DEFINE_bool

Приклад:

DEFINE_bool(big_menu, true, "Include 'advanced' options in the menu listing");

З командного рядка можна визначити:

sh script.sh --bigmenu
sh script.sh --nobigmenu # False

Це тест на швидкість щодо різних способів тестування "булевих" значень у Bash:

#!/bin/bash
rounds=100000

b=true # For true; b=false for false
type -a true
time for i in $(seq $rounds); do command $b; done
time for i in $(seq $rounds); do $b; done
time for i in $(seq $rounds); do [ "$b" == true ]; done
time for i in $(seq $rounds); do test "$b" == true; done
time for i in $(seq $rounds); do [[ $b == true ]]; done

b=x; # Or any non-null string for true; b='' for false
time for i in $(seq $rounds); do [ "$b" ]; done
time for i in $(seq $rounds); do [[ $b ]]; done

b=1 # Or any non-zero integer for true; b=0 for false
time for i in $(seq $rounds); do ((b)); done

Це надрукувало б щось подібне

true is a shell builtin
true is /bin/true

real    0m0,815s
user    0m0,767s
sys     0m0,029s

real    0m0,562s
user    0m0,509s
sys     0m0,022s

real    0m0,829s
user    0m0,782s
sys     0m0,008s

real    0m0,782s
user    0m0,730s
sys     0m0,015s

real    0m0,402s
user    0m0,391s
sys     0m0,006s

real    0m0,668s
user    0m0,633s
sys     0m0,008s

real    0m0,344s
user    0m0,311s
sys     0m0,016s

real    0m0,367s
user    0m0,347s
sys     0m0,017s

Альтернативно - використовувати функцію

is_ok(){ :;}
is_ok(){ return 1;}
is_ok && echo "It's OK" || echo "Something's wrong"

Визначити функцію менш інтуїтивно, але перевірити її повернене значення дуже просто.

Bash дійсно заплутує питання з подібними [, [[, ((, $((і т.д.

Усі крокують на кодових просторах один одного. Я здогадуюсь це здебільшого історичне, де Баш мусив робити вигляд, що буває shчас від часу.

Більшу частину часу я можу просто вибрати метод і дотримуватися його. У цьому випадку я схильний декларувати (бажано, у загальному бібліотечному файлі, який я можу включити .у свій фактичний сценарій (и)).

TRUE=1; FALSE=0

Тоді я можу використовувати ((... ))арифметичний оператор для перевірки таким чином.

testvar=$FALSE

if [[ -d ${does_directory_exist} ]]
then
    testvar=$TRUE;
fi

if (( testvar == TRUE )); then
    # Do stuff because the directory does exist
fi

1. Ви повинні бути дисциплінованими. Ви testvarповинні бути налаштовані на $TRUEабо $FALSEпостійно.

2. У ((... ))компараторах вам не потрібні попередні $, що робить його більш читабельним.

3. Я можу використовувати ((... ))бо $TRUE=1і $FALSE=0, наприклад , числові значення.

4. Мінусом доводиться $епізодично використовувати :

   testvar=$TRUE

   що не так симпатично.

Це не ідеальне рішення, але воно охоплює кожен випадок, коли мені потрібен такий тест.