Chiamate protette con pcall()

Fa parte della sezione Logica e flusso del percorso Lua di Coddy. Lezione 33 di 54.

Mentre error() interrompe il programma quando qualcosa va storto, a volte vuoi gestire gli errori senza causare un arresto anomalo. La funzione pcall() di Lua ti consente di eseguire in sicurezza codice che potrebbe non riuscire.

Il nome pcall() sta per «chiamata protetta». Avvolge una chiamata di funzione in uno strato protettivo che intercetta eventuali errori. Invece di mandare in crash il programma, pcall() restituisce informazioni su ciò che è accaduto.

Ecco la sintassi di base:

local status, result = pcall(functionName, arg1, arg2)

La funzione pcall() restituisce due valori. Il primo è uno stato booleano: true se la funzione è riuscita, oppure false se si è verificato un errore. Il secondo valore dipende dallo stato: se l'esecuzione è riuscita, è il valore restituito dalla funzione; se si è verificato un errore, è il messaggio di errore.

Ecco un esempio pratico:

function divide(a, b)
    if b == 0 then
        error("Cannot divide by zero")
    end
    return a / b
end
local success, result = pcall(divide, 10, 0)
if success then
    print("Result: " .. result)
else
    print("Error caught: " .. result)
end

In questo esempio, la divisione per zero provoca un errore, ma invece di bloccarsi, pcall() lo intercetta. Il programma continua a essere eseguito e può gestire l’errore in modo corretto controllando il valore di stato.

Tieni presente che pcall() intercetta tutti gli errori all’interno della chiamata, inclusi i bug che non ti aspettavi, e li segnala tutti allo stesso modo. Quindi racchiudi solo la chiamata che può fallire e, per gli errori che prevedi, preferisci una funzione che restituisce nil e un messaggio, come nella lezione precedente.

Sfida

Facile

Scrivi una funzione safeCalculate che accetta operation, a e b e restituisce il risultato del calcolo oppure un messaggio di errore.

La funzione deve usare pcall() per eseguire in sicurezza l'operazione matematica richiesta. Crea una funzione interna che esegue il calcolo in base alla stringa dell'operazione, quindi racchiudila in pcall() per intercettare eventuali errori.

Logica:

Crea una funzione interna che controlla il tipo di operazione ed esegue il calcolo
Per "add", restituisci a + b
Per "subtract", restituisci a - b
Per "multiply", restituisci a * b
Per "divide", controlla se b è 0 e, in tal caso, chiama error("Division by zero", 0); altrimenti restituisci a / b
Per qualsiasi altra operazione, chiama error("Invalid operation", 0)
Usa pcall() per eseguire la funzione interna
Se l'esecuzione ha esito positivo, restituisci "Result: " seguito dal risultato
Se si verifica un errore, restituisci "Error: " seguito dal messaggio di errore

Passa 0 come secondo argomento di error(). Questo argomento è il livello di errore e 0 indica a Lua di non anteporre al messaggio il nome del file e il numero di riga, così la stringa restituita è esattamente "Error: Division by zero".

Parametri:

operation (stringa): l'operazione da eseguire ("add", "subtract", "multiply" oppure "divide")
a (numero): il primo operando
b (numero): il secondo operando

Valore restituito: una stringa contenente "Result: " seguito dal risultato del calcolo, oppure "Error: " seguito dal messaggio di errore (stringa)

Provalo tu

function safeCalculate(operation, a, b)
    -- Scrivi il codice qui
    -- Nota: chiama error(message, 0) affinché Lua non aggiunga il nome del file e il
    -- numero di riga davanti al tuo messaggio.
end