Wie deklarieren und verwenden Sie boolesche Variablen in einem Shell-Skript?

TL; DR

bool=true

if [ "$bool" = true ]

Probleme mit Mikus ( original ) Antwort

Ich empfehle die akzeptierte Antwort nicht ¹. Die Syntax ist hübsch, aber es gibt einige Fehler.

Angenommen, wir haben die folgende Bedingung.

if $var; then
  echo 'Muahahaha!'
fi

In den folgenden Fällen²Wird diese Bedingung zu true ausgewertet und der verschachtelte Befehl ausgeführt.

# 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

Normalerweise soll Ihre Bedingung nur dann als wahr ausgewertet werden, wenn Ihre "boolesche" Variable var in diesem Beispiel explizit auf "wahr" gesetzt ist. Alle anderen Fälle sind gefährlich irreführend!

Der letzte Fall (# 5) ist besonders ungezogen, da er den in der Variablen enthaltenen Befehl ausführt (weshalb die Bedingung für gültige Befehle als wahr ausgewertet wird)^{3, 4}).

Hier ist ein harmloses Beispiel:

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!

Das Zitieren Ihrer Variablen ist sicherer, z. if "$var"; then. In den oben genannten Fällen sollten Sie eine Warnung erhalten, dass der Befehl nicht gefunden wird. Aber wir können es immer noch besser machen (siehe meine Empfehlungen unten).

^{Siehe auch Mike Holts Erklärung zu Mikus ursprünglicher Antwort.}

Probleme mit der Antwort von Hbar

Dieser Ansatz hat auch unerwartetes Verhalten.

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

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

Es ist zu erwarten, dass die obige Bedingung als falsch bewertet wird, sodass die verschachtelte Anweisung niemals ausgeführt wird. Überraschung!

Das Zitieren des Werts ("false"), das Zitieren der Variablen ("$var") oder das Verwenden von test oder [[ anstelle von [ machen keinen Unterschied.

Was ich empfehle:

Ich empfehle Ihnen, Ihre "Booleschen Werte" zu überprüfen. Sie arbeiten wie erwartet.

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

Sie sind alle ziemlich gleichwertig. Sie müssen einige Tastenanschläge mehr eingeben als in den anderen Antworten⁵ aber Ihr Code wird defensiver sein.

Fußnoten

1. Mikus Antwort wurde inzwischen überarbeitet und enthält keine (bekannten) Fehler mehr.
2. Keine vollständige Liste.
3. Ein gültiger Befehl bedeutet in diesem Zusammenhang einen vorhandenen Befehl. Es spielt keine Rolle, ob der Befehl richtig oder falsch verwendet wird. Z.B. man woman wird auch dann als gültiger Befehl betrachtet, wenn keine solche Manpage vorhanden ist.
4. Bei ungültigen (nicht vorhandenen) Befehlen beschwert sich Bash lediglich, dass der Befehl nicht gefunden wurde.
5. Wenn Ihnen die Länge am Herzen liegt, ist die erste Empfehlung die kürzeste.

Es scheint hier ein Missverständnis über die eingebaute true von Bash zu geben, und insbesondere darüber, wie Bash Ausdrücke in Klammern erweitert und interpretiert.

Der Code in mikus Antwort hat absolut nichts mit der in Bash eingebauten Variable true oder /bin/true oder einer anderen Variante des true-Befehls zu tun. In diesem Fall ist true nichts anderes als eine einfache Zeichenfolge, und es wird nie ein Aufruf des Befehls truebuiltin ausgeführt, weder durch die Zuweisung der Variablen noch durch die Auswertung des Bedingungsausdrucks.

Der folgende Code ist funktional identisch mit dem Code in der Antwort des Miku:

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

Der Unterschied von _/only besteht darin, dass die vier verglichenen Zeichen 'y', 'e', ​​'a' und 'h' anstelle von 't', 'r', 'u' und 'e' sind. . Das ist es. Es wird weder versucht, einen Befehl oder ein eingebautes Kommando mit dem Namen yeah aufzurufen, noch gibt es (in mikus Beispiel) irgendeine spezielle Behandlung, wenn Bash das Token true analysiert. Es ist nur eine Saite und eine völlig willkürliche.

Update (2014-02-19): Nachdem ich dem Link in der Antwort von miku gefolgt bin, sehe ich jetzt, woher die Verwirrung kommt. Mikus Antwort verwendet einfache Klammern, aber der Code-Snippet, mit dem er verknüpft ist, verwendet keine Klammern. Es ist nur:

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

Beide Codeausschnitte werden verhalten auf die gleiche Weise, aber die Klammern ändern vollständig das Geschehen unter der Haube. 

Folgendes tut Bash in jedem Fall:

Keine Klammern:

1. Erweitern Sie die Variable $the_world_is_flat zur Zeichenfolge "true".
2. Versuchen Sie, die Zeichenfolge "true" als Befehl zu analysieren.
3. Suchen Sie den Befehl true und führen Sie ihn aus (je nach Bash-Version entweder ein integrierter Code oder /bin/true).
4. Vergleichen Sie den Exit-Code des true-Befehls (der immer 0 ist) mit 0. Erinnern Sie sich, dass in den meisten Shells ein Exit-Code 0 den Erfolg und alles andere einen Fehler bedeutet.
5. Da der Exit-Code 0 (Erfolg) war, führen Sie die if-Klausel der then-Anweisung aus

Klammern:

1. Erweitern Sie die Variable $the_world_is_flat zur Zeichenfolge "true".
2. Analysieren Sie den nun vollständig erweiterten Bedingungsausdruck in der Form string1 = string2. Der =-Operator ist der Stringvergleich-Operator von bash. So...
3. Führen Sie einen Stringvergleich für "true" und "true" durch.
4. Ja, die beiden Strings waren gleich, also ist der Wert der Bedingung wahr.
5. Führen Sie die if-Klausel der then-Anweisung aus.

Der Code ohne Klammern funktioniert, da der Befehl true einen Beendigungscode von 0 zurückgibt, der den Erfolg angibt. Der eingeklammerte Code funktioniert, da der Wert von $the_world_is_flat mit dem Zeichenfolgenliteral true auf der rechten Seite des = identisch ist.

Um den Punkt nach Hause zu bringen, betrachten Sie die folgenden zwei Codefragmente: 

Dieser Code (wenn er mit Root-Berechtigungen ausgeführt wird) startet Ihren Computer neu:

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

Dieser Code druckt nur "Nice try". Der Neustartbefehl wird nicht aufgerufen.

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

Update (2014-04-14) Zur Beantwortung der Frage in den Kommentaren zum Unterschied zwischen = und ==: AFAIK gibt es keinen Unterschied. Der ==-Operator ist ein Bash-spezifisches Synonym für =. Soweit ich es gesehen habe, funktionieren sie in allen Zusammenhängen genau gleich.

Beachten Sie jedoch, dass ich gerade über die =- und ==-Zeichenfolgenvergleichsoperatoren spreche, die in den [ ]- oder [[ ]]-Tests verwendet werden. Ich schlage nicht vor, dass = und == austauschbar sind überall in der bash.

Beispielsweise können Sie mit == offensichtlich keine Zuweisung von Variablen vornehmen, wie var=="foo" (technisch gesehen können Sie can), aber der Wert von var ist "=foo", da Bash hier keinen ==-Operator sieht , es wird ein = (Zuweisungsoperator) angezeigt, gefolgt von dem Literalwert ="foo", der gerade zu "=foo") wird.

Obwohl = und == austauschbar sind, sollten Sie bedenken, dass die Funktionsweise dieser Tests do davon abhängt, ob Sie sie in [ ] oder [[ ]] verwenden und ob die Operanden zitiert werden oder nicht. Weitere Informationen hierzu finden Sie in Advanced Bash Scripting Guide: 7.3 Andere Vergleichsoperatoren (blättern Sie zur Diskussion von = und ==).

Verwenden Sie arithmetische Ausdrücke.

#!/bin/bash

false=0
true=1

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

Ausgabe:

wahr
nicht falsch

Um es kurz zu machen:

In Bash gibt es keine Booleaner

Was bash hat, ist boolesche Ausdrücke in Bezug auf Vergleich und Bedingungen. Das heißt, was Sie in bash deklarieren und vergleichen können, sind Strings und Zahlen. Das ist es.

Wo immer Sie true oder false in der bash sehen, ist dies entweder ein String oder ein Befehl/builtin, der nur für den Exit-Code verwendet wird.

Diese Syntax ...

if true; then ...

ist im Wesentlichen...

if COMMAND; then ...

Die Bedingung ist immer dann erfüllt, wenn der Befehl den Exit-Code 0 zurückgibt. true und false sind eingebaute Bash-Programme und manchmal auch eigenständige Programme, die nichts weiter tun, als den entsprechenden Exit-Code zurückzugeben.

Die obige Bedingung ist äquivalent zu:

COMMAND && ...

Wenn Sie eckige Klammern oder den Befehl test verwenden, verlassen Sie sich auf den Exit-Code dieses Konstrukts. Denken Sie daran, dass [ ] und [[ ]] auch nur Befehle/Builtins wie jedes andere sind. So ...

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

entspricht

if COMMAND; then echo yes; fi

und die COMMAND ist hier [[ 1 == 1 ]]

Das if..then..fi-Konstrukt ist nur syntaktischer Zucker. Sie können die Befehle immer durch ein doppeltes kaufmännisches Und ausführen, um denselben Effekt zu erzielen:

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

Wenn Sie true und false in diesen Testkonstrukten verwenden, übergeben Sie eigentlich nur den String "true" oder "false" an den Testbefehl. Hier ein Beispiel:

Glauben Sie es oder nicht, aber diese Bedingungen ergeben alle das dasselbe Ergebnis:

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

TL; DR; Vergleichen Sie immer mit Zeichenfolgen oder Zahlen

Um dies für zukünftige Leser klarer zu machen, würde ich empfehlen, immer Anführungszeichen um true und false zu verwenden:

TUN

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

NICHT

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 `==`

Könnte sein

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

Vor langer Zeit, als alles, was wir hatten, sh war, wurden Booleans durch die Verwendung einer Konvention des test-Programms gehandhabt, wobei test einen falschen Exit-Status zurückgibt, wenn er ohne Argumente ausgeführt wird. Dies ermöglicht es, sich eine Variable vorzustellen, die als falsch festgelegt ist, und eine Variable, die auf einen beliebigen Wert als "true" gesetzt ist. Heutzutage ist test in bash integriert und allgemein unter seinem Aliasname [ (oder einer ausführbaren Datei, die in Shells verwendet werden kann, die es fehlt, wie Dolmen anmerkt):

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

Aufgrund von Zitierkonventionen bevorzugen Skriptentwickler die Verwendung des zusammengesetzten Befehls [[, der test nachahmt, aber eine schönere Syntax hat: Variablen mit Leerzeichen müssen nicht in Anführungszeichen gesetzt werden, && und || können als logische Operatoren mit einer seltsamen Vorrangstellung verwendet werden, und es gibt kein POSIX Einschränkungen der Anzahl der Begriffe.

Um beispielsweise festzustellen, ob FLAG gesetzt ist und COUNT eine Zahl größer als 1 ist:

FLAG="u p"
COUNT=3

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

Dieses Zeug kann verwirrend sein wenn Leerzeichen, Zeichenfolgen mit Nulllänge und Nullvariablen benötigt werden und auch wenn Ihr Skript mit mehreren Shells arbeiten muss.

Wie deklarieren und verwenden Sie boolesche Variablen in einem Shell-Skript?

Im Gegensatz zu vielen anderen Programmiersprachen trennt Bash seine Variablen nicht nach "Typ". [1]

Die Antwort ist also ziemlich klar. Es gibt keinen boolean variable in bash . Allerdings:

Mit einer Deklarationsanweisung können wir die Wertzuweisung auf Variablen beschränken. [2]

#!/bin/bash
declare -ir BOOL=(0 1) #remember BOOL can't be unset till this Shell terminate
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"

Die Option r in declare und readonly wird verwendet, um explizit anzugeben, dass die Variablen readonly sind. Hoffe der Zweck ist klar.

Anstatt einen Boolean zu fälschen und künftigen Lesern eine Falle zu stellen, verwenden Sie einen besseren Wert als wahr und falsch.

Zum Beispiel:

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

Bill Parker wird abgelehnt , weil seine Definitionen von der normalen Code-Konvention abweichen. Normalerweise ist true als 0 definiert und false ist ungleich Null. 1 wird für falsch arbeiten, ebenso wie 9999 und -1. Das Gleiche gilt für Funktionsrückgabewerte - 0 ist erfolgreich und alles andere als Null ist ein Fehler. Entschuldigung, ich habe noch nicht die Glaubwürdigkeit der Straße, um zu stimmen oder ihm direkt zu antworten.

Bash empfiehlt, jetzt doppelte Klammern anstelle von einfachen Klammern zu verwenden, und der Link, den Mike Holt gegeben hat, erklärt die Unterschiede in ihrer Funktionsweise. 7.3. Andere Vergleichsoperatoren

Zum einen ist -eq ein numerischer Operator, also mit dem Code

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

gibt eine Fehleranweisung aus und erwartet einen ganzzahligen Ausdruck. Dies gilt für beide Parameter, da keiner der ganzzahligen Werte ist. Wenn wir ihn jedoch in doppelte Klammern setzen, wird keine Fehleraussage ausgegeben, aber es wird ein falscher Wert ausgegeben (in 50% der möglichen Permutationen). Es wird zu [[0-eq true]] = Erfolg ausgewertet, aber auch zu [[0 -eq false]] = Erfolg, was falsch ist (hmmm .... was ist mit dem eingebauten numerischen Wert?).

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

Es gibt andere Permutationen der Bedingung, die ebenfalls zu einer falschen Ausgabe führen. Grundsätzlich alles (mit Ausnahme der oben aufgeführten Fehlerbedingung), das eine Variable auf einen numerischen Wert setzt und sie mit einem True/False-Builtin vergleicht oder eine Variable auf ein True/False-Builtin setzt und sie mit einem Zahlenwert vergleicht. Alles, was eine Variable auf ein true/false-Builtin setzt und einen Vergleich mit -eq durchführt. Vermeiden Sie also -eq für boolesche Vergleiche und vermeiden Sie die Verwendung numerischer Werte für boolesche Vergleiche. Hier ist eine Zusammenfassung der Permutationen, die zu ungültigen Ergebnissen führen werden:

#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

So, jetzt zu dem, was funktioniert. Verwenden Sie True/False-Builtins sowohl für Ihren Vergleich als auch für Ihre Bewertungen (wie Mike Hunt bemerkt hat, fügen Sie sie nicht in Anführungszeichen ein). Verwenden Sie dann entweder oder ein einfaches oder doppeltes Gleichheitszeichen (= oder ==) und entweder einfache oder doppelte Klammern ([] oder [[]]). Ich persönlich mag das doppelte Gleichheitszeichen, weil es mich an logische Vergleiche in anderen Programmiersprachen erinnert, und doppelte Anführungszeichen, nur weil ich gerne tippe. Also diese Arbeit:

#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

Hier hast du es.

In vielen Programmiersprachen ist der boolesche Typ ein Subtyp von Integer oder ist als solcher implementiert: true verhält sich wie 1 und false verhält sich wie 0:

• Boolean in C

• Boolean in Python

• Boolean in Java

Mathematisch , Boolesche Algebra ähnelt Integer-Arithmetik Modulo 2. Wenn also eine Sprache keinen nativen Boolean-Typ bietet, ist die natürlichste und effizienteste Lösung die Verwendung von Integer-Werten. Dies funktioniert mit fast jeder Sprache. In Bash können Sie beispielsweise Folgendes tun:

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

man bash :

((Ausdruck))

Der Ausdruck wird gemäß den unten unter ARITHMETISCHE BEWERTUNG beschriebenen Regeln ausgewertet. Wenn der Wert des Ausdrucks nicht Null ist, ist der Rückgabestatus 0; Andernfalls ist der Rückgabestatus 1. Dies ist genau gleichbedeutend mit "Ausdruck". 

POSIX (Schnittstelle des tragbaren Betriebssystems)

Ich vermisse hier den entscheidenden Punkt, nämlich die Portabilität. Deshalb hat meine Kopfzeile POSIX in sich.

Im Wesentlichen sind alle gewählten Antworten korrekt, mit der Ausnahme, dass sie BASH -spezifisch zu viel sind.

Im Grunde möchte ich nur weitere Informationen zur Portabilität hinzufügen.

1. [ und ] Klammern wie in [ "$var" = true ] sind nicht erforderlich, und Sie können sie weglassen und den Befehl test direkt verwenden:

   test "$var" = true && CodeIfTrue || CodeIfFalse
   

2. Stellen Sie sich vor, was diese Wörter true und false für die Shell bedeuten, testen Sie es selbst:

   echo $((true))
   

   0
   

   echo $((false))
   

   1
   

   Aber mit Anführungszeichen:

   echo $(("true"))
   

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

   Das gleiche gilt für:

   echo $(("false"))
   

   Die Shell kann sie nur als Zeichenfolge interpretieren. Ich hoffe, Sie erhalten eine Vorstellung davon, wie gut das richtige Keyword ohne - Anführungszeichen ist.

   Aber niemand hat es in früheren Antworten gesagt.

3. Was das bedeutet Nun, mehrere Dinge.

   • Sie sollten sich daran gewöhnen, dass die booleschen Schlüsselwörter tatsächlich wie Zahlen behandelt werden, dh true = 0 und false = 1. Denken Sie daran, dass alle Werte ungleich Null wie false behandelt werden.

   • Da sie wie Zahlen behandelt werden, sollten Sie sie auch so behandeln, d. H. Wenn Sie eine Variable definieren, sagen Sie:

     var_a=true
     echo "$var_a"
     

      true
     

     sie können einen entgegengesetzten Wert davon erstellen mit:

     var_a=$((1 - $var_a))
     echo "$var_a"
     

     1
     

     Wie Sie selbst sehen können, druckt Shell zum ersten Mal true string, aber seitdem funktioniert alles über die Nummer 0 bzw. 1.

Zum Schluss, was Sie mit all diesen Informationen tun sollten

• Die erste gute Gewohnheit wäre, 0 anstelle von true zuzuweisen. 1 statt false.

• Die zweite gute Gewohnheit wäre zu testen, ob die Variable gleich Null ist/nicht:

  test "$var" -eq 0 && CodeIfTrue || CodeIfFalse
  

Hier ist eine Implementierung eines 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
}

Beispiel 1

my_boolean=true

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

Beispiel 2  

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

Hier ist ein einfaches Beispiel, das für mich funktioniert:

temp1=true
temp2=false

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

Hier ist eine Verbesserung von mikus original answer , die die Bedenken von Dennis Williamson bezüglich des Falls betrifft, bei dem die Variable nicht gesetzt ist:

the_world_is_flat=true

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

Und um zu testen, ob die Variable false ist:

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

In anderen Fällen mit einem unangenehmen Inhalt in der Variablen ist dies ein Problem bei externen Eingaben, die einem Programm zugeführt werden.

Jede externe Eingabe muss überprüft werden, bevor Sie ihr vertrauen. Diese Bestätigung muss jedoch nur einmal durchgeführt werden, wenn diese Eingabe empfangen wird.

Es muss sich nicht auf die Leistung des Programms auswirken, indem es bei jeder Verwendung der Variablen wie Dennis Williamson vorgeschlagen wird.

Ich fand die vorhandenen Antworten verwirrend.

Ich persönlich möchte nur etwas haben, das wie C aussieht und funktioniert.

Dieser Ausschnitt funktioniert in der Produktion mehrmals täglich:

snapshotEvents=true

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

und um alle glücklich zu machen, habe ich getestet:

snapshotEvents=false

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

Was auch gut funktioniert hat.

Der $snapshotEvents wertet den Inhalt der Variablen aus. Sie benötigen also den $.

Sie brauchen die Klammern nicht wirklich, ich finde sie einfach hilfreich.

• Getestet am: GNU Bash, Version 4.1.11 (2) -release

• Bash Guide für Anfänger , Machtelt Garrels, v1.11, 2008

Meine Erkenntnisse und Vorschläge unterscheiden sich ein wenig von den anderen Beiträgen. Ich fand heraus, dass ich true/false grundsätzlich so verwenden konnte, wie man es in jeder "normalen" Sprache tun würde, ohne das "Hoop Jumping" vorzuschlagen ... Keine Notwendigkeit für [] oder explizite Zeichenkettenvergleiche ... Ich habe mehrere Linux-Distributionen ausprobiert und getestet Bash, Dash und Busybox. Ich bin mit und ohne sie gerannt ... Die Ergebnisse waren immer die gleichen. Ich bin mir nicht sicher, wovon die ursprünglichen Top-Voting-Posts sprechen. Vielleicht haben sich die Zeiten geändert und das ist alles?

Wenn Sie eine Variable auf true setzen, wird sie in einer Bedingung als true ausgewertet. Setzen Sie es auf false, und es wird mit false ausgewertet. Sehr einfach! Die einzige Einschränkung ist, dass eineUNDEFINIERTEVariable auch true ergibt! Es wäre schön, wenn es das Gegenteil tun würde, aber das ist der Trick - Sie müssen Ihre Booleschen Werte nur explizit auf wahr oder falsch setzen .

Siehe das Beispiel unten und die Ergebnisse. Testen Sie es selbst, wenn Sie bestätigen möchten ...

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

Ausbeuten

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

Sie können GFlags verwenden: https://gflags.github.io/gflags/

Es gibt Ihnen die Möglichkeit zu definieren: DEFINE_bool

Beispiel:

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

Über die Befehlszeile können Sie Folgendes definieren:

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