0Pricing
Lua Academy · Lezione

Operatori aritmetici e relazionali

Utilizzi efficacemente +, -, *, /, //, %, ^ e gli operatori di confronto.

Operatori aritmetici e relazionali è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Panoramica degli operatori aritmetici

Lua offre un set completo di operatori aritmetici: + (addizione), - (sottrazione), * (moltiplicazione), / (divisione in virgola mobile), // (divisione con arrotondamento per difetto), % (modulo), ^ (elevamento a potenza) e - unario (negazione). In Lua 5.3+ è fondamentale capire quando ciascun operatore restituisce un intero o un float.

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)       -- -5

Divisione tra interi e float

L’operatore / restituisce sempre un float, anche quando divide due interi con risultato esatto. L’operatore di divisione con arrotondamento per difetto // restituisce un intero solo quando entrambi gli operandi sono interi; se almeno uno è un float, il risultato è un float ma viene comunque arrotondato per difetto.

L’operatore di elevamento a potenza ^ converte sempre il risultato in float, quindi 2^3 restituisce 8.0, non 8. Se necessario, usare math.tointeger() per riconvertirlo.

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)

Operatore modulo

L’operatore % di Lua è definito come a % b == a - floor(a/b) * b. Ciò significa che segue il segno del divisore, non quello del dividendo. Questo comportamento differisce da C/Java, in cui il risultato segue il segno del dividendo.

L’operatore modulo è utile per riportare i valori all’interno di un intervallo, scorrere ciclicamente gli array e implementare buffer circolari. Un uso comune è i % n, che produce ciclicamente valori da 0 a 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
end

Operatori relazionali

Gli operatori relazionali di Lua restituiscono valori booleani: == (uguale), ~= (diverso), <, >, <=, >=. Si noti che Lua usa ~= per indicare la disuguaglianza, a differenza di !=, usato nella maggior parte dei linguaggi.

Il confronto con == tra valori di tipi diversi restituisce sempre false: non esiste una conversione implicita per i controlli di uguaglianza. In Lua, 1 == "1" è false.

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")  -- true

Operatori logici: and, or, not

Gli operatori logici di Lua sono and, or e not. A differenza di molti linguaggi, and e or non restituiscono valori booleani: restituiscono uno dei loro operandi. Questo consente di usare schemi idiomatici per i valori predefiniti e l'assegnazione condizionale.

  • a and b restituisce a se a è falso, altrimenti restituisce b
  • a or b restituisce a se a è vero, altrimenti restituisce b
-- 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)        -- Anonymous

L'idioma ternario

Lua non ha un operatore ternario (?:), ma è possibile simularlo usando and/or. Lo schema condition and value_if_true or value_if_false funziona purché value_if_true non sia nil o false.

Si tratta di un idioma molto comune in Lua. Faccia attenzione al caso limite: se il ramo vero è esattamente false, lo schema non funziona; in questo caso utilizzi invece un'istruzione 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!)

Precedenza degli operatori

Precedenza degli operatori Lua, dalla più bassa alla più alta: or, and, confronti (< > <= >= == ~=), |, ~, &, shift, .., + -, * / // %, unari (not # - ~), ^. Gli operatori ^ e .. sono associativi a destra; tutti gli altri sono associativi a sinistra.

-- 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)   -- 20

Operatori bitwise (Lua 5.3+)

Lua 5.3 ha introdotto operatori bitwise nativi che funzionano sugli interi: & (AND), | (OR), ~ (XOR quando è binario, NOT quando è unario), << (shift a sinistra), >> (shift a destra). Non sono disponibili in Lua 5.1/5.2 senza una libreria.

Gli operatori bitwise richiedono operandi interi. Il passaggio di un numero in virgola mobile causa un errore a runtime, a meno che il valore non rappresenti esattamente un intero.

-- 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)

Lunghezza e concatenazione delle stringhe

L'operatore # restituisce la lunghezza di una stringa in byte, mentre l'operatore .. concatena due stringhe. Quando si applica .. a dei numeri, Lua li converte automaticamente in stringhe. Tuttavia, combinare tipi diversi con + segue le regole di coercizione: una stringa che rappresenta un numero può essere utilizzata nelle operazioni aritmetiche.

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!)

Errori comuni con gli operatori

In Lua sono comuni diversi bug legati agli operatori: dimenticare che / restituisce sempre un numero in virgola mobile; usare != invece di ~= (errore di sintassi); aspettarsi che 0 o "" siano falsi (sono veri); e fare affidamento su and/or quando il ramo vero potrebbe essere false.

Verifichi sempre le condizioni limite, soprattutto nella divisione intera con numeri negativi, perché // arrotonda verso l'infinito negativo.

-- 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!)

Verifica rapida

Qual è il risultato di -7 // 2 in Lua?

Riepilogo: operatori aritmetici e relazionali

Punti chiave trattati:

  • / restituisce sempre un numero in virgola mobile; // arrotonda verso l'infinito negativo
  • ^ restituisce sempre un numero in virgola mobile ed è associativo a destra
  • ~= è l'operatore di disuguaglianza (non !=)
  • and/or restituiscono gli operandi, non valori booleani; questo consente l'idioma del valore predefinito
  • Solo nil e false sono falsi; 0 e "" sono veri
  • Gli operatori bitwise (& | ~ << >>) richiedono interi di Lua 5.3+

Successivamente: coercizione dei tipi e funzioni di conversione esplicita.

Domande Frequenti

La lezione «Operatori aritmetici e relazionali» è gratuita?

Sì — il testo completo di «Operatori aritmetici e relazionali» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Operatori aritmetici e relazionali»?

Utilizzi efficacemente +, -, *, /, //, %, ^ e gli operatori di confronto. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Operatori aritmetici e relazionali»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica dei tipi di dati Lua
  2. Dichiarare variabili in Lua
  3. Operatori aritmetici e relazionali
  4. Coercizione e conversione dei tipi
← Torna a Lua Academy