Lua
Booléens à Lua

Remarques

Le type booléen

Booléens et autres valeurs

Lorsque vous traitez avec lua, il est important de différencier les valeurs booléennes true et false et les valeurs évaluées à true ou false.

Il n'y a que deux valeurs dans lua évaluées à false: nil et false , tandis que tout le reste, y compris le 0 numérique, est évalué à true.

Quelques exemples de ce que cela signifie:

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.

Opérations logiques

Les opérateurs logiques dans lua ne renvoient pas nécessairement des valeurs booléennes:

and retournera la deuxième valeur si la première valeur est évaluée à true;

or renvoie la deuxième valeur si la première valeur est fausse;

Cela permet de simuler l'opérateur ternaire, comme dans d'autres langages:

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

Cela peut également être utilisé pour initialiser des tables si elles n'existent pas

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

ou pour éviter d'utiliser des instructions if, rendant le code plus facile à lire

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)

Vérifier si les variables sont définies

On peut aussi facilement vérifier si une variable existe (si elle est définie), puisque les variables non-existantes renvoient nil , ce qui équivaut à false.

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

Le seul cas où cela ne s'applique pas est lorsqu'une variable stocke la valeur false , auquel cas elle existe techniquement mais est toujours évaluée à false. De ce fait, créer des fonctions qui renvoient false et nil fonction de l'état ou de l'entrée est une mauvaise conception. On peut quand même vérifier si on a un nil ou un 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

Contextes conditionnels

Les contextes conditionnels dans Lua ( if , elseif , while , until ) ne nécessitent pas de booléen. Comme beaucoup de langues, toute valeur Lua peut apparaître dans une condition. Les règles d'évaluation sont simples:

1. false et nil comptent comme faux.

2. Tout le reste compte comme étant vrai.

   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
   

Opérateurs logiques

Dans Lua, les booléens peuvent être manipulés par des opérateurs logiques . Ces opérateurs n'incluent not , and et / or .

Dans les expressions simples, les résultats sont assez simples:

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

Ordre de préséance

L'ordre de priorité est similaire aux opérateurs mathématiques unaires - , * et + :

• not
• alors and
• alors or

Cela peut conduire à des expressions complexes:

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

Évaluation abrégée

Les opérateurs and / or peuvent uniquement être évalués à l'aide du premier opérande, à condition que le second ne soit pas nécessaire:

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

Opérateur conditionnel idiomatique

En raison de la priorité des opérateurs logiques, la capacité d'évaluation coupe courte et l'évaluation des non false et non nil valeurs true , un opérateur conditionnel idiomatiques est disponible en 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

En outre, en raison de la nature de la structure x and a or b , a ne sera jamais renvoyé si elle est évaluée à false , cette condition conditionnelle renverra toujours b quel que soit x .

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

Tables de vérité

Les opérateurs logiques dans Lua ne "renvoient" pas un booléen, mais l'un de leurs arguments. En utilisant nil pour les faux et les nombres pour vrai, voici comment ils se comportent.

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

Comme vous pouvez le voir, Lua retournera toujours la première valeur qui fait échouer ou réussir la vérification. Voici les tableaux de vérité montrant cela.

  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

Pour ceux qui en ont besoin, voici deux fonctions représentant ces opérateurs logiques.

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

Émulation d'un opérateur ternaire avec les opérateurs logiques 'et' ou '.

Dans lua, les opérateurs logiques and / or retournent l'un des opérandes comme résultat au lieu d'un résultat booléen. En conséquence, ce mécanisme peut être exploité pour émuler le comportement de l'opérateur ternaire même si lua ne possède pas d'opérateur ternaire «réel» dans le langage.

Syntaxe

condition et truthy_expr ou falsey_expr

Utilisation en affectation / initialisation de variables

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

Utiliser dans un constructeur de table

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

Utiliser comme argument de fonction

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

Utiliser dans la déclaration de retour

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

Caveat

Il existe des situations où ce mécanisme n'a pas le comportement souhaité. Considérez ce cas

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

Dans un opérateur ternaire «réel», la valeur attendue de var est false . En lua, cependant, la and évaluation « tombe à travers » parce que le second opérande est Falsey. Par conséquent, var se termine avec should not happen place.

Deux solutions possibles à ce problème, refactorisez cette expression pour que l'opérande du milieu ne soit pas faux. par exemple.

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

ou bien, utilisez la construction classique if then else .