Lua
Booleaner in Lua

Bemerkungen

Der boolesche Typ

Booleans und andere Werte

Beim Umgang mit lua ist es wichtig, zwischen den booleschen Werten true und false und Werten, die als wahr oder falsch ausgewertet werden, zu unterscheiden.

In lua gibt es nur zwei Werte, die als falsch ausgewertet werden: nil und false , während alles andere, einschließlich der numerischen 0 , als wahr ausgewertet wird.

Einige Beispiele, was das bedeutet:

if 0 then print("0 is true") end --> this will print "true"
if (2 == 3) then print("true") else print("false") end --> this prints "false"
if (2 == 3) == false then print("true") end --> this prints "true"
if (2 == 3) == nil then else print("false") end
--> prints false, because even if nil and false both evaluate to false,
--> they are still different things.

Logische Operationen

Logische Operatoren in lua geben nicht unbedingt boolesche Werte zurück:

and gibt den zweiten Wert zurück, wenn der erste Wert als wahr ausgewertet wird;

or gibt den zweiten Wert zurück, wenn der erste Wert als falsch ausgewertet wird;

Dies ermöglicht es, den ternären Operator wie in anderen Sprachen zu simulieren:

local var = false and 20 or 30 --> returns 30
local var = true and 20 or 30 --> returns 20
-- in C: false ? 20 : 30

Dies kann auch zum Initialisieren von Tabellen verwendet werden, wenn sie nicht vorhanden sind

tab = tab or {} -- if tab already exists, nothing happens

oder um zu vermeiden, if-Anweisungen zu verwenden, um den Code leichter lesbar zu machen

print(debug and "there has been an error") -- prints "false" line if debug is false
debug and print("there has been an error") -- does nothing if debug is false
-- as you can see, the second way is preferable, because it does not output
-- anything if the condition is not met, but it is still possible.
-- also, note that the second expression returns false if debug is false,
-- and whatever print() returns if debug is true (in this case, print returns nil)

Prüfen, ob Variablen definiert sind

Man kann auch leicht überprüfen, ob eine Variable existiert (wenn sie definiert ist), da nicht vorhandene Variablen nil , was als falsch ausgewertet wird.

local tab_1, tab_2 = {}
if tab_1 then print("table 1 exists") end --> prints "table 1 exists"
if tab_2 then print("table 2 exists") end --> prints nothing

Der einzige Fall, in dem dies nicht zutrifft, ist, wenn eine Variable den Wert " false speichert. In diesem Fall ist sie technisch vorhanden, wird jedoch als "false" ausgewertet. Aus diesem Grund ist es ein schlechtes Design, Funktionen zu erstellen, die je nach Status oder Eingabe " false und " nil . Wir können jedoch noch prüfen, ob wir eine nil oder eine false :

if nil == nil then print("A nil is present") else print("A nil is not present") end
if false == nil then print("A nil is present") else print("A nil is not present") end
-- The output of these calls are:
-- A nil is present!
-- A nil is not present

Bedingte Kontexte

Bedingte Kontexte in Lua ( if , elseif , while , until ) erfordern kein Boolean. Wie viele Sprachen kann jeder Lua-Wert in einer Bedingung erscheinen. Die Regeln für die Bewertung sind einfach:

1. false und nil zählen als falsch.

2. Alles andere gilt als wahr.

   if 1 then
     print("Numbers work.")
   end
   if 0 then
     print("Even 0 is true")
   end
   
   if "strings work" then
     print("Strings work.")
   end
   if "" then
     print("Even the empty string is true.")
   end
   

Logische Operatoren

In Lua können Booleans durch logische Operatoren manipuliert werden . Diese Operatoren enthalten not , and , und or .

In einfachen Ausdrücken sind die Ergebnisse ziemlich einfach:

print(not true) --> false
print(not false) --> true
print(true or false) --> true
print(false and true) --> false

Rangfolge

Die Rangfolge ist ähnlich wie die mathematischen Operatoren unary - , * und + :

• not
• dann and
• dann or

Dies kann zu komplexen Ausdrücken führen:

print(true and false or not false and not true)
print( (true and false) or ((not false) and (not true)) )
    --> these are equivalent, and both evaluate to false

Kurzauswertung

Die Operatoren and und or möglicherweise nur mit dem ersten Operanden ausgewertet werden, sofern der zweite nicht erforderlich ist:

function a()
    print("a() was called")
    return true
end

function b()
    print("b() was called")
    return false
end

print(a() or b())
    --> a() was called
    --> true
    --  nothing else
print(b() and a())
    --> b() was called
    --> false
    --  nothing else
print(a() and b())
    --> a() was called
    --> b() was called
    --> false

Idiomatischer bedingter Operator

Aufgrund der Vorrang der logischen Operatoren, die Möglichkeit für Kurzschnitt - Bewertung und die Bewertung von nicht false und nicht - nil - Werte als true ist, eine idiomatische Konditionaloperator in Lua zur Verfügung:

function a()
    print("a() was called")
    return false
end
function b()
    print("b() was called")
    return true
end
function c()
    print("c() was called")
    return 7
end

print(a() and b() or c())
    --> a() was called
    --> c() was called
    --> 7
    
print(b() and c() or a())
    --> b() was called
    --> c() was called
    --> 7

Aufgrund der Natur der x and a or b Struktur wird a niemals zurückgegeben, wenn es als false ausgewertet wird. Diese Bedingung gibt dann immer b unabhängig davon, was x ist.

print(true and false or 1)  -- outputs 1

Wahrheitstabellen

Logische Operatoren in Lua "geben" keinen Booleschen Wert zurück, sondern eines ihrer Argumente. Verwenden Sie nil für falsch und Zahlen für wahr, wie sie sich verhalten.

print(nil and nil)       -- nil
print(nil and 2)         -- nil
print(1 and nil)         -- nil
print(1 and 2)           -- 2

print(nil or nil)        -- nil
print(nil or 2)          -- 2
print(1 or nil)          -- 1
print(1 or 2)            -- 1

Wie Sie sehen, gibt Lua immer den ersten Wert zurück, durch den die Prüfung fehlschlägt oder erfolgreich ist . Hier sind die Wahrheitstabellen, die das zeigen.

  x  |  y  || and            x  |  y  || or
------------------         ------------------
false|false||  x           false|false||  y   
false|true ||  x           false|true ||  y   
true |false||  y           true |false||  x   
true |true ||  y           true |true ||  x

Für diejenigen, die es brauchen, hier zwei Funktionen, die diese logischen Operatoren darstellen.

function exampleAnd(value1, value2)
  if value1 then
    return value2
  end
  return value1
end

function exampleOr(value1, value2)
  if value1 then
    return value1
  end
  return value2
end

Emulation des ternären Operators mit 'und' oder 'logischen Operatoren.

In lua geben die logischen Operatoren and und or einen der Operanden als Ergebnis anstelle eines booleschen Ergebnisses zurück. Folglich kann dieser Mechanismus genutzt werden, um das Verhalten des ternären Operators zu simulieren, obwohl lua keinen "echten" ternären Operator in der Sprache hat.

Syntax

Bedingung und Wahrheit_expr oder falsey_expr

Verwendung bei der Variablenzuweisung / -initialisierung

local drink = (fruit == "apple") and "apple juice" or "water"

Verwendung im Tabellenkonstruktor

local menu =
{
  meal  = vegan and "carrot" or "steak",
  drink = vegan and "tea"    or "chicken soup"
}

Verwenden Sie als Funktionsargument

print(age > 18 and "beer" or "fruit punch")

Verwenden Sie in return Anweisung

function get_gradestring(student)
  return student.grade > 60 and "pass" or "fail"
end

Vorbehalt

Es gibt Situationen, in denen dieser Mechanismus nicht das gewünschte Verhalten aufweist. Betrachten Sie diesen Fall

local var = true and false or "should not happen"

In einem 'echten' ternären Operator ist der erwartete Wert von var false . In lua, die jedoch and ‚fällt durch‘ Bewertung , da der zweite Operand ist Falsey. Als Ergebnis sollte var should not happen stattdessen should not happen .

Zwei mögliche Problemumgehungen für dieses Problem, Refactor dieser Ausdruck, so dass der mittlere Operand nicht falsch ist. z.B.

local var = not true and "should not happen" or false

oder alternativ, verwenden Sie die klassische if then else konstruieren.