Lua - Gestion des erreurs

Nécessité d'une gestion des erreurs

La gestion des erreurs est assez critique car les opérations du monde réel nécessitent souvent l'utilisation d'opérations complexes, qui incluent des opérations sur les fichiers, des transactions de base de données et des appels de service Web.

Dans toute programmation, il y a toujours une exigence pour la gestion des erreurs. Les erreurs peuvent être de deux types, notamment:

Erreurs de syntaxe
Erreurs d'exécution

Erreurs de syntaxe

Des erreurs de syntaxe se produisent en raison d'une mauvaise utilisation de divers composants du programme tels que des opérateurs et des expressions. Un exemple simple d'erreur de syntaxe est présenté ci-dessous.

a == 2

Comme vous le savez, il y a une différence entre l'utilisation d'un simple «égal à» et d'un double «égal à». L'utilisation de l'un au lieu de l'autre peut entraîner une erreur. Un «égal à» fait référence à l'assignation tandis qu'un double «égal à» fait référence à la comparaison. De même, nous avons des expressions et des fonctions ayant leurs modes d'implémentation prédéfinis.

Un autre exemple d'erreur de syntaxe est présenté ci-dessous -

for a= 1,10
   print(a)
end

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante -

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

Les erreurs de syntaxe sont beaucoup plus faciles à gérer que les erreurs d'exécution car l'interpréteur Lua localise l'erreur plus clairement qu'en cas d'erreur d'exécution. À partir de l'erreur ci-dessus, nous pouvons facilement savoir que l'ajout d'une instruction do avant l'instruction print est nécessaire selon la structure Lua.

Erreurs d'exécution

En cas d'erreurs d'exécution, le programme s'exécute avec succès, mais cela peut entraîner des erreurs d'exécution dues à des erreurs de saisie ou à des fonctions mal gérées. Un exemple simple pour montrer l'erreur d'exécution est présenté ci-dessous.

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

add(10)

Lorsque nous construisons le programme, il se construira avec succès et s'exécutera. Une fois qu'il s'exécute, affiche une erreur d'exécution.

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]: ?

Il s'agit d'une erreur d'exécution, qui s'est produite en raison du non-passage de deux variables. leb paramètre est attendu et ici il est nul et produit une erreur.

Fonctions d'assert et d'erreur

Afin de gérer les erreurs, nous utilisons souvent deux fonctions - assert et error. Un exemple simple est présenté ci-dessous.

local function add(a,b)
   assert(type(a) == "number", "a is not a number")
   assert(type(b) == "number", "b is not a number")
   return a+b
end

add(10)

Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie d'erreur suivante.

lua: test2.lua:3: b is not a number
stack traceback:
	[C]: in function 'assert'
	test2.lua:3: in function 'add'
	test2.lua:6: in main chunk
	[C]: ?

le error (message [, level])met fin à la dernière fonction protégée appelée et renvoie le message comme message d'erreur. Cette erreur de fonction ne revient jamais. En général, l'erreur ajoute des informations sur la position de l'erreur au début du message. L'argument de niveau spécifie comment obtenir la position d'erreur. Avec le niveau 1 (par défaut), la position d'erreur est l'endroit où la fonction d'erreur a été appelée. Le niveau 2 pointe l'erreur vers l'endroit où la fonction qui a appelé error a été appelée; etc. Le passage d'un niveau 0 évite l'ajout d'informations de position d'erreur au message.

pcall et xpcall

En programmation Lua, pour éviter de lancer ces erreurs et de gérer les erreurs, nous devons utiliser les fonctions pcall ou xpcall.

le pcall (f, arg1, ...)function appelle la fonction demandée en mode protégé. Si une erreur se produit dans la fonction f, elle ne génère pas d'erreur. Il renvoie simplement le statut d'erreur. Un exemple simple utilisant pcall est présenté ci-dessous.

function myfunction ()
   n = n/nil
end

if pcall(myfunction) then
   print("Success")
else
	print("Failure")
end

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante.

Failure

le xpcall (f, err)function appelle la fonction demandée et définit également le gestionnaire d'erreurs. Toute erreur à l'intérieur de f n'est pas propagée; à la place, xpcall détecte l'erreur, appelle la fonction err avec l'objet d'erreur d'origine et renvoie un code d'état.

Un exemple simple pour xpcall est présenté ci-dessous.

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante.

ERROR:	test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

En tant que programmeur, il est très important de vous assurer que vous prenez soin de gérer correctement les erreurs dans les programmes que vous écrivez. L'utilisation de la gestion des erreurs peut garantir que les conditions inattendues au-delà des conditions limites sont gérées sans déranger l'utilisateur du programme.