Condizionali if/else in Lua

Le istruzioni condizionali sono un elemento fondamentale della programmazione che permettono di eseguire blocchi di codice differenti in base a determinate condizioni. In Lua, le strutture condizionali si basano sulle parole chiave if, elseif, else e then, e ogni blocco condizionale termina con la parola chiave end.

L’Istruzione if

L’istruzione if e la forma piu semplice di controllo condizionale. Esegue un blocco di codice solo se la condizione specificata e vera:

local eta = 20

if eta >= 18 then
    print("Sei maggiorenne")
end

La struttura base e: if condizione then ... end. Il blocco di codice tra then e end viene eseguito solo se la condizione risulta vera.

local temperatura = 35

if temperatura > 30 then
    print("Fa molto caldo oggi!")
    print("Ricordati di bere molta acqua.")
end

-- Il programma continua qui indipendentemente dalla condizione
print("Programma terminato.")

L’Istruzione if-else

L’istruzione if-else permette di definire un blocco alternativo da eseguire quando la condizione e falsa:

local numero = 7

if numero % 2 == 0 then
    print(numero .. " e un numero pari")
else
    print(numero .. " e un numero dispari")
end
-- Output: 7 e un numero dispari

Un esempio pratico con l’autenticazione:

local password_corretta = "lua2026"
local password_inserita = "lua2026"

if password_inserita == password_corretta then
    print("Accesso consentito! Benvenuto.")
else
    print("Password errata. Accesso negato.")
end

L’Istruzione if-elseif-else

Quando ci sono piu condizioni da verificare in sequenza, si utilizza elseif per aggiungere condizioni intermedie:

local voto = 27

if voto >= 30 then
    print("Eccellente!")
elseif voto >= 26 then
    print("Ottimo!")
elseif voto >= 22 then
    print("Buono")
elseif voto >= 18 then
    print("Sufficiente")
else
    print("Insufficiente")
end
-- Output: Ottimo!

Le condizioni vengono valutate dall’alto verso il basso. Appena una condizione risulta vera, il blocco corrispondente viene eseguito e le condizioni successive vengono ignorate:

local ora = 14

if ora < 6 then
    print("Buonanotte!")
elseif ora < 12 then
    print("Buongiorno!")
elseif ora < 18 then
    print("Buon pomeriggio!")
elseif ora < 22 then
    print("Buonasera!")
else
    print("Buonanotte!")
end
-- Output: Buon pomeriggio!

Condizioni Annidate

Le istruzioni condizionali possono essere annidate una dentro l’altra per gestire logiche piu articolate:

local eta = 25
local ha_patente = true

if eta >= 18 then
    print("Sei maggiorenne.")
    if ha_patente then
        print("Puoi guidare un'automobile.")
    else
        print("Non hai la patente, non puoi guidare.")
    end
else
    print("Sei minorenne.")
    if eta >= 14 then
        print("Puoi guidare un ciclomotore con il patentino.")
    else
        print("Non puoi ancora guidare nessun veicolo a motore.")
    end
end

Per evitare un annidamento eccessivo, spesso e preferibile combinare le condizioni con gli operatori logici:

local eta = 25
local ha_patente = true

-- Versione equivalente senza annidamento
if eta >= 18 and ha_patente then
    print("Puoi guidare un'automobile.")
elseif eta >= 18 and not ha_patente then
    print("Sei maggiorenne ma non hai la patente.")
elseif eta >= 14 then
    print("Puoi guidare un ciclomotore con il patentino.")
else
    print("Non puoi ancora guidare.")
end

Truthiness in Lua

In Lua, il concetto di verita (truthiness) e molto semplice e diverso da molti altri linguaggi. La regola fondamentale e:

Solo false e nil sono considerati falsi. Tutti gli altri valori sono considerati veri.

Questo include valori che in altri linguaggi sarebbero falsi:

-- false e nil sono falsi
if false then print("non stampato") end
if nil then print("non stampato") end

-- TUTTO il resto e vero, inclusi:
if 0 then print("0 e vero in Lua!") end           -- stampato!
if "" then print("stringa vuota e vera!") end       -- stampato!
if "false" then print("la stringa 'false' e vera!") end  -- stampato!
if {} then print("tabella vuota e vera!") end       -- stampato!

-- Questo e diverso da Python, JavaScript, ecc.
-- dove 0, "" e {} possono essere falsi

Questa regola rende i controlli molto prevedibili:

local nome = nil

if nome then
    print("Il nome e: " .. nome)
else
    print("Il nome non e stato impostato")
end
-- Output: Il nome non e stato impostato

-- Verificare se una variabile esiste
local configurazione = { debug = false }

if configurazione.debug then
    print("Modalita debug attiva")
else
    print("Modalita debug disattiva")
end
-- Output: Modalita debug disattiva

-- Attenzione: false e nil si comportano diversamente
if configurazione.debug == nil then
    print("debug non e definito")
else
    print("debug e definito (vale: " .. tostring(configurazione.debug) .. ")")
end
-- Output: debug e definito (vale: false)

Operatori Logici nelle Condizioni

Lua supporta tre operatori logici: and, or e not:

local eta = 25
local ha_biglietto = true
local e_vip = false

-- and: entrambe le condizioni devono essere vere
if eta >= 18 and ha_biglietto then
    print("Puoi entrare al concerto")
end

-- or: almeno una condizione deve essere vera
if ha_biglietto or e_vip then
    print("Hai accesso all'evento")
end

-- not: inverte il valore di verita
if not e_vip then
    print("Non sei un VIP")
end

-- Combinazione di operatori
if (eta >= 18 and ha_biglietto) or e_vip then
    print("Accesso consentito")
end

Una particolarita di Lua e che and e or restituiscono uno dei loro operandi, non necessariamente true o false:

-- and restituisce il primo valore falso, o l'ultimo valore
print(1 and 2)       -- 2
print(nil and 2)     -- nil
print(false and 2)   -- false

-- or restituisce il primo valore vero, o l'ultimo valore
print(1 or 2)        -- 1
print(nil or 2)      -- 2
print(false or 2)    -- 2
print(nil or false)  -- false

L’Idioma Ternario: a and b or c

Lua non ha un operatore ternario come il ? : di C o JavaScript. Tuttavia, esiste un idioma comune che sfrutta il comportamento di and e or:

-- Idioma ternario: condizione and valore_se_vero or valore_se_falso
local eta = 20
local stato = (eta >= 18) and "maggiorenne" or "minorenne"
print(stato)  -- maggiorenne

-- Equivalente a:
-- local stato
-- if eta >= 18 then stato = "maggiorenne" else stato = "minorenne" end

-- Altro esempio
local numero = 7
local tipo = (numero % 2 == 0) and "pari" or "dispari"
print(numero .. " e " .. tipo)  -- 7 e dispari

-- Uso con funzioni
local x = -5
local valore_assoluto = (x >= 0) and x or -x
print(valore_assoluto)  -- 5

Attenzione: questo idioma ha una limitazione importante. Non funziona correttamente se il valore di b puo essere false o nil:

-- PROBLEMA: se b e false, l'idioma non funziona
local condizione = true
local risultato = condizione and false or "alternativa"
print(risultato)  -- "alternativa" (SBAGLIATO! ci aspettavamo false)

-- In questo caso, usare un if-else esplicito:
local risultato2
if condizione then
    risultato2 = false
else
    risultato2 = "alternativa"
end
print(risultato2)  -- false (CORRETTO)

Esempi Pratici con Diversi Tipi di Dati

Classificazione di un Carattere

local function classifica_carattere(c)
    if string.match(c, "%d") then
        return "cifra"
    elseif string.match(c, "%u") then
        return "lettera maiuscola"
    elseif string.match(c, "%l") then
        return "lettera minuscola"
    elseif string.match(c, "%s") then
        return "spazio bianco"
    elseif string.match(c, "%p") then
        return "punteggiatura"
    else
        return "altro"
    end
end

print(classifica_carattere("A"))  -- lettera maiuscola
print(classifica_carattere("5"))  -- cifra
print(classifica_carattere("!"))  -- punteggiatura

Confronto di Tipi

local function descrivi_valore(v)
    local t = type(v)

    if t == "number" then
        if v == math.floor(v) then
            print(v .. " e un numero intero")
        else
            print(v .. " e un numero decimale")
        end
    elseif t == "string" then
        if #v == 0 then
            print("Stringa vuota")
        else
            print('"' .. v .. '" e una stringa di ' .. #v .. " caratteri")
        end
    elseif t == "boolean" then
        print("Booleano: " .. tostring(v))
    elseif t == "table" then
        print("Tabella con " .. #v .. " elementi nella parte sequenziale")
    elseif t == "nil" then
        print("Valore nil (nessun valore)")
    else
        print("Tipo: " .. t)
    end
end

descrivi_valore(42)            -- 42 e un numero intero
descrivi_valore(3.14)          -- 3.14 e un numero decimale
descrivi_valore("Ciao")        -- "Ciao" e una stringa di 4 caratteri
descrivi_valore(true)          -- Booleano: true
descrivi_valore({1, 2, 3})    -- Tabella con 3 elementi nella parte sequenziale
descrivi_valore(nil)           -- Valore nil (nessun valore)

Conclusioni

Le istruzioni condizionali in Lua sono semplici e intuitive. La regola di truthiness, dove solo false e nil sono valori falsi, rende i controlli molto prevedibili. L’idioma ternario a and b or c e un pattern utile ma va usato con consapevolezza delle sue limitazioni. Combinando if, elseif, else con gli operatori logici and, or e not, e possibile esprimere qualsiasi logica condizionale in modo chiaro e leggibile.