Lua
La gestion des erreurs

En utilisant pcall

pcall signifie "appel protégé". Il est utilisé pour ajouter la gestion des erreurs aux fonctions. pcall fonctionne comme un try-catch dans d'autres langues. L'avantage de pcall est que toute l'exécution du script n'est pas interrompue si des erreurs surviennent dans les fonctions appelées avec pcall . Si une erreur dans une fonction appelée avec pcall se produit, une erreur est pcall et le reste du code continue son exécution.

Syntaxe:

pcall( f , arg1,···)

Valeurs de retour:

Renvoie deux valeurs

1. statut (booléen)

• Renvoie true si la fonction a été exécutée sans erreur.
• Renvoie false si une erreur est survenue dans la fonction.

2. Renvoie la valeur de la fonction ou du message d'erreur si une erreur s'est produite dans le bloc fonction.

pcall peut être utilisé pour divers cas, cependant, il est courant de détecter les erreurs de la fonction donnée à votre fonction. Par exemple, disons que nous avons cette fonction:

local function executeFunction(funcArg, times) then
    for i = 1, times do
        local ran, errorMsg = pcall( funcArg )
        if not ran then
            error("Function errored on run " .. tostring(i) .. "\n" .. errorMsg)
        end
    end
end

Lorsque la fonction donnée commet des erreurs lors de l'exécution 3, le message d'erreur sera clair pour l'utilisateur qu'il ne provient pas de votre fonction, mais de la fonction qui a été donnée à notre fonction. Dans cette optique, un BSoD sophistiqué peut être envoyé à l’utilisateur. Cependant, cela dépend de l'application qui implémente cette fonction, car une API ne le fera probablement pas.

Exemple A - Exécution sans pcall

function square(a)
  return a * "a"    --This will stop the execution of the code and throws an error, because of the attempt to perform arithmetic on a string value
end

square(10);

print ("Hello World")    -- This is not being executed because the script was interrupted due to the error

Exemple B - Exécution avec pcall

function square(a)
  return a * "a"
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "false" because an error was thrown.
print ("Return Value: ", retval)  -- will print "input:2: attempt to perform arithmetic on a string value"
print ("Hello World")    -- Prints "Hello World"

Exemple - Exécution d'un code sans faille

function square(a)
  return a * a
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "true" because no errors were thrown 
print ("Return Value: ", retval)  -- will print "100"
print ("Hello World")    -- Prints "Hello World"

Gestion des erreurs dans Lua

En supposant que nous avons la fonction suivante:

function foo(tab)
  return tab.a
end -- Script execution errors out w/ a stacktrace when tab is not a table

Améliorons un peu

function foo(tab)
  if type(tab) ~= "table" then
    error("Argument 1 is not a table!", 2)
  end
  return tab.a
end -- This gives us more information, but script will still error out

Si nous ne voulons pas qu'une fonction plante un programme même en cas d'erreur, il est standard de faire ce qui suit:

function foo(tab)
    if type(tab) ~= "table" then return nil, "Argument 1 is not a table!" end
    return tab.a
end -- This never crashes the program, but simply returns nil and an error message

Maintenant, nous avons une fonction qui se comporte comme ça, nous pouvons faire des choses comme ceci:

if foo(20) then print(foo(20)) end -- prints nothing
result, error = foo(20)
if result then print(result) else log(error) end

Et si nous voulons que le programme plante si quelque chose ne va pas, nous pouvons toujours le faire:

result, error = foo(20)
if not result then error(error) end

Heureusement, nous n'avons même pas à écrire tout cela à chaque fois. Lua a une fonction qui fait exactement cela

result = assert(foo(20))