Comprendre et corriger les erreurs de VBA [#29 FORMATION EXCEL VBA COMPLETE]

Pour ce nouveau chapitre de la formation dédié à la découverte du développement en VBA, je vous propose de découvrir les différentes erreurs auxquelles nous allons être amenés à nous confronter dans le cadre du développement d’applications VBA.

Téléchargement

Vous pouvez télécharger le fichier d'exemple de cet article en cliquant sur le lien suivant :

Tutoriel Vidéo

Partie 1 : Comprendre et corriger les erreurs de VBA

Partie 2 : Dompter les erreurs de VBA pour mieux les corriger

Partie 3 : Les outils de débogage intégrés à VBE

1. Qu’est-ce qu’une erreur de VBA

À l’instar des formules saisies dans Excel, il arrive régulièrement lorsque nous développons une application en VBA, que nous soyons confrontés à des erreurs qui viennent interrompre le cours du développement, ou encore de l’exécution de la macro.

Ces erreurs se matérialisent le plus souvent par un message d’erreur présenté à l’utilisateur :

En présence de ce message, celui-ci peut au choix :

• Fin : Mettre fin à l’exécution de la macro, sans que la suite ne puisse être exécutée, et retourner sur la feuille de calcul,
• Débogage : Mettre fin à l’exécution de la macro une fois encore, mais en présentant directement la ligne incriminée et en passant VBE en mode de débogage
• Aide : ce bouton permet quant à lui de consulter la documentation relative à l’erreur pointée, sur le site de Microsoft. En revanche, cliquer sur le bouton Aide ne permet pas de fermer le message d’erreur, qui sera toujours présent lorsque que nous reviendrons dans l’éditeur VBE.

Dans ce dernier cas, la ligne ayant générée l’anomalie est surlignée en jaune

Dans cet exemple, VBA nous informe qu’il rencontre une erreur d’exécution 13, c’est-à-dire liée à une incompatibilité de type :

Sub testErreur()
    a = "coucou"
    b = a + 5
End Sub

Si vous avez suivi correctement les précédents chapitres de cette formation dédiée à l’apprentissage de VBA d’Excel, vous aurez alors facilement identifié l’origine de cette erreur.

En effet, étant donné que n’avons pas déclaré explicitement le type de la variable a, celle-ci a été définie par Excel comme étant une variable Variant, ce qui lui n permet alors de recevoir toutes sortes d’informations.

Nous lui avons ensuite donné pour valeur la chaîne « coucou ».

Aucun problème jusque-là.

Par contre, lorsque nous insérons cette variable dans un calcul, aussi simple soit-il, une erreur est forcément retournée !

Dans cet exemple, la résolution de l’erreur est très simple, il suffit de donner une valeur numérique à la variable a :

Sub testErreur()
    a = 2
    b = a + 5
End Sub

Une fois le problème de code réglé, il suffit de réinitialiser VBA en cliquant sur le carré bleu :

Puis de relancer le code en cliquant sur le triangle vert (ou en appuyant sur la touche [F5]) pour l’exécuter à nouveau :

Mais bien entendu, il existe de nombreux autres types d’erreurs qui peuvent être plus ou moins complexes à corriger.

2. Les erreurs de syntaxe

Les erreurs de syntaxe sont des erreurs qui ont lieu lors de la saisie des instructions de VBA.

Il s’agit à la fois des erreurs les plus courantes à utiliser et également les plus simples à corriger.

Lorsque l’instruction est saisie sur une seule ligne, alors VBE sera capable de détecter ces erreurs au fil de leur saisie et de nous en informer directement lors de la validation de la ligne :

if a > 5 a = 5

Ici, VBE nous informe immédiatement que le problème vient du fait qu’il manque le Then à notre If.

En revanche, si l’instruction est saisie sur plusieurs lignes, VBE ne nous informera de l’erreur que lorsque nous tenterons d’exécuter le code :

    If a > 5 Then
        a = 5
    Else
        a = 2

Ici il manque le End If à la fin de l’instruction If.

Nous serons également alertés en cas d’erreur dans le cas d’une saisie incorrecte d’une instruction :

    msbox "Coucou"

Ici VBA ne parvient pas à identifier l’instruction MsBox, dans laquelle il manque le « g ».

Pour notre dernier exemple concernant les erreurs de compilation, imaginons que nous souhaitions afficher à l’écran le mot « coucou ».

Sauf que par inadvertance, nous omettons de saisir les guillemets :

    MsgBox coucou

Ici, Excel va considérer que le terme coucou n’est pas un texte, mais une variable !

Celle-ci n’ayant aucune valeur déclarée, il va simplement afficher un message vide :

Il faut bien comprendre qu’ici il n’y a aucune erreur apparente, mais par contre toute la suite du programme sera vérolée !

Il serait alors bien plus pratique d’afficher un message d’erreur pour nous inviter à corriger le problème !

Pour cela, il suffit d’ajouter l’instruction « Option Explicit » en tout début de code.

De cette manière, et comme nous l’avons déjà abordé au cours des chapitres précédents, Excel va maintenant nous demander de déclarer toutes les variables utilisées dans le module.

Nous allons alors déclarer les variables a et b, mais en aucun cas la variable coucou (qui pour rappel correspond à une chaîne de caractères) :

Nous comprendrons alors notre erreur et la corrigerons dans la foulée :

    MsgBox "coucou"

Pour désactiver l’apparition du message (ce que je vous déconseille fortement), rendez-vous dans le menu Outils > Options :

Ensuite, décochez simplement le menu « Vérification automatique de la syntaxe ».

De cette manière, le message n’apparaîtra que lorsque la macro sera exécutée.

3. Les erreurs d’exécutions

Malheureusement, VBE ne va pas être capable de détecter automatiquement toutes les erreurs au fil de la saisie.

Certaines erreurs ne seront en effet présentées que dans certains contextes en particulier.

Pour reprendre l’exemple étudié au début de ce chapitre, imaginons que la valeur de a ne soit plus saisie directement, mais que ce soit à l’utilisateur de la renseigner via un InputBox :

    a = InputBox("Quelle est la valeur de a  ?")

Tant que l’utilisateur va saisir des nombres, Excel n’aura aucun problème pour exécuter le code :

En revanche, dès que le résultat ne sera pas numérique, alors le code retournera une erreur :

Il convient alors d’effectuer un contrôle sur la valeur retournée (en utilisant par exemple la fonction IsNumeric() qui retourne une valeur Booléenne qui sera égale à True (vrai) lorsque la valeur passée en argument est un nombre ou à False (faux) dans le cas contraire) :

    a = InputBox("Quelle est la valeur de a  ?")
    If Not IsNumeric(a) Then Exit Sub

Il existe de nombreux cas de figure pouvant conduire à une erreur :

• Ouverture d’un fichier inexistant,
• Appel d’un index de tableau des index déclarés,
• Saisie d’une donnée sur une cellule protégée,
• …

Et il est alors important de savoir envisager tous les cas de figure afin de pouvoir anticiper les erreurs et de la corriger avant que celles-ci ne se produisent !

4. Dompter les erreurs pour mieux les corriger

Comme nous venons de le voir, il n’est pas toujours évident de pouvoir anticiper tous les types d’erreurs possibles.

En revanche, VBA dispose de sa palette d’outils qui vont nous permettre de travailler avec les erreurs.

Pour nous en rendre compte, nous allons utiliser la macro suivante :

Sub testErreurBis()
    Dim a As Integer, i As Integer
    
    a = 2
    For i = 1 To 10
        a = a ^ 2
        Debug.Print a
    Next
End Sub

Ici, nous déclarons deux variables a et i.

La première de ces variables va nous permettre d’effectuer des calculs, tandis que la seconde va être utilisée pour lancer une boucle.

Le calcul va alors être simple, nous allons simplement vouloir affecter à la valeur a, la puissance au carré de sa propre valeur et ensuite nous allons simplement afficher la valeur correspondante dans la fenêtre d’exécution.

Cette opération nous allons vouloir la répéter 10 fois.

Lorsque nous exécutions cette macro, nous allons pouvoir constater deux choses :

• La boucle a effectivement pu se lancer trois fois (nous retrouvons en effet dans la fenêtre d’exécution les valeurs successives 4, 16 et 256),
• Ensuite la macro a généré une erreur dite d’exécution dite « Erreur d’exécution 6 »

Le message d’information lié à cette erreur est très clair : dépassement de capacité, c’est-à-dire que nous avons essayé d’affecter à une variable une valeur qui lui est incompatible.

En effet, nous souhaitons stocker dans la variable a la valeur correspondante au résultat 256 élevé au carré, soit de 256x256, soit encore une valeur 65536.

Or, comme nous l’avons déjà vu dans le chapitre dédié à l’utilisation des variables, une variable typée en tant que Integer ne peut enregistrer qu’une valeur comprise entre -32768 et +32768.

Pour éviter d’être à nouveau confronté à cette erreur, nous pourrions bien entendu changer directement le type de la variable, mais cela serait bien trop facile !

   4.1. Quitter la macro en présence d’une erreur

La première possibilité qui va nous permettre ici d’éviter l’affichage du message d’erreur sera alors de simplement quitter le déroulé de la macro.

Pour cela nous allons faire appel à une notion que nous avons déjà eu l’occasion d’aborder dans un chapitre précédent, il s’agit des étiquettes, qui pour rappel permettent d’atteindre un endroit précis d’une macro à l’aide de l’instruction GoTo.

Nous commençons donc par poser l’étiquette « finDeMacro » en toute fin de macro :

Sub testErreurBis()
    …
    
finDeMacro:
 
End Sub

Puis, nous allons demander à Excel de capturer toute erreur éventuelle à l’intérieur de la macro afin de se rendre directement au niveau de l’étiquette que nous venons de poser.

Pour cela, nous utilisons l’instruction « On Error Goto finDeMacro », juste avant de lancer la boucle :

Sub testErreurBis()
    Dim a As Integer, i As Integer
    
    a = 2
    
    On Error GoTo finDeMacro
    
    For i = 1 To 10
        a = a ^ 2
        Debug.Print a
    Next
    
finDeMacro:
 
End Sub

Nous pouvons alors lancer la macro :

La fenêtre d’exécution ne va encore une fois ne retourner que trois résultats (4, 16 et 256), mais désormais aucun message d’erreur ne vient interrompre le déroulement de la macro !

Mais si nous le souhaitons, nous pouvons afficher un message d’erreur en plaçant une instruction MsgBox après la déclaration de l’étiquette :

finDeMacro:   MsgBox "Erreur : la variable a ne  peut être supérieure à 32767 !"

Par contre, maintenant modifions légèrement la macro pour demander à ce que a soit maintenant simplement incrémenté d’une unité :

    For i = 1 To 10
        a = a + 1
        Debug.Print a
    Next

Si nous lançons la macro, nous allons bien retrouver toutes les valeurs prises par a (de 2 à 12), mais nous allons malgré tout nous retrouver avec le message vu juste avant :

La raison en est très simple : une fois sortie de la boucle, la macro suit son déroulement normal.

Elle arrive donc au niveau de l’étiquette et à ce moment-là, comme nous le lui avons demandé, elle affiche le message d’erreur !

Il est donc nécessaire d’interrompre le déroulement de la macro juste avant l’étiquette, de manière à ce que le seul moyen de l’atteindre soit l’instruction GoTo.

Pour cela, nous insérons une instruction « Exit Sub » :

Sub testErreurBis()
    …
    
    Exit Sub
    
finDeMacro:   MsgBox "Erreur : la variable a ne  peut être supérieure à 32767 !"
 
End Sub

Le message ne s’affiche maintenant plus.

Il faut savoir que l’instruction On Error que nous venons d’utiliser ici permet d’appliquer notre propre système de gestion des erreurs, à la place de celui de VBA.

Si ce besoin s’avère n’être que provisoire, alors nous pouvons simplement rendre la main à VBA en utilisant cette fois-ci l’instruction « On Error Goto 0 » :

    On Error GoTo finDeMacro
    
    For i = 1 To 10
        a = a + 1
        Debug.Print a
    Next
    
    On Error GoTo 0

Dans cet exemple, cela n’aura aucune incidence, mais nous pouvons imaginer le cas d’une macro-commande plus importante, et au sein de laquelle nous ne souhaiterions capturer les erreurs que sur une portion donnée.

   4.2. Ignorer les erreurs

Nous pouvons également imaginer le cas dans lequel nous souhaiterons simplement passer outre les erreurs éventuelles, et continuer d’exécuter le code comme si aucune erreur n’avait été détectée.

Pour cela, nous allons utiliser l’instruction « On Error Resume Next » :

Sub testErreurContinuer()
    Dim a As Integer, i As Integer
    
    a = 2
    
    On Error Resume Next
    
    For i = 1 To 10
        a = a ^ a
        Debug.Print a
    Next
 
End Sub

Attention toutefois, utiliser cette instruction peut avoir de lourdes conséquences sur le déroulement du code.

En effet, dans notre exemple, nous indiquons à VBA que nous ne souhaitons pas que les erreurs interrompent la macro, mais pour autant cela ne signifie pas que la valeur incompatible avec le type Integer pour être stockée.

VBA ignore tout simplement la ligne problématique et la variable a se retrouve avec une valeur erronée.

   4.3. Personnaliser les messages d’erreurs

Lorsqu’une erreur se produit, l’application ne se contente pas de simplement d’afficher un message d’erreur.

En effet, en plus de cela, Excel va instancier un nouvel objet qui porte le nom de Err et dans lequel nous allons pouvoir retrouver le numéro de l’erreur ainsi que la description correspondante.

Reprenons l’exemple vu à l’instant avec la macro « testErreurQuitter »

Maintenant, nous allons souhaiter que le message d’erreur n’interrompe pas forcément le déroulement de la macro et pour cela, nous allons préférer que celui-ci s’affiche dans la fenêtre d’exécution et non pas sur une notification :

Comme nous venons de le voir, les erreurs font partie du quotidien de tout développeur, y compris pour les développeurs de macros VBA.

S’il paraît très difficile, voir impossible d’imaginer anticiper toutes les erreurs pouvant intervenir, il existe toutefois des outils intégrés à VBE qui vont permettre d’analyser et de corriger un maximum n’anomalies pouvant se présenter.

5. Techniques de débogage du code

Dans cette partie du chapitre dédié à la découverte de la gestion des erreurs de VBA, nous allons découvrir les différentes techniques d’analyse du code qui vont permettre de réduire au maximums les comportements imprévus de nature à entraver le bon déroulement de celui-ci.

Pour rappel, comme nous venons de le voir, il existe deux types de bugs :

• Les bugs de codage, qui sont de natures à empêcher le bon déroulement du code, qui bien qu’énervant ce sont les plus simples à identifier étant donné qu’Excel va clairement nous informer de leur présence, et même de leur positionnement !
• En revanche, les bugs de développement sont les plus pernicieux. En effet, ils n’empêchent pas forcément la macro-commande de s’exécuter, mais risque à un moment donné d’avoir des conséquences sur les résultats de celle-ci…

Malheureusement, même si comme nous allons le voir il existe quelques méthodes qui vont permettre d’identifier l’origine d’un bug, rien ne remplacera une bonne connaissance du langage de programmation. Et bien évidemment, avec l’expérience, la correction des bugs deviendra de plus en plus aisée.

C’est en effet l’expérience, et les effets de l’habitude qui vont permettre de savoir rapidement où chercher les bugs se répétant le plus souvent.

   5.1. L’analyse des variables

Dans la plupart des cas, lorsqu’un bug se présente, c’est parce qu’une variable ne prend pas la valeur souhaitée.

Les raisons peuvent être nombreuses :

• Dépassement de la capacité autorisée par le type,
• Insertion de texte dans une variable numérique,
• Mauvaise affectation, …

Pour pister au fil de l’eau les valeurs des variables, il existe plusieurs solutions dont la plus courante consiste à afficher la valeur de celle-ci dans un message.

Pour illustrer ce cas de figure, imaginons que nous souhaitions créer une fonction qui va nous calculer le taux de TVA :

Function calculTVA(montantHT As Double, tauxTVA As  Double) as Double
    Dim montantTTC As Integer
    montantTTC = montantHT * (1 + tauxTVA)
    
    calculTVA = montantTTC - montantHT
End Function

Cette fonction est très simple :

• Elle demande deux arguments : le montant HT et le taux de TVA à appliquer,
• Ensuite la fonction calcul le montant TTC qui est stocké dans la variable montantTTC,
• Et pour finir, le résultat retourné correspond à la différence entre le montant TTC et le montant HT

Bien entendu, nous pourrions gagner un peu de temps en multipliant tout simplement le montant HT par le taux de TVA, mais cette fonction ne sert ici que d’exemple.

Ensuite, pour tester la fonction, nous créons une nouvelle procédure qui va permettre de récupérer le montant de la TVA de deux produits :

Sub testPrixTVA()
    Dim totalTVA As Double, TVA1 As Double, TVA2 As Double
    
    TVA1 = calculTVA(72.4, 0.2)
    TVA2 = calculTVA(52.93, 0.2)
    totalTVA = TVA1 + TVA2
    
    Debug.Print "Montant de la TVA", totalTVA
End Sub

Ici, nous pouvons lancer cette procédure, Excel ne rencontre alors aucune erreur et nous retourne comme valeur 25,67€ :

Aucun problème ?

Pas sûr ! Je vous laisse sortir la calculatrice et contrôler :

Certes, nous ne sommes pas loin du résultat, mais celui-ci en reste néanmoins erroné !

Maintenant, il ne nous reste plus qu’à en déterminer la cause…

Comme nous l’avons vu juste avant, nous allons décortiquer chaque variable, jusqu’à trouver la raison de cette anomalie.

Et pour cela, nous allons découvrir la première méthode, qui va consister à afficher chacune de ces valeurs après que celles-ci soient affectées :

    TVA1 = calculTVA(72.4, 0.2)
    MsgBox "La TVA de 72.40€ est de " & TVA1
    TVA2 = calculTVA(52.93, 0.2)
    MsgBox "La TVA de 52.93€ est de " & TVA2

Ici en affichant clairement la valeur prise par les variables TVA1 et TVA2, nous allons pouvoir définir si le bug se trouve dans la procédure testPrixTVA ou dans la fonction calculTVA.

Les messages affichés nous présentent alors les informations suivantes :

• La TVA de 72.40€ est de 14.60€

• La TVA de 52.93€ est de 11.07€

Nous pouvons alors contrôler ces informations et constater que celles-ci sont erronées !

Dès lors, nous avons la confirmation que le bug provient de la fonction testPrixTVA.

Nous pouvons alors y insérer un nouveau message :

    montantTTC = montantHT * (1 + tauxTVA)
    MsgBox "Le montant TTC de " & montantHT  & " est de " & montantTTC

Ce qui donne les informations :

• Le montant TTC de 72.40€ est de 87€

• Le montant TTC de 52.93€ est de 64€

Ce qui une fois encore n’est pas valide :

Pour nous rendre rapidement au niveau de la ligne de code erronée et pointée par le message, nous pouvons appuyer sur les touches [Ctrl]+[Pause] (sur certains claviers de PC portables, la touche [Pause] s’obtient en appuyant sur les touches [Fn]+[S]) afin d’afficher le message d’interruption de la macro :

Nous pouvons alors :

• Reprendre le cours de la macro,
• Terminer l’exécution de la macro,
• Terminer l’exécution de la macro et lancer la fenêtre de VBE tout en passant en mode débogage,
• Lancer une page d’aide depuis le site de Microsoft

Nous cliquons alors sur débogage, inutile de continuer d’exécuter la macro, celle-ci étant erronée :

Maintenant, nous pouvons avec certitude affirmer que le bug ne se situe que sur l’une des trois lignes suivantes :

Function calculTVA(montantHT As Double, tauxTVA As  Double) As Double
    Dim montantTTC As Integer
    montantTTC = montantHT * (1 + tauxTVA)

C’est-à-dire les trois lignes qui se trouvent être positionnées AVANT le message affiché !

Nous retrouvons ainsi :

• La ligne de déclaration de la fonction : chaque argument est typé en tant que Double, c’est-à-dire une variable pouvant contenir des grands nombres décimaux, ce qui ne pose aucun problème ici. Sur cette ligne nous avons également typé la fonction suivant le même modèle, mais si le problème se trouvait à cet endroit, le calcul du montant TTC que nous venons d’analyser serait correct,
• Ensuite, nous retrouvons la déclaration de la variable montantTTC au sein de laquelle nous allons justement enregistrer le montant problématique ! Or cette variable est déclarée en tant que Integer, c’est-à-dire un nombre entier… si nous revenons un peu plus tôt, nous pouvons d’ailleurs constater que les calculs sont arrondis à l’euro le plus proche. Nous venons donc de trouver la source du Bug ! Il suffit alors de typer la variable en tant que Double, puis de retester le code en lançant à nouveau la procédure de test

Le premier message nous informe alors que le montant TTC de 72.40€ est 86.88€, ce qui correspond justement au résultat de notre calcul effectué un peu plus tôt :

Et pour finir le résultat retourné par la fonction est maintenant de 25.066€, soit ce que nous avions calculé manuellement au tout début !

Notre code est maintenant debuggé !

Maintenant que nous avons vu les grands principes du débogage en affichant les valeurs de variables, découvrons en quelques variantes.

   5.2. Debut.Print

Tout d’abord, il est possible de remplacer MsgBox par Debug.Print.

Cela n’offre certes pas la possibilité d’interrompre à la demande la macro afin de pouvoir accéder directement à la ligne correspondante du code, mais en revanche l’avantage non négligeable vient du fait que la macro ne sera pas arrêtée par des notifications incessantes.

En effet, toutes les valeurs de variables seront présentées les unes à la suite des autres dans la fenêtre d’exécution :

   5.3. Le mode débogage d’Excel

Pour aider les développeurs dans cette lourde tâche que peut vite devenir l’analyse des lignes code, VBE dispose que quelques outils spécifiques au débogage.

Nous avons déjà eu l’occasion de découvrir le mode débogage, lorsque le code VBA rencontre une erreur, ou lorsque que nous l’appelons en utilisant la combinaison de touches [Ctrl]+[Pause].

Mais bien entendu, il est possible d’en personnaliser simplement le comportement.

Pour cela, il suffit de cliquer dans la zone située à gauche du code (dans la marge grise) afin d’y insérer un point marron et que la ligne de code prenne la même couleur (ou de cliquer sur la touche [F9] pour passer la ligne dans laquelle se trouve le curseur de saisie en marron) :

Cela permet alors d’interrompre le code à l’endroit voulu afin d’entrer dans le mode de débogage.

Évidemment, ce mode d’analyse du code ne se limite pas uniquement à interrompre le code à un endroit voulu.

Il permet en effet d’afficher instantanément les valeurs affectées aux variables !

Pour cela, il suffit simplement de survoler l’une de ces variables pour faire apparaître son contenu dans un infobulle jaune :

Pour reprendre le cours de la macro, il suffit d’appuyer sur le rectangle vert ou d’appuyer sur [F5] :

La macro reprend alors son cours, jusqu’à rencontrer un autre point d’arrêt, ou à défaut, jusqu’à son terme.

Dans notre exemple, étant donné que la fonction calculTVA est appelée deux fois, la macro va alors s’arrêter exactement au même endroit, mais bien entendu, les valeurs des variables vont maintenant être modifiées :

Pour supprimer un point d’arrêt, il suffit de cliquer à nouveau sur celui-ci (ou d’appuyer sur [F9] après avoir sélectionné la ligne en question).

Pour supprimer automatiquement tous les points d’arrêts, il convient cette fois-ci d’appuyer sur les touches [Ctrl]+[Majuscule]+[F9]

Plutôt que de devoir survoler toutes les variables pour repérer celles qui contiennent des valeurs anormales, il est possible de d’utiliser la fenêtre des variables locales, qui permet d’afficher toutes les variables déclarées, avec leur type et surtout leur valeur !

Pour cela, rendez-vous dans le menu Affichage > Fenêtre Variables locales :

Il est ainsi plus facile de pouvoir analyser toutes les variables déclarées d’un simple coup d’œil :

Enfin, pour ne suivre l’évolution que d’une variable il est possible de placer un espion au sein de la feuille de code !

Pour cela, rendez-vous une fois encore dans la fenêtre affichage, afin de cliquer sur Fenêtre Espions :

Pour ajouter un nouvel espion, effectuez un clic-droit > Ajouter un espion :

Il suffit alors de saisir le nom de la variable et de valider en appuyant sur le bouton [OK].

De cette manière, lorsque le code sera interrompu, la valeur de la variable renseignée sera affichée dans la fenêtre :

Notez qu’il n’est pas utile de prendre la peine de poser des points d’arrêt, il suffit en effet de sélectionner l’option « Arrêt si la valeur change » pour que la macro s’interrompe d’elle-même !

   5.4. Le mode pas à pas détaillé

VBE propose un autre mode dédié au débogage qui est le mode pas à pas détaillé.

Celui-ci permet de parcourir la macro en marquant une interruption lors de l’exécution de CHAQUE ligne de code !

Un peu comme si nous avions placé un point d’arrêt sur toutes les lignes de la macro.

Pour lancer le mode pas à pas détaillé, rendez-vous dans le menu Débogage > Pas à pas détaillé (ou appuyez sur [F8]) :

Une fois le mode pas à pas détaillé, nous passons à la ligne suivante en appuyant sur la touche [F8] :

Pour aller analyser directement une ligne en particulier, il est possible de faire glisser la flèche jaune qui se trouve dans la marge de la feuille de code :