Gestion des erreurs Lua

La gestion des erreurs est nécessaire pendant le fonctionnement du programme. Des erreurs inattendues se produiront lors des opérations sur les fichiers, du transfert de données et des appels de service Web. Si vous ne faites pas attention à la gestion des messages d'erreur, des informations seront divulguées et le programme ne fonctionnera pas.

La gestion des erreurs est requise dans n'importe quel langage de programmation. Les types d'erreur sont :

• Erreur de syntaxe

• Erreur d'exécution

---

Erreur de syntaxe

Erreur de syntaxe

Les erreurs de syntaxe sont généralement causées par une mauvaise utilisation des composants du programme (tels que les opérateurs, les expressions). Un exemple simple est le suivant :

-- test.lua 文件
a == 2

Le résultat de l'exécution du code ci-dessus est :

lua: test.lua:2: syntax error near '=='

Comme vous pouvez le voir, il y a une erreur de syntaxe dans ce qui précède, un "=" suivi de deux "=" Il y a une différence de nombre. 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'erreur suivante se produira lors de l'exécution du programme ci-dessus :

lua: test2.lua:2: 'do' expected near 'print'

Les erreurs de syntaxe sont plus simples que les erreurs d'exécution du programme. Les erreurs d'exécution ne peuvent pas localiser les erreurs spécifiques, et erreurs de syntaxe Nous pouvons résoudre l'erreur rapidement. Par exemple, dans l'exemple ci-dessus, il suffit d'ajouter do sous l'instruction for :

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

Erreur d'exécution

Une erreur d'exécution signifie que le programme peut être exécuté normalement, mais il affichera un message d'erreur. Dans l'exemple suivant, en raison d'une saisie de paramètre incorrecte, une erreur se produit lors de l'exécution du programme :

---

function add(a,b)
   return a+b
end

add(10)

Lorsque nous compilons et exécutons le code suivant, la compilation peut réussir, mais l'erreur suivante se produira pendant l'opération :

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
	test2.lua:2: in function 'add'
	test2.lua:5: in main chunk
	[C]: ?

Le message d'erreur suivant est dû au fait que le programme manque le paramètre b.

Gestion des erreurs

Nous pouvons utiliser deux fonctions : assert et error pour gérer les erreurs. L'exemple est le suivant :

local function add(a,b)
   assert(type(a) == "number", "a 不是一个数字")
   assert(type(b) == "number", "b 不是一个数字")
   return a+b
end
add(10)

L'erreur suivante se produira lors de l'exécution du programme ci-dessus :

lua: test.lua:3: b 不是一个数字
stack traceback:
	[C]: in function 'assert'
	test.lua:3: in local 'add'
	test.lua:6: in main chunk
	[C]: in ?

Dans l'exemple, assert vérifie d'abord le premier paramètre. S'il n'y a pas de problème, assert le fait. ne faites rien ; sinon, assert commence par le premier paramètre. Les deux paramètres sont renvoyés sous forme de messages d'erreur.

fonction d'erreur

Format de syntaxe :

error (message [, level])

Fonction : terminez la fonction en cours d'exécution et renvoyez le contenu du message sous forme d'informations d'erreur (la fonction d'erreur ne reviendra jamais)

• Normalement, l'erreur ajoutera des informations sur l'emplacement de l'erreur à l'en-tête du message.
  Le paramètre Level indique l'emplacement où l'erreur a été obtenue :

• Level=1 [Par défaut] : Appeler l'emplacement de l'erreur (fichier + numéro de ligne)

• Niveau=2 : Indiquez quelle fonction appelle la fonction d'erreur

---

Niveau=0 : Ne pas ajouter d'informations sur l'emplacement de l'erreur

pcall et xpcall, debug

Pour gérer les erreurs dans Lua, vous pouvez utiliser la fonction pcall (appel protégé) pour encapsuler le code qui doit être exécuté.

pcall reçoit une fonction et les paramètres à passer à cette dernière, et l'exécute. Le résultat de l'exécution est : erreur ou pas d'erreur ; la valeur de retour est vraie ou fausse, errorinfo.

Le format de syntaxe est le suivant<🎜>

if pcall(function_name, ….) then
-- 没有错误
else
-- 一些错误
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..

<pIci, faites attention au jugement logique de la valeur de retour :< p="">

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

< 🎜>pcall en "Mode protégé" pour appeler avec le premier argument, afin que pcall puisse détecter toute erreur d'exécution de la fonction. <🎜>

Souvent, lorsqu'une erreur se produit, vous souhaitez obtenir plus d'informations de débogage, pas seulement l'emplacement où l'erreur s'est produite. Mais lorsque pcall revient, il a détruit une partie de la pile appelante.

Lua fournit la fonction xpcall. xpcall reçoit le deuxième paramètre - une fonction de gestion des erreurs lorsqu'une erreur se produit, Lua appellera la fonction de gestion des erreurs avant d'appeler unwind, elle peut donc être utilisée dans cela. fonction pour obtenir des informations supplémentaires sur l’erreur.

La bibliothèque de débogage fournit deux fonctions générales de gestion des erreurs :

• debug.debug : fournit une invite Lua pour permettre aux utilisateurs de découvrir la cause des erreurs de propagation.

• debug.traceback : Construire un message d'erreur étendu basé sur le rappel

>=xpcall(function(i) print(i) error( ' erreur..') fin, function() print(debug.traceback()) fin, 33) 33 traçage de la pile : stdin:1 : en fonction