Gestion des erreurs Excel VBA - Tout ce que vous devez savoir !

Quelle que soit votre expérience avec le codage VBA, les erreurs en feront toujours partie.

La différence entre un programmeur novice et un programmeur expert en VBA est que les programmeurs experts savent comment gérer et utiliser efficacement les erreurs.

Dans ce didacticiel, je vais vous montrer différentes façons de gérer efficacement les erreurs dans Excel VBA.

Avant d'aborder la gestion des erreurs VBA, commençons par comprendre les différents types d'erreurs que vous êtes susceptible de rencontrer lors de la programmation dans Excel VBA.

Types d'erreurs VBA dans Excel

Il existe quatre types d'erreurs dans Excel VBA :

1. Erreurs de syntaxe
2. Erreurs de compilation
3. Erreurs d'exécution
4. Erreurs logiques

Comprenons rapidement quelles sont ces erreurs et quand vous êtes susceptible de les rencontrer.

Erreur de syntaxe

Une erreur de syntaxe, comme son nom l'indique, se produit lorsque VBA trouve un problème avec la syntaxe du code.

Par exemple, si vous oubliez une partie de l'instruction/de la syntaxe qui est nécessaire, vous verrez l'erreur de compilation.

Dans le code ci-dessous, dès que j'appuie sur Entrée après la deuxième ligne, je vois une erreur de compilation. C'est parce que le énoncé SI doit avoir le 'Puis', qui manque dans le code ci-dessous.

Noter: Lorsque vous tapez un code dans Excel VBA, il vérifie chaque phrase dès que vous appuyez sur Entrée. Si VBA trouve quelque chose qui manque dans la syntaxe, il affiche instantanément un message avec du texte qui peut vous aider à comprendre la partie manquante.

Pour vous assurer que vous voyez l'erreur de syntaxe chaque fois qu'il manque quelque chose, vous devez vous assurer que la vérification de la syntaxe automatique est activée. Pour ce faire, cliquez sur « Outils » puis sur « Options ». Dans la boîte de dialogue des options, assurez-vous que l'option « Vérification automatique de la syntaxe » est activée.

Si l'option « Vérification automatique de la syntaxe » est désactivée, VBA mettra toujours en surbrillance la ligne avec l'erreur de syntaxe en rouge, mais il n'affichera pas la boîte de dialogue d'erreur.

Erreur de compilation

Des erreurs de compilation se produisent lorsqu'il manque quelque chose qui est nécessaire pour que le code s'exécute.

Par exemple, dans le code ci-dessous, dès que j'essaie d'exécuter le code, il affichera l'erreur suivante. Cela se produit car j'ai utilisé l'instruction IF Then sans la fermer avec le "End If" obligatoire.

Une erreur de syntaxe est également un type d'erreur de compilation. Une erreur de syntaxe se produit dès que vous appuyez sur Entrée et VBA identifie qu'il manque quelque chose. Une erreur de compilation peut également se produire lorsque VBA ne trouve rien qui manque lors de la saisie du code, mais c'est le cas lorsque le code est compilé ou exécuté.

VBA vérifie chaque ligne pendant que vous tapez le code et met en évidence l'erreur de syntaxe dès que la ligne est incorrecte et que vous appuyez sur Entrée. Les erreurs de compilation, en revanche, ne sont identifiées que lorsque l'ensemble du code est analysé par VBA.

Vous trouverez ci-dessous quelques scénarios dans lesquels vous rencontrerez l'erreur de compilation :

1. Utilisation d'une instruction IF sans la fin IF
2. Utilisation de l'instruction For avec Next
3. Utilisation de l'instruction Select sans utiliser la commande End Select
4. Ne pas déclarer la variable (cela ne fonctionne que lorsque Option Explicit est activée)
5. Appeler une Sous/Fonction qui n'existe pas (ou avec des paramètres erronés)

Remarque sur « Option explicite »: Lorsque vous ajoutez 'Option Explicit', vous devrez déclarer toutes les variables avant d'exécuter le code. S'il y a une variable qui n'a pas été déclarée, VBA affichera une erreur. C'est une bonne pratique car elle affiche une erreur au cas où vous auriez une variable mal orthographiée. Vous pouvez en savoir plus sur Option Explicit ici.

Erreurs d'exécution

Les erreurs d'exécution sont celles qui se produisent lors de l'exécution du code.

Les erreurs d'exécution ne se produiront que lorsque toutes les erreurs de syntaxe et de compilation seront prises en charge.

Par exemple, si vous exécutez du code censé ouvrir un classeur Excel, mais que ce classeur n'est pas disponible (supprimé ou nom modifié), votre code vous donnera une erreur d'exécution.

Lorsqu'une erreur d'exécution se produit, le code s'arrête et vous affiche la boîte de dialogue d'erreur.

Le message dans la boîte de dialogue Erreur d'exécution est un peu plus utile. Il essaie d'expliquer le problème qui peut vous aider à le corriger.

Si vous cliquez sur le bouton Déboguer, il mettra en évidence la partie du code qui mène à l'erreur.

Si vous avez corrigé l'erreur, vous pouvez cliquer sur le bouton Exécuter dans la barre d'outils (ou appuyer sur F5) pour continuer à exécuter le code d'où il est parti.

Ou vous pouvez également cliquer sur le bouton Fin pour sortir du code.

Important: Si vous cliquez sur le bouton Fin dans la boîte de dialogue, cela arrêtera le code à la ligne à laquelle il est rencontré. Cependant, toutes les lignes de code avant cela auraient été exécutées.

Erreurs logiques

Les erreurs logiques n'arrêteraient pas votre code mais peuvent conduire à des résultats erronés. Il peut également s'agir des types d'erreurs les plus difficiles à résoudre.

Ces erreurs ne sont pas mises en évidence par le compilateur et doivent être corrigées manuellement.

Un exemple d'erreur logique (avec laquelle je me retrouve souvent coincé) est l'exécution d'une boucle sans fin.

Un autre exemple pourrait être lorsqu'il donne un résultat qui est faux. Par exemple, vous pouvez finir par utiliser une mauvaise variable dans le code ou ajouter deux variables là où l'une est incorrecte.

Il y a plusieurs façons que j'utilise pour résoudre les erreurs logiques :

1. Insérez la boîte de message à un endroit dans le code et mettez en surbrillance les valeurs/données qui peuvent aider à comprendre si tout se passe comme prévu.
2. Au lieu d'exécuter le code d'un seul coup, parcourez chaque ligne une par une. Pour ce faire, cliquez n'importe où dans le code et appuyez sur F8. vous remarquerez qu'à chaque fois que vous appuyez sur F8, une ligne est exécutée. Cela vous permet de parcourir le code une ligne à la fois et d'identifier les erreurs logiques.

Utilisation du débogage pour rechercher les erreurs de compilation/syntaxe

Une fois que vous avez terminé avec le code, c'est une bonne pratique de le compiler d'abord avant de l'exécuter.

Pour compiler un code, cliquez sur l'option Debug dans la barre d'outils et cliquez sur Compile VBAProject.

Lorsque vous compilez un projet VBA, il parcourt le code et identifie les erreurs (le cas échéant).

S'il trouve une erreur, il vous montrera une boîte de dialogue avec l'erreur. Il trouve les erreurs une par une. Donc, s'il trouve une erreur et que vous l'avez corrigée, vous devez relancer la compilation pour trouver d'autres erreurs (s'il y en a).

Lorsque votre code est exempt d'erreurs, l'option Compiler VBAProject sera grisée.

Notez que la compilation ne trouvera que les erreurs « Syntaxe » et les erreurs « Compilation ». Il ne trouvera PAS les erreurs d'exécution.

Lorsque vous écrivez du code VBA, vous ne voulez pas que les erreurs surviennent. Pour éviter cela, il existe de nombreuses méthodes de gestion des erreurs que vous pouvez utiliser.

Dans les prochaines sections de cet article, je couvrirai les méthodes que vous pouvez utiliser pour la gestion des erreurs VBA dans Excel.

Configurer les paramètres d'erreur (erreurs gérées par rapport aux erreurs non gérées)

Avant de commencer à travailler avec votre code, vous devez vérifier un paramètre dans Excel VBA.

Allez dans la barre d'outils VBA et cliquez sur Outils puis sur Options.

Dans la boîte de dialogue Options, cliquez sur l'onglet Général et assurez-vous que dans le groupe « Interruption des erreurs », « Rupture sur les erreurs non gérées » est coché.

Laissez-moi vous expliquer les trois options :

1. Pause sur toutes les erreurs: Cela arrêtera votre code sur tous les types d'erreurs, même lorsque vous avez utilisé les techniques pour gérer ces erreurs.
2. Module Pause en classe: Cela arrêtera votre code sur toutes les erreurs non gérées, et en même temps, si vous utilisez des objets tels que Userforms, il se brisera également dans ces objets et mettra en évidence la ligne exacte à l'origine de l'erreur.
3. Pause sur les erreurs non gérées: Cela arrêtera votre code uniquement pour les erreurs qui ne sont pas gérées. Il s'agit du paramètre par défaut car il garantit que toutes les erreurs non gérées sont signalées à votre attention. Si vous utilisez des objets tels que Userforms, cela ne mettra pas en surbrillance la ligne à l'origine de l'erreur dans l'objet, mais uniquement la ligne faisant référence à cet objet.

Noter: si vous travaillez avec des objets tels que des formulaires utilisateur, vous pouvez modifier ce paramètre sur « Rupture sur les modules de classe ». La différence entre #2 et #3 est que lorsque vous utilisez Break in Class Module, cela vous amènera à la ligne spécifique de l'objet qui provoque l'erreur. Vous pouvez également choisir de l'utiliser au lieu de « Rupture sur les erreurs non gérées ».

Donc, en un mot - si vous commencez tout juste avec Excel VBA, assurez-vous que la case "Rupture sur les erreurs non gérées" est cochée.

Gestion des erreurs VBA avec les déclarations « On Error »

Lorsque votre code rencontre une erreur, vous pouvez effectuer plusieurs opérations :

1. Ignorez l'erreur et laissez le code continuer
2. Avoir un code de gestion des erreurs en place et l'exécuter lorsqu'une erreur se produit

Ces deux méthodes de gestion des erreurs garantissent que l'utilisateur final ne verra pas d'erreur.

Il existe quelques déclarations « En erreur » que vous pouvez utiliser pour les faire.

En cas d'erreur Reprendre ensuite

Lorsque vous utilisez « On Error Resume Next » dans votre code, toute erreur rencontrée sera ignorée et le code continuera à s'exécuter.

Cette méthode de gestion des erreurs est utilisée assez souvent, mais vous devez être prudent lorsque vous l'utilisez. Comme il ignore complètement toute erreur pouvant survenir, vous ne pourrez peut-être pas identifier les erreurs qui doivent être corrigées.

Par exemple, si le code ci-dessous est exécuté, il renverra une erreur.

Sub AssignValues() x = 20 / 4 y = 30 / 0 End Sub

Cela se produit parce que vous ne pouvez pas diviser un nombre par zéro.

Mais si j'utilise l'instruction « On Error Resume Next » dans ce code (comme indiqué ci-dessous), l'erreur sera ignorée et je ne saurai pas qu'il y a un problème qui doit être corrigé.

Sub AssignValues() En cas d'erreur Reprendre Next x = 20 / 4 y = 30 / 0 End Sub

On Error Resume Next ne doit être utilisé que lorsque vous connaissez clairement le type d'erreurs que votre code VBA est censé générer et que vous pouvez l'ignorer.

Par exemple, vous trouverez ci-dessous le code d'événement VBA qui ajouterait instantanément la valeur de date et d'heure dans la cellule A1 d'une feuille nouvellement insérée (ce code est ajouté dans la feuille de calcul et non dans un module).

Private Sub Workbook_NewSheet(ByVal Sh As Object) Sh.Range("A1") = Format(Maintenant, "dd-mmm-yyyy hh:mm:ss") End Sub

Bien que cela fonctionne très bien dans la plupart des cas, une erreur s'afficherait si j'ajoutais une feuille de graphique au lieu d'une feuille de calcul. Étant donné qu'une feuille de graphique n'a pas de cellules, le code générerait une erreur.

Ainsi, si j'utilise l'instruction « On Error Resume Next » dans ce code, cela fonctionnera comme prévu avec les feuilles de calcul et ne fera rien avec les feuilles de graphique.

Private Sub Workbook_NewSheet(ByVal Sh As Object) En cas d'erreur Resume Next Sh.Range("A1") = Format(Maintenant, "dd-mmm-yyyy hh:mm:ss") End Sub

Remarque : En cas d'erreur, l'instruction suivante est mieux utilisée lorsque vous savez quel type d'erreur vous êtes susceptible de rencontrer. Et puis si vous pensez qu'il est sûr d'ignorer ces erreurs, vous pouvez l'utiliser.

Vous pouvez faire passer ce code au niveau supérieur en analysant s'il y a eu une erreur et en affichant un message pertinent pour cela.

Le code ci-dessous afficherait une boîte de message qui informerait l'utilisateur qu'une feuille de calcul n'a pas été insérée.

Private Sub Workbook_NewSheet(ByVal Sh As Object) On Error Resume Next Sh.Range("A1") = Format(Maintenant, "dd-mmm-yyyy hh:mm:ss") If Err.Number 0 Then MsgBox "On dirait que vous inséré une feuille de graphique" & vbCrLf & "Error - " & Err.Description End If End Sub

"Err.Number" est utilisé pour obtenir le numéro d'erreur et "Err.Description" est utilisé pour obtenir la description de l'erreur. Ceux-ci seront traités plus loin dans ce tutoriel.

En cas d'erreur GoTo 0

« On Error GoTo 0 » arrêtera le code sur la ligne qui provoque l'erreur et affichera une boîte de message décrivant l'erreur.

En termes simples, il active le comportement de vérification d'erreur par défaut et affiche le message d'erreur par défaut.

Alors pourquoi même l'utiliser ?

Normalement, vous n'avez pas besoin d'utiliser 'On Error Goto 0', mais cela peut être utile lorsque vous l'utilisez en conjonction avec 'On Error Resume Next'

Laisse-moi expliquer!

Le code ci-dessous sélectionnerait toutes les cellules vides de la sélection.

Sub SelectFormulaCells() Selection.SpecialCells(xlCellTypeBlanks).Select End Sub

Mais cela afficherait une erreur lorsqu'il n'y a pas de cellules vides dans les cellules sélectionnées.

Donc, pour éviter d'afficher l'erreur, vous pouvez utiliser On Error Resume ensuite’

Désormais, il affichera également toute erreur lorsque vous exécutez le code ci-dessous :

Sub SelectFormulaCells() en cas d'erreur Reprendre la sélection suivante.SpecialCells(xlCellTypeBlanks).Select End Sub

Jusqu'ici tout va bien!

Le problème survient lorsqu'il y a une partie du code où une erreur peut se produire, et puisque vous utilisez « On Error Resume Next », le code l'ignorerait simplement et passerait à la ligne suivante.

Par exemple, dans le code ci-dessous, il n'y aurait pas d'invite d'erreur :

Sub SelectFormulaCells() En cas d'erreur Resume Next Selection.SpecialCells(xlCellTypeBlanks).Select '… plus de code pouvant contenir une erreur End Sub

Dans le code ci-dessus, il y a deux endroits où une erreur peut se produire. Le premier endroit est l'endroit où nous sélectionnons toutes les cellules vides (à l'aide de Selection.SpecialCells) et le second est dans le code restant.

Alors que la première erreur est attendue, toute erreur ultérieure ne l'est pas.

C'est là qu'On Error Goto 0 vient à la rescousse.

Lorsque vous l'utilisez, vous réinitialisez le paramètre d'erreur par défaut, où il commencera à afficher des erreurs lorsqu'il le rencontrera.

Par exemple, dans le code ci-dessous, il n'y aurait pas d'erreur au cas où il n'y aurait pas de cellules vides, mais il y aurait une invite d'erreur à cause de '10/0'

Sub SelectFormulaCells() On Error Resume Next Selection.SpecialCells(xlCellTypeBlanks).Select On Error GoTo 0 '… plus de code pouvant contenir une erreur End Sub

En cas d'erreur Aller à [Étiquette]

Les deux méthodes ci-dessus - "On Error Resume Next" et "On Error Goto 0" - ne nous permettent pas de vraiment gérer l'erreur. L'un fait en sorte que le code ignore l'erreur et le second reprenne la vérification des erreurs.

On Error Go [Label] est un moyen avec lequel vous pouvez spécifier ce que vous voulez faire au cas où votre code aurait une erreur.

Vous trouverez ci-dessous la structure de code qui utilise ce gestionnaire d'erreurs :

Sub Test() On Error GoTo Label : X = 10 / 0 'cette ligne provoque une erreur'… .votre code restant va ici Exit Sub Label : 'code pour gérer l'erreur End Sub

Notez qu'avant le traitement d'erreur « Étiquette », il y a un Exit Sub. Cela garantit qu'en cas d'absence d'erreur, le sous-marin est quitté et le code « Label » n'est pas exécuté. Si vous n'utilisez pas Exit Sub, il exécutera toujours le code « Label ».

Dans l'exemple de code ci-dessous, lorsqu'une erreur se produit, le code saute et exécute le code dans la section du gestionnaire (et affiche une boîte de message).

Sub Errorhandler() On Error GoTo ErrMsg X = 12 Y = 20 / 0 Z = 30 Exit Sub ErrMsg: MsgBox "Il semble y avoir une erreur" & vbCrLf & Err.Description End Sub

Notez que lorsqu'une erreur se produit, le code a déjà exécuté et exécuté les lignes avant la ligne provoquant l'erreur. Dans l'exemple ci-dessus, le code définit la valeur de X sur 12, mais puisque l'erreur se produit dans la ligne suivante, il ne définit pas les valeurs pour Y et Z.

Une fois que le code passe au code du gestionnaire d'erreurs (ErrMsg dans cet exemple), il continuera à exécuter toutes les lignes dans et au-dessous du code du gestionnaire d'erreurs et quittera le sous.

En cas d'erreur Aller à -1

Celui-ci est un peu compliqué, et dans la plupart des cas, il est peu probable que vous l'utilisiez.

Mais je couvrirai toujours cela car j'ai été confronté à une situation où cela était nécessaire (n'hésitez pas à ignorer et à passer à la section suivante si vous ne recherchez que les bases).

Avant d'entrer dans les détails, permettez-moi d'essayer d'expliquer en quoi cela peut être utile.

Supposons que vous ayez un code où une erreur est rencontrée. Mais tout va bien car vous avez un gestionnaire d'erreurs en place. Mais que se passe-t-il lorsqu'il y a une autre erreur dans le code du gestionnaire d'erreurs (ouais… un peu comme le film de création).

Dans un tel cas, vous ne pouvez pas utiliser le deuxième gestionnaire car la première erreur n'a pas été effacée. Ainsi, bien que vous ayez traité la première erreur, elle existe toujours dans la mémoire de VBA. Et la mémoire VBA n'a de place que pour une erreur - pas deux ou plus.

Dans ce scénario, vous pouvez utiliser On Error Goto -1.

Il efface l'erreur et libère de la mémoire VBA pour gérer l'erreur suivante.

Assez parlé !

Expliquons-moi maintenant en utilisant des exemples.

Supposons que j'ai le code ci-dessous. Cela lancera une erreur car il y a division par zéro.

Sub Errorhandler() X = 12 Y = 20 / 0 Z = 30 End Sub

Donc, pour le gérer, j'utilise un code de gestionnaire d'erreurs (avec le nom ErrMsg) comme indiqué ci-dessous :

Sub Errorhandler() On Error GoTo ErrMsg X = 12 Y = 20 / 0 Z = 30 Exit Sub ErrMsg: MsgBox "Il semble y avoir une erreur" & vbCrLf & Err.Description End Sub

Tout va bien maintenant à nouveau. Dès que l'erreur se produit, le gestionnaire d'erreurs est utilisé et affiche une boîte de message comme indiqué ci-dessous.

Maintenant, je développe le code afin d'avoir plus de code dans ou après le gestionnaire d'erreurs.

Sub Errorhandler() On Error GoTo ErrMsg X = 12 Y = 20 / 0 Z = 30 Exit Sub ErrMsg: MsgBox "Il semble y avoir une erreur" & vbCrLf & Err.Description A = 10 / 2 B = 35 / 0 End Sub

Étant donné que la première erreur a été gérée mais pas la seconde, je vois à nouveau une erreur comme indiqué ci-dessous.

Toujours tout bon. Le code se comporte comme nous l'espérions.

Donc, pour gérer la deuxième erreur, j'utilise un autre gestionnaire d'erreurs (ErrMsg2).

Sub Errorhandler() On Error GoTo ErrMsg X = 12 Y = 20 / 0 Z = 30 Quitter Sub ErrMsg: MsgBox "Il semble y avoir une erreur" & vbCrLf & Err.Description On Error GoTo ErrMsg2 A = 10 / 2 B = 35 / 0 Exit Sub ErrMsg2: MsgBox "Il semble qu'il y ait à nouveau une erreur" & vbCrLf & Err.Description End Sub

Et c'est là qu'il ne fonctionne pas comme prévu.

Si vous exécutez le code ci-dessus, il vous donnera toujours une erreur d'exécution, même après avoir mis en place le deuxième gestionnaire d'erreurs.

Cela se produit car nous n'avons pas effacé la première erreur de la mémoire de VBA.

Oui, nous nous en sommes occupés ! Mais il reste toujours dans la mémoire.

Et lorsque VBA rencontre une autre erreur, il est toujours bloqué avec la première erreur et, par conséquent, le deuxième gestionnaire d'erreurs n'est pas utilisé. Le code s'arrête à la ligne qui a causé l'erreur et affiche l'invite d'erreur.

Pour effacer la mémoire de VBA et effacer l'erreur précédente, vous devez utiliser le "On Error Goto -1".

Donc, si vous ajoutez cette ligne dans le code ci-dessous et que vous l'exécutez, cela fonctionnera comme prévu.

Sub Errorhandler() On Error GoTo ErrMsg X = 12 Y = 20 / 0 Z = 30 Quitter Sub ErrMsg: MsgBox "Il semble y avoir une erreur" & vbCrLf & Err.Description On Error GoTo -1 On Error GoTo ErrMsg2 A = 10 / 2 B = 35 / 0 Exit Sub ErrMsg2 : MsgBox "Il semble qu'il y ait encore une erreur" & vbCrLf & Err.Description End Sub

Noter: L'erreur est automatiquement effacée lorsqu'un sous-programme se termine.Ainsi, « On Error Goto -1 » peut être utile lorsque vous obtenez deux ou plus de deux erreurs dans le même sous-programme.

L'objet d'erreur

Chaque fois qu'une erreur se produit avec un code, c'est l'objet Err qui est utilisé pour obtenir les détails sur l'erreur (comme le numéro d'erreur ou la description).

Err Propriétés de l'objet

L'objet Err a les propriétés suivantes :

Biens	La description
Numéro	Un nombre qui représente le type d'erreur. Lorsqu'il n'y a pas d'erreur, cette valeur est 0
La description	Une brève description de l'erreur
La source	Nom du projet dans lequel l'erreur s'est produite
Contexte de l'aide	L'identifiant du contexte d'aide pour l'erreur dans le fichier d'aide
Fichier d'aide	Une chaîne qui représente l'emplacement du dossier et le nom de fichier du fichier d'aide

Bien que dans la plupart des cas, vous n'ayez pas besoin d'utiliser l'objet Err, cela peut parfois être utile lors de la gestion des erreurs dans Excel.

Par exemple, supposons que vous ayez un jeu de données comme indiqué ci-dessous et que pour chaque nombre, dans la sélection, vous vouliez calculer la racine carrée dans la cellule adjacente.

Le code ci-dessous peut le faire, mais comme il y a une chaîne de texte dans la cellule A5, il affiche une erreur dès que cela se produit.

Sub FindSqrRoot() Dim rng As Range Set rng = Selection For Each Cell In rng cell.Offset(0, 1).Value = Sqr(cell.Value) Next cell End Sub

Le problème avec ce type de message d'erreur est qu'il ne vous donne rien sur ce qui ne va pas et où le problème s'est produit.

Vous pouvez utiliser l'objet Err pour rendre ces messages d'erreur plus significatifs.

Par exemple, si j'utilise maintenant le code VBA ci-dessous, il arrêtera le code dès que l'erreur se produira et affichera une boîte de message avec l'adresse de la cellule où il y a un problème.

Sub FindSqrRoot() Dim rng As Range Set rng = Selection For Each Cell In rng On Error GoTo ErrHandler cell.Offset(0, 1).Value = Sqr(cell.Value) Cellule suivante ErrHandler: MsgBox "Error Number:" & Err .Number & vbCrLf & _ "Description de l'erreur : " & Err.Description & vbCrLf & _ "Erreur à : " & cell.Address End Sub

Le code ci-dessus vous donnerait beaucoup plus d'informations que le simple "Type Mismatch", en particulier l'adresse de la cellule afin que vous sachiez où l'erreur s'est produite.

Vous pouvez affiner davantage ce code pour vous assurer que votre code s'exécute jusqu'à la fin (au lieu de se briser à chaque erreur), puis vous donne une liste d'adresses de cellule où l'erreur se produit.

Le code ci-dessous ferait ceci:

Sub FindSqrRoot2() Dim ErrorCells As String Dim rng As Range On Error Resume Next Set rng = Selection For Each Cell In rng cell.Offset(0, 1).Value = Sqr(cell.Value) If Err.Number 0 Then ErrorCells = ErrorCells & vbCrLf & cell.Address On Error GoTo -1 End If Next cell MsgBox "Erreur dans les cellules suivantes" & ErrorCells Exit Sub End Sub

Le code ci-dessus s'exécute jusqu'à la fin et donne la racine carrée de toutes les cellules qui contiennent des nombres (dans la colonne adjacente). Il affiche ensuite un message qui répertorie toutes les cellules où il y a eu une erreur (comme indiqué ci-dessous) :

Méthodes d'objet d'erreur

Bien que les propriétés Err soient utiles pour afficher des informations utiles sur les erreurs, il existe également deux méthodes Err qui peuvent vous aider à gérer les erreurs.

Méthode	La description
Dégager	Efface tous les paramètres de propriété de l'objet Err
Augmenter	Génère une erreur d'exécution

Apprenons rapidement ce que c'est et comment/pourquoi les utiliser avec VBA dans Excel.

Err Effacer la méthode

Supposons que vous ayez un ensemble de données comme indiqué ci-dessous et que vous souhaitiez obtenir la racine carrée de tous ces nombres dans la colonne adjacente.

Le code suivant obtiendra les racines carrées de tous les nombres de la colonne adjacente et affichera un message indiquant qu'une erreur s'est produite pour les cellules A5 et A9 (car elles contiennent du texte).

Sub FindSqrRoot2() Dim ErrorCells As String Dim rng As Range On Error Resume Next Set rng = Selection For Each Cell In rng cell.Offset(0, 1).Value = Sqr(cell.Value) If Err.Number 0 Then ErrorCells = ErrorCells & vbCrLf & cell.Address Err.Clear End If Next cell MsgBox "Erreur dans les cellules suivantes" & ErrorCells End Sub

Notez que j'ai utilisé la méthode Err.Clear dans l'instruction If Then.

Une fois qu'une erreur s'est produite et interceptée par la condition If, la méthode Err.Clear réinitialise le numéro d'erreur à 0. Cela garantit que la condition IF intercepte uniquement les erreurs pour les cellules où elle est déclenchée.

Si je n'avais pas utilisé la méthode Err.Clear, une fois que l'erreur s'est produite, elle serait toujours vraie dans la condition IF et le numéro d'erreur n'a pas été réinitialisé.

Une autre façon de faire fonctionner cela consiste à utiliser On Error Goto -1, qui réinitialise complètement l'erreur.

Noter: Err.Clear est différent de On Error Goto -1. Err.Clear n'efface que la description de l'erreur et le numéro de l'erreur. il ne le réinitialise pas complètement. Cela signifie que s'il y a une autre instance d'erreur dans le même code, vous ne pourrez pas la gérer avant de la réinitialiser (ce qui peut être fait avec "On Error Goto -1" et non par "Err.Clear").

Méthode d'augmentation d'erreur

La méthode Err.Raise vous permet de déclencher une erreur d'exécution.

Vous trouverez ci-dessous la syntaxe de l'utilisation de la méthode Err.Raise :

Err.Raise [numéro], [source], [description], [helpfile], [helpcontext]

Tous ces arguments sont facultatifs et vous pouvez les utiliser pour rendre votre message d'erreur plus significatif.

Mais pourquoi voudriez-vous jamais signaler une erreur vous-même ?

Bonne question!

Vous pouvez utiliser cette méthode lorsqu'il y a une instance d'erreur (ce qui signifie qu'il y aura une erreur de toute façon), puis vous utilisez cette méthode pour en dire plus à l'utilisateur sur l'erreur (au lieu du message d'erreur moins utile que VBA affiche par défaut).

Par exemple, supposons que vous ayez un jeu de données comme indiqué ci-dessous et que vous souhaitiez que toutes les cellules aient uniquement des valeurs numériques.

Sub RaiseError() Dim rng As Range Set rng = Selection On Error GoTo ErrHandler For Each Cell In rng If Not (IsNumeric(Cell.Value)) Then Err.Raise vbObjectError + 513, Cell.Address, "Pas un nombre", " Test.html" End If Next Cell ErrHandler: MsgBox Err.Description & vbCrLf & Err.HelpFile End Sub

Le code ci-dessus afficherait un message d'erreur contenant la description spécifiée et le fichier de contexte.

Personnellement, je n'ai jamais utilisé Err.Raise car je travaille principalement avec Excel uniquement. Mais pour quelqu'un qui utilise VBA pour travailler avec Excel avec d'autres applications telles que Outlook, Word ou PowerPoint, cela peut être utile.

Voici un article détaillé sur la méthode Err.Raise au cas où vous voudriez en savoir plus.

Meilleures pratiques de gestion des erreurs VBA

Peu importe à quel point vous obtenez un code VBA d'écriture, les erreurs en feront toujours partie. Les meilleurs codeurs sont ceux qui ont les compétences pour gérer correctement ces erreurs.

Voici quelques bonnes pratiques que vous pouvez utiliser en matière de gestion des erreurs dans Excel VBA.

1. Utilisez « On Error Go [Label] » au début du code. Cela garantira que toute erreur pouvant survenir à partir de là est gérée.
2. Utilisez « On Error Resume Next » UNIQUEMENT lorsque vous êtes sûr des erreurs qui peuvent se produire. Utilisez-le uniquement avec l'erreur attendue. Si vous l'utilisez avec des erreurs inattendues, il l'ignorera simplement et avancera. Vous pouvez utiliser « On Error Resume Next » avec « Err.Raise » si vous souhaitez ignorer un certain type d'erreur et attraper le reste.
3. Lorsque vous utilisez des gestionnaires d'erreurs, assurez-vous d'utiliser Exit Sub avant les gestionnaires. Cela garantira que le code du gestionnaire d'erreurs est exécuté uniquement en cas d'erreur (sinon, il sera toujours exécuté).
4. Utilisez plusieurs gestionnaires d'erreurs pour intercepter différents types d'erreurs. Le fait d'avoir plusieurs gestionnaires d'erreurs garantit qu'une erreur est correctement traitée. Par exemple, vous voudriez gérer une erreur « incompatibilité de type » différemment d'une erreur d'exécution « Division par 0 ».

J'espère que vous avez trouvé cet article Excel utile!

Voici d'autres didacticiels Excel VBA que vous pourriez aimer :

• Types de données Excel VBA - Un guide complet
• Boucles Excel VBA - Pour le suivant, faire pendant, faire jusqu'à, pour chacun
• Événements Excel VBA - Un guide simple (et complet)
• Excel Visual Basic Editor - Comment l'ouvrir et l'utiliser dans Excel