处理错误 Lua

La gestion des erreurs pendant l'exécution du programme est nécessaire, car lors des opérations de fichier, du transfert de données et des appels de web service, des erreurs imprévues peuvent se produire. Si nous ne prêtons pas attention à la gestion des informations d'erreur, cela peut entraîner des fuites d'informations, le programme ne peut pas fonctionner, etc.

Dans n'importe quel langage de programmation, la gestion des erreurs est nécessaire. Les types d'erreurs incluent :

• Erreur de syntaxe

• Erreur d'exécution

Erreur de syntaxe

Les erreurs de syntaxe sont généralement causées par une utilisation incorrecte des composants du programme (comme les opérateurs, les expressions). Voici un exemple simple :

--　fichier　test.lua
a ==　2

Le résultat de l'exécution du code suivant est :

lua:　test.lua:2:　erreur de syntaxe près de　'=='

Comme vous pouvez le voir, il y a une erreur de syntaxe ci-dessus. Un "=" et deux "=" ont un sens différent. Un "=" est une expression d'affectation, et deux "=" sont des opérations de comparaison.

Un autre exemple :

for　a=　1,10
　　　print(a)
end

L'exécution du programme suivant entraînera l'erreur suivante :

lua:　test2.lua:2:　'do' attendu près de　'print'

Les erreurs de syntaxe sont plus simples que les erreurs d'exécution. Les erreurs d'exécution ne permettent pas de localiser l'erreur spécifique, tandis que les erreurs de syntaxe peuvent être résolues rapidement, comme dans l'exemple ci-dessus, nous devons ajouter do sous la déclaration for :

for　a=　1,10
do
　　　print(a)
end

Erreur d'exécution

Erreur d'exécution : le programme peut s'exécuter normalement, mais affichera des informations d'erreur. Comme dans l'exemple suivant, en raison de l'erreur de saisie des paramètres, le programme affichera une erreur lors de l'exécution :

function　ajouter(a,b)
　　　retourner　a+b
end
ajouter(10)

Lorsque nous compilons et exécutons le code suivant, la compilation peut réussir, mais lors de l'exécution, une erreur telle que ci-dessous se produira :

lua:　test2.lua:2:　tentative de calcul arithmétique sur la variable locale　'b'　(valeur nil)
stack traceback:
　　　　test2.lua:2:　dans la fonction　'ajouter'
　　　　test2.lua:5: dans le morceau principal
　　　　[C]:　?

Dans lua, appeler une fonction, même si la liste des arguments et la liste des paramètres ne correspond pas, peut réussir, les arguments en excès seront rejetés, et les paramètres manquants seront remplacés par nil.

Les informations d'erreur ci-dessus sont dues au fait que le paramètre b a été remplacé par nil après, nil a participé à + une opération.

si ajouter dans la fonction "retourner a+b" plutôt que "print(a,b)" si, le résultat deviendra "10 nil" Ne pas afficher d'erreur.

Gestion des erreurs

Nous pouvons utiliser deux fonctions : assert et error pour gérer les erreurs. Voici un exemple :

local　function　ajouter(a,b)
　　　assert(type(a) == "number", "a　n'est pas un nombre")
　　　assert(type(b) == "number", "b　n'est pas un nombre")
　　　retourner　a+b
end
ajouter(10)

L'exécution du programme suivant entraînera l'erreur suivante :

lua:　test.lua:3: b n'est pas un nombre
stack traceback:
　　　　[C] : in function 'assert'
　　　　test.lua :3: in local 'add'
　　　　test.lua :6: dans le morceau principal
　　　　[C]: dans ?

Dans l'exemple, assert vérifie d'abord le premier paramètre. Si tout va bien, assert ne fait rien. Sinon, assert lève une erreur avec le second paramètre en tant que message d'erreur.

Fonction error

Format syntaxique :

error (message [, level])

Fonction : Termine la fonction en cours d'exécution et retourne le contenu du message en tant que message d'erreur (la fonction error ne retourne jamais)

Dans les cas habituels, error ajoute des informations de position d'erreur à l'en-tête du message.

Le paramètre Level indique l'obtention de la position de l'erreur :

• Level=1[Par défaut] : Position d'appel de l'erreur (fichier+Numéro de ligne)

• Level=2Indique quel est le fonction de l'appel error

• Level=0 : Ne pas ajouter d'informations de position d'erreur

pcall et xpcall, debug

Dans Lua, la gestion des erreurs peut être effectuée en utilisant la fonction pcall (appel protégé) pour envelopper le code à exécuter.

pcall reçoit une fonction et les paramètres à transmettre à celle-ci, puis l'exécute. Le résultat de l'exécution : il y a une erreur, il n'y a pas d'erreur ; retourne true ou false, errorinfo.

Format syntaxique :

if pcall(function_name, ... ) then
--　Pas d'erreurs
else
--　Certains erreurs
end

Exemple simple :

> =pcall(function(i) print(i) end,　33)
33
true
　　　
> =pcall(function(i) print(i) error('error..') end,　33)
33
false stdin:1: error..

Ici, attention à la jugement logique du retour valeur :

> function f() return false,2　end
> if f() then print '1'else print '0' end
0

pcall appelle le premier paramètre dans un mode "protection", donc pcall peut capturer toute erreur se produisant dans l'exécution de la fonction.

Généralement, lorsque des erreurs se produisent, on souhaite obtenir plus d'informations de débogage que simplement l'emplacement de l'erreur. Mais lorsque pcall retourne, il a déjà détruit une partie de la pile des appels.

Lua propose la fonction xpcall, qui reçoit le second paramètre - une fonction de gestion des erreurs. Lorsqu'une erreur se produit, Lua appelle cette fonction de gestion des erreurs avant de dérouler la pile des appels, ce qui permet d'utiliser la bibliothèque debug pour obtenir des informations supplémentaires sur l'erreur.

La bibliothèque debug fournit deux fonctions de traitement des erreurs génériques :

• debug.debug : fournit un prompt Lua pour que l'utilisateur puisse vérifier la cause des erreurs

• debug.traceback : construit un message d'erreur étendu en fonction de la pile d'appel

>=xpcall(function(i) print(i) error('error..') end, function() print(debug.traceback()) end,　33)
33
stack traceback:
stdin:1: dans la fonction <stdin:1>
[C]: dans la fonction 'error'
stdin:1: dans la fonction <stdin:1>
[C]: dans la fonction 'xpcall'
stdin:1: dans le morceau principal
[C]: dans ?
false nil

Exemple d'utilisation de xpcall 2:

function myfunction ()
　　　n = n/nil
end
function myerrorhandler( err )
　　　print( "ERROR:", err )
end
status = xpcall( myfunction, myerrorhandler )
print( status )

L'exécution du programme suivant entraînera l'erreur suivante :

ERREUR:2.lua:2: tentative d'effectuer une opération arithmétique sur le global 'n' (une valeur nil)
false