Appels protégés avec pcall()

Fait partie de la section Logique et déroulement du programme du Journey Lua de Coddy. Leçon 33 sur 54.

Alors que error() arrête ton programme en cas de problème, tu veux parfois gérer les erreurs sans provoquer de plantage. La fonction pcall() de Lua te permet d’exécuter en toute sécurité du code susceptible d’échouer.

Le nom pcall() signifie « appel protégé ». Il enveloppe un appel de fonction dans une couche de protection qui intercepte les erreurs. Au lieu que votre programme plante, pcall() renvoie des informations sur ce qui s’est passé.

Voici la syntaxe de base :

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

La fonction pcall() renvoie deux valeurs. La première est un statut booléen : true si la fonction a réussi, ou false si une erreur s’est produite. La deuxième valeur dépend du statut : en cas de réussite, c’est la valeur renvoyée par la fonction ; en cas d’erreur, c’est le message d’erreur.

Voici un exemple pratique :

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

Dans cet exemple, la division par zéro déclenche une erreur, mais au lieu de planter, pcall() l’intercepte. Le programme continue de s’exécuter et peut gérer l’erreur correctement en vérifiant la valeur d’état.

Gardez à l’esprit que pcall() intercepte toutes les erreurs dans l’appel, y compris les bogues auxquels vous ne vous attendiez pas, et les signale toutes de la même manière. N’encapsulez donc que l’appel susceptible d’échouer et, pour les échecs auxquels vous vous attendez, préférez une fonction qui renvoie nil et un message, comme dans la leçon précédente.

Défi

Facile

Écris une fonction safeCalculate qui prend operation, a et b, puis renvoie le résultat du calcul ou un message d’erreur.

La fonction doit utiliser pcall() pour effectuer en toute sécurité l’opération mathématique demandée. Crée une fonction interne qui effectue le calcul selon la chaîne d’opération, puis enveloppe-la avec pcall() pour intercepter les erreurs.

Logique :

Crée une fonction interne qui vérifie le type d’opération et effectue le calcul
Pour "add", renvoie a + b
Pour "subtract", renvoie a - b
Pour "multiply", renvoie a * b
Pour "divide", vérifie si b vaut 0 et appelle error("Division by zero", 0) si c’est le cas ; sinon, renvoie a / b
Pour toute autre opération, appelle error("Invalid operation", 0)
Utilise pcall() pour exécuter la fonction interne
En cas de réussite, renvoie "Result: " suivi du résultat
En cas d’erreur, renvoie "Error: " suivi du message d’erreur

Passe 0 comme deuxième argument de error(). Cet argument est le niveau d’erreur, et 0 indique à Lua de ne pas placer le nom du fichier et le numéro de ligne devant ton message, de sorte que la chaîne renvoyée soit exactement "Error: Division by zero".

Paramètres :

operation (chaîne) : l’opération à effectuer ("add", "subtract", "multiply" ou "divide")
a (nombre) : le premier opérande
b (nombre) : le deuxième opérande

Valeur renvoyée : une chaîne contenant soit "Result: " suivi du résultat du calcul, soit "Error: " suivi du message d’erreur (chaîne)

Essayez vous-même

function safeCalculate(operation, a, b)
    -- Écrivez le code ici
    -- Note : appelez error(message, 0) pour que Lua n’ajoute pas le nom du fichier et le
    -- numéro de ligne devant votre message.
end