Lua
Booleans in Lua

Opmerkingen

Het Booleaanse type

Booleans en andere waarden

Bij het omgaan met lua is het belangrijk om onderscheid te maken tussen de booleaanse waarden true en false en waarden die als true of false evalueren.

Er zijn slechts twee waarden in lua die evalueren als onwaar: nil en false , terwijl al het andere, inclusief de numerieke 0 waar is.

Enkele voorbeelden van wat dit betekent:

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 bewerkingen

Logische operatoren in lua geven niet noodzakelijk booleaanse waarden terug:

and zal de tweede waarde teruggeven als de eerste waarde waar is;

or retourneert de tweede waarde als de eerste waarde onwaar is;

Dit maakt het mogelijk om de ternaire operator te simuleren, net als in andere talen:

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

Dit kan ook worden gebruikt om tabellen te initialiseren als ze niet bestaan

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

of om te voorkomen dat if-instructies worden gebruikt, waardoor de code gemakkelijker te lezen is

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)

Controleren of variabelen zijn gedefinieerd

Je kunt ook eenvoudig controleren of er een variabele bestaat (als deze is gedefinieerd), omdat niet-bestaande variabelen nil retourneren, wat resulteert in onwaar.

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

Het enige geval waarin dit niet van toepassing is, is wanneer een variabele de waarde false opslaat, in welk geval deze technisch bestaat maar nog steeds als false wordt geëvalueerd. Daarom is het een slecht ontwerp om functies te maken die false en nil retourneren, afhankelijk van de status of invoer. We kunnen echter nog steeds controleren of we nil of 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

Voorwaardelijke contexten

Voorwaardelijke contexten in Lua ( if , elseif , while , until ) geen boolean nodig. Zoals veel talen kan elke Lua-waarde in een voorwaarde worden weergegeven. De regels voor evaluatie zijn eenvoudig:

1. false en nil tellen als onwaar.

2. Al het andere telt als waar.

   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 kunnen booleans worden gemanipuleerd via logische operatoren . Deze operatoren omvatten not , and , en or .

In eenvoudige uitdrukkingen zijn de resultaten vrij eenvoudig:

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

Rangorde

De volgorde van prioriteit is vergelijkbaar met de wiskundige operatoren unary - , * en + :

• not
• dan and
• dan or

Dit kan leiden tot complexe uitdrukkingen:

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

Kortere weg evaluatie

De operatoren and en or kunnen alleen worden geëvalueerd met behulp van de eerste operand, op voorwaarde dat de tweede overbodig is:

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

Idiomatische voorwaardelijke operator

Vanwege de voorrang van de logische operatoren, de mogelijkheid voor sneltoetsevaluatie en de evaluatie van niet- false en niet- nil als true , is een idiomatische voorwaardelijke operator beschikbaar in Lua:

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

Vanwege de aard van de x and a or b structuur wordt a nooit geretourneerd als deze als false evalueert, deze voorwaardelijke zal dan altijd b retourneren, ongeacht wat x is.

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

Waarheidstafels

Logische operators in Lua "retourneren" geen Boolean, maar een van hun argumenten. nil voor onwaar en getallen voor waar, hier is hoe ze zich gedragen.

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

Zoals u ziet, retourneert Lua altijd de eerste waarde waardoor de controle mislukt of slaagt . Hier zijn de waarheidstabellen die dat laten zien.

  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

Voor degenen die het nodig hebben, hier zijn twee functies die deze logische operatoren vertegenwoordigen.

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

Ternary-operator emuleren met 'en' of 'logische operators.

In lua retourneren de logische operatoren and en or een van de operanden als het resultaat in plaats van een boolean resultaat. Bijgevolg kan dit mechanisme worden benut om het gedrag van de ternaire operator na te bootsen ondanks dat Lua geen 'echte' ternaire operator in de taal heeft.

Syntaxis

conditie en waarheidsgetrouw of falsey_expr

Gebruik bij variabele toewijzing / initialisatie

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

Gebruik in tabelconstructor

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

Gebruik als functieargument

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

Gebruik in retourverklaring

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

Caveat

Er zijn situaties waarin dit mechanisme niet het gewenste gedrag heeft. Overweeg deze zaak

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

In een 'echte' ternaire operator is de verwachte waarde van var false . In Lua 'valt' and 'door' omdat de tweede operand falsey is. Als gevolg hiervan zou var should not happen .

Twee mogelijke oplossingen voor dit probleem, refactor deze uitdrukking zodat de middelste operand niet falsey is. bv.

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

of gebruik if alternatief de klassieke if then else constructie.