Opérateurs arithmétiques et relationnels
Utilisez efficacement +, -, *, /, //, %, ^ et les opérateurs de comparaison.
Opérateurs arithmétiques et relationnels est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.
Vue d’ensemble des opérateurs arithmétiques
Lua fournit un ensemble complet d’opérateurs arithmétiques : + (additionner), - (soustraire), * (multiplier), / (division flottante), // (division entière par défaut), % (modulo), ^ (exponentiation) et - unaire (négation). Comprendre dans quels cas chacun renvoie un entier ou un nombre flottant est essentiel dans Lua 5.3 et les versions ultérieures.
print(10 + 3) -- 13
print(10 - 3) -- 7
print(10 * 3) -- 30
print(10 / 3) -- 3.3333... (always float)
print(10 // 3) -- 3 (floor division)
print(10 % 3) -- 1 (modulo)
print(2 ^ 10) -- 1024.0 (always float)
print(-5) -- -5Division entière et division flottante
L’opérateur / renvoie toujours un nombre flottant, même lorsqu’il divise deux entiers dont le quotient est exact. L’opérateur de division entière par défaut // renvoie un entier uniquement lorsque ses deux opérandes sont des entiers ; si l’un des deux est un nombre flottant, le résultat est flottant, mais toujours arrondi vers le bas.
L’opérateur d’exponentiation ^ convertit toujours le résultat en nombre flottant : 2^3 donne donc 8.0, et non 8. Utilisez math.tointeger() pour reconvertir le résultat si nécessaire.
print(6 / 2) -- 3.0 (float!)
print(6 // 2) -- 3 (integer)
print(6.0 // 2) -- 3.0 (float floor)
print(7 // 2) -- 3 (floor toward -inf)
print(-7 // 2) -- -4 (floor, not truncate!)
print(2 ^ 3) -- 8.0 (always float)Opérateur modulo
L’opérateur % de Lua est défini par a % b == a - floor(a/b) * b. Cela signifie qu’il suit le signe du diviseur, et non celui du dividende. Cela diffère de C et de Java, où le résultat suit le signe du dividende.
L’opérateur modulo est utile pour faire boucler des valeurs, parcourir cycliquement des tableaux et implémenter des tampons circulaires. Une utilisation courante : i % n parcourt cycliquement les valeurs de 0 à n-1.
print(10 % 3) -- 1 (positive)
print(-10 % 3) -- 2 (sign of divisor!)
print(10 % -3) -- -2 (sign of divisor)
-- Cycling 1..5 example
for i = 1, 8 do
local idx = (i - 1) % 5 + 1
io.write(idx .. " ") -- 1 2 3 4 5 1 2 3
endOpérateurs relationnels
Les opérateurs relationnels de Lua renvoient des valeurs booléennes : == (égal), ~= (différent), <, >, <=, >=. Notez que Lua utilise ~= pour exprimer l’inégalité, contrairement à != dans la plupart des langages.
Comparer des valeurs de types différents avec == renvoie toujours false : Lua n’effectue aucune conversion implicite lors des comparaisons d’égalité. Ainsi, 1 == "1" vaut false en Lua.
print(3 == 3) -- true
print(3 ~= 4) -- true
print(3 < 4) -- true
print(3 >= 3) -- true
-- No cross-type equality coercion
print(1 == "1") -- false
print(0 == false) -- false
-- Strings compare lexicographically
print("abc" < "abd") -- trueOpérateurs logiques : and, or, not
Les opérateurs logiques de Lua sont and, or et not. Contrairement à de nombreux langages, and et or ne renvoient pas des booléens : ils renvoient l’un de leurs opérandes. Cela permet d’utiliser des constructions idiomatiques comme les valeurs par défaut et l’affectation conditionnelle.
a and brenvoieasiaest considéré comme faux, sinon il renvoieba or brenvoieasiaest considéré comme vrai, sinon il renvoieb
-- and/or return operands, not booleans
print(1 and 2) -- 2
print(false and 2) -- false
print(1 or 2) -- 1
print(false or 2) -- 2
-- Default value idiom
local name = nil
local display = name or "Anonymous"
print(display) -- AnonymousL’idiome ternaire
Lua ne possède pas d’opérateur ternaire (?:), mais vous pouvez en simuler un avec and/or. La construction condition and value_if_true or value_if_false fonctionne tant que value_if_true n’est ni nil ni false.
Il s’agit d’un idiome Lua très courant. Faites attention au cas particulier suivant : si la branche vraie vaut littéralement false, la construction échoue ; utilisez plutôt une instruction if.
local x = 10
-- Ternary idiom
local label = x > 5 and "big" or "small"
print(label) -- big
-- Works for non-false truthy values
local age = 20
local status = age >= 18 and "adult" or "minor"
print(status) -- adult
-- Edge case: true branch is false -> use if
local val = true and false or "fallback"
print(val) -- fallback (wrong!)Priorité des opérateurs
Priorité des opérateurs Lua, de la plus faible à la plus élevée : or, and, comparaisons (< > <= >= == ~=), |, ~, &, décalages, .., + -, * / // %, opérateurs unaires (not # - ~), ^. Les opérateurs ^ et .. sont associatifs à droite ; tous les autres sont associatifs à gauche.
-- Precedence examples
print(2 + 3 * 4) -- 14 (not 20)
print(2 ^ 3 ^ 2) -- 512 (right assoc: 2^(3^2) = 2^9)
print(not 1 == 1) -- false (not (1) == 1 => false == 1)
print(not (1 == 1)) -- false
-- Use parens to be explicit
print((2 + 3) * 4) -- 20Opérateurs bit à bit (Lua 5.3+)
Lua 5.3 a ajouté des opérateurs bit à bit natifs qui fonctionnent sur les entiers : & (AND), | (OR), ~ (XOR en version binaire, NOT en version unaire), << (décalage à gauche), >> (décalage à droite). Ils ne sont pas disponibles dans Lua 5.1/5.2 sans bibliothèque.
Les opérateurs bit à bit exigent des opérandes entiers. Le passage d’un nombre flottant provoque une erreur d’exécution, sauf si ce nombre possède une valeur entière exacte.
-- Bitwise operators (Lua 5.3+)
print(0xFF & 0x0F) -- 15 (AND)
print(0xF0 | 0x0F) -- 255 (OR)
print(0xFF ~ 0x0F) -- 240 (XOR)
print(~0) -- -1 (bitwise NOT)
print(1 << 4) -- 16 (left shift)
print(256 >> 4) -- 16 (right shift)Longueur et concaténation des chaînes
L’opérateur # renvoie la longueur d’une chaîne en octets, tandis que l’opérateur .. concatène deux chaînes. Lorsque vous appliquez .. à des nombres, Lua les convertit automatiquement en chaînes. En revanche, le mélange de types avec + suit les règles de conversion implicite : une chaîne qui ressemble à un nombre peut être utilisée dans un calcul arithmétique.
local s = "hello"
print(#s) -- 5
print(s .. " world") -- hello world
print(1 .. 2) -- 12 (number to string)
-- Length of table = array part length
local t = {10, 20, 30}
print(#t) -- 3
-- Beware: # on tables with holes is undefined
local h = {1, nil, 3}
print(#h) -- 1 or 3 (undefined behavior!)Erreurs courantes avec les opérateurs
Plusieurs erreurs liées aux opérateurs sont courantes en Lua : oublier que / renvoie toujours un nombre flottant ; utiliser != au lieu de ~= (erreur de syntaxe) ; s’attendre à ce que 0 ou "" soit considéré comme faux (ces valeurs sont considérées comme vraies) ; et utiliser and/or alors que la branche vraie peut valoir false.
Testez toujours les conditions limites, en particulier la division entière avec des nombres négatifs, car // arrondit vers moins l’infini.
-- Common mistakes
-- 1. / is always float
local result = 10 / 2
print(math.type(result)) -- float, not integer!
-- 2. ~= not !=
-- if x != 5 then -- SYNTAX ERROR!
if 3 ~= 5 then print("not equal") end
-- 3. 0 is truthy
if 0 then print("0 is truthy in Lua!") end
-- 4. Negative floor division
print(-7 // 2) -- -4 (not -3!)Vérification rapide
Quel est le résultat de -7 // 2 en Lua ?
Récapitulatif : opérateurs arithmétiques et relationnels
Points essentiels abordés :
/renvoie toujours un nombre flottant ;//arrondit vers moins l’infini^renvoie toujours un nombre flottant et est associatif à droite~=est l’opérateur de différence (et non!=)and/orrenvoient des opérandes, et non des booléens — ce qui permet l’idiome des valeurs par défaut- Seuls
niletfalsesont considérés comme faux —0et""sont considérés comme vrais - Les opérateurs bit à bit (
& | ~ << >>) exigent des entiers de Lua 5.3 ou version ultérieure
Ensuite : conversion implicite des types et fonctions de conversion explicite.
Questions Fréquemment Posées
La leçon « Opérateurs arithmétiques et relationnels » est-elle gratuite ?
Oui — le texte complet de « Opérateurs arithmétiques et relationnels » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Opérateurs arithmétiques et relationnels » ?
Utilisez efficacement +, -, *, /, //, %, ^ et les opérateurs de comparaison. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Lua Academy ?
Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Opérateurs arithmétiques et relationnels » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?
Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Présentation des types de données Lua
- Déclarer des variables en Lua
- Opérateurs arithmétiques et relationnels
- Coercition et conversion de types