Lors du développement et du test d’un programme, les erreurs sont généralement courantes. Tous les développeurs commettent des erreurs. La différence entre le développeur débutant et l’expert en développement est que l’expert reconnaît, diagnostique et corrige ses erreurs beaucoup plus rapidement qu’un débutant.

Dans ce chapitre, nous allons vous aider à bien démarrer en vous enseignant les outils et les fonctionnalités de débogage inclus dans Visual Basic Editor (VBE) et les tactiques que vous pouvez utiliser pour dépanner votre code en cas de problème.

Ces erreurs peuvent être divisées en trois groupes : les erreurs de syntaxe, les erreurs d’exécution et les erreurs logiques. Les erreurs de syntaxe peuvent être évitées à l’aide de l’éditeur. Les erreurs d’exécution, c’est-à-dire les erreurs pendant l’exécution du programme qui entraînent un blocage du programme, peuvent être traitées avec l’instruction On Error. Les erreurs logiques sont les plus difficiles à trouver.

1 Erreur de syntaxe
Les erreurs de syntaxe sont des erreurs qui se produisent lorsque votre code ne respecte pas les exigences de syntaxe de VBA (Code incomplète ou mal écrit). Elles sont relativement bénignes car elles se produisent généralement au moment du développement du code et, tant que la fonction de vérification automatique de la syntaxe est activée, certaines d’entre elles peuvent être automatiquement détectées par le VBE lors de la saisie de votre code. Mais la fonctionnalité de vérification automatique de la syntaxe ne détecte pas toutes les erreurs de syntaxe. Plus précisément, il ne peut détecter que les erreurs de syntaxe qui se produisent dans une seule instruction ou ligne de code. Par exemple, la ligne Debug.Prinf   est une erreur de syntaxe que la fonction de vérification automatique de la syntaxe peut détecter car elle n’a pas besoin d’autres instructions pour donner un sens à cette ligne. L’écriture correcte est Debug.Print. Le code suivant contient une erreur de syntaxe qui ne peut pas être trouvée par la vérification automatique de la syntaxe.

Sub ErreurSyntaxe ()
    Dim n As Long
    For n = 10 To 20 Step 2
    MsgBox n
End Sub

Figure : Une erreur de syntaxe

Commentaires 

■ Le problème avec ce code est qu’il manque une instruction Next.

■ Ce code est classé comme une erreur de syntaxe car il ne respecte pas les exigences de syntaxe de VBA. Chaque déclaration For doit être suivie à un moment donné dans la même procédure par une déclaration Next. 

■ La vérification automatique de la syntaxe ne peut jamais vous avertir de cette erreur car elle vérifie les instructions individuelles uniquement au fur et à mesure de leur saisie. Par conséquent, il ne peut pas rechercher d’erreurs de syntaxe nécessitant d’autres instructions afin de garantir une formation correcte des procédures.

Visual Basic contient une fonctionnalité de vérification de la syntaxe qui :

■ contrôle chaque instruction au fur et à mesure à la recherche d’erreurs de syntaxe, par exemple un mot clé mal orthographié ou un séparateur absent, et vous avertit en cas d’erreur ;

■ traduit le code en un formulaire interne si la syntaxe est correcte, ce qui accélère la transition vers le moment de l’exécution.

Cette fonctionnalité est activée au premier démarrage, mais vous pouvez la désactiver si vous souhaitez pour écrire du code sans être averti des erreurs au fur et à mesure de leur détection.

Pour activer la vérification de la syntaxe :

1. Dans le menu Outils, choisissez options.
2. Sélectionnez l’onglet Éditeur.
3. Activez la case à cocher Vérification automatique de la syntaxe comme le montre la figure suivante.

■ Sélectionnez OK.

2 Erreur d’exécution

Les erreurs d’exécution se produisent lorsque le programme tente d’effectuer une opération non conforme. Voici des exemples d’erreurs d’exécution :
■ Division par zéro
■ Essayer d’ouvrir un classeur inexistant
■ Référence à une feuille de calcul inexistante
Les erreurs d’exécution sont plus difficiles à détecter que les erreurs de syntaxe pour deux raisons. Tout d’abord, le code est sans défaut du point de vue du compilateur, on ne peut donc pas les détecter automatiquement. Ensuite, vous allez trouver difficile d’envisager toutes les conditions possibles que votre programme pourrait rencontrer.

a- Programme avec des erreurs d’exécution

La procédure suivante provoque une erreur d’exécution. Le contenu de la cellule A1 est divisé par le contenu de la cellule A2. Le résultat de la division doit être sorti dans la cellule A3.

Sub ErreurExecution()
    Dim aa As Integer, bb As Integer, cc As Integer
    ThisWorkbook.Worksheets("Feuil1").Activate
    aa = Range("A1").Value
    bb = Range("A2").Value
    cc = aa / bb
    Range("A3").Value = cc
End Sub

Commentaires

■ Si les nombres 100 et 25 sont dans les deux cellules, le résultat est conforme à celui attendu à la figure suivante.

 
■ Toutefois, si les nombres 100 et 0 sont dans les cellules, le programme se termine par une erreur d’exécution. Une boîte de dialogue apparaît avec un message d’erreur.

■ Vous pouvez maintenant appuyer sur le bouton Fin ou sur le bouton Débogage. Si vous cliquez sur le bouton de débogage, la ligne de code défectueuse est surlignée en jaune et l’exécution du code est suspendue. Dans ce cas, il s’agit de la ligne cc = aa / bb comme l’indique la figure suivant, car la division doit être effectuée dans cette ligne. Cela vous donnera un autre indice pour le dépannage.

Si vous utilisez le bouton Fin, l’exécution du code est annulée. Cependant, il n’y a aucune référence à la ligne de code défectueuse.

Les messages d’erreur affichés ne sont souvent pas très significatifs. Un clic sur le bouton d’aide affiche des informations supplémentaires, mais celles-ci ne correspondent pas toujours au problème qui conduit à ce message d’erreur. Mais ne vous inquiétez pas, avec le temps, vous développerez de plus en plus le sentiment de la cause possible. Par exemple, les forums continuent d’aider, où une solution au problème est généralement trouvée rapidement.

b- Interception en cas d’erreur

Une erreur peut être gérée même pendant l’exécution du code, tant que sa présence a été remarquée et, par conséquent, une configuration a été faite dans le code qui permet son traitement.

L’instruction On Error est appliquée exactement dans ces cas, car elle positionne la procédure et démarre une procédure de gestion des erreurs.

Il existe trois syntaxes pour l’instruction On Error : On Error Resume Next, On Error GoTo et On Error GoTo 0. Ces trois types sont décrites dans le tableau suivant :

c-  On Error Resume Next

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. Puisqu’il ignore complètement toute erreur qui peut se produire, vous ne pourrez peut-être pas identifier les erreurs qui doivent être corrigées.

La procédure précédente est maintenant améliorée pour intercepter l’erreur d’exécution comme suit:

Sub ExempleGestionErreur1()
    Dim aa As Integer, bb As Integer, cc As Integer
    ThisWorkbook.Worksheets("Feuil1").Activate
    On Error GoTo monErreur
    aa = Range("A1").Value
    bb = Range("A2").Value
    cc = aa / bb
    Range("A3").Value = cc
    monErreur:
    MsgBox Err.Description
    Resume Next
End Sub

Commentaires

La sortie ressemble à ceci dans le cas de 100 et 0:

■ L’instruction On Error monErreur signifie qu’en cas d’erreur d’exécution dans cette procédure, un saut est effectué sur la ligne avec le marqueur de ligne Error.

■ Le marqueur de ligne est défini avec: monErreur :, c’est-à-dire généralement avec le nom du marqueur de ligne et un deux-points.

■ En cas d’erreur d’exécution, l’objet d’erreur Err reçoit des données. Vous pouvez par exemple, indiquez la valeur de la propriété Description et recevez la description de l’erreur.

Le tableau suivant répertorie les propriétés et les méthodes les plus importantes de l’objet Err.
devrait.

■ Contrairement à l’exemple précédent, le programme peut continuer, il ne s’interrompt pas.

■ Exit Sub (similaire à Exit For ou Exit Do pour une boucle) peut être utilisé pour quitter une procédure prématurément. Si cette instruction était omise dans la présente procédure, les instructions après le marqueur de ligne Error seraient exécutées dans tous les cas, même si les nombres dans les cellules sont corrects. Bien sûr que cela ne devrait pas être le cas.

■ L’instruction Resume Next signifie que l’exécution du programme se poursuit avec l’instruction qui suit l’instruction dans laquelle l’erreur d’exécution s’est produite.

d- On Error GoTo

Dans cette syntaxe, l’argument de ligne est obligatoire et détermine la ligne où le gestionnaire doit être démarré. Nous pouvons définir cet argument comme n’importe quel numéro d’étiquette ou de ligne. Il fonctionne lorsqu’une erreur d’exécution se produit et que le contrôle passe à la ligne, démarrant la gestion des erreurs. Afin d’éviter une erreur lors de la compilation, nous devons faire attention au fait qu’il est nécessaire de spécifier la ligne dans la même procédure où se trouve l’instruction On Error.

Dans l’exemple suivant, la variable age a été créée pour recevoir une valeur numérique. Il vous sera demandé de saisir une valeur dans une zone de saisie qui affectera la valeur saisie dans la variable. On sait qu’une variable de type Byte ne peut pas stocker de valeurs de type texte (String) et que ce type de variable n’accepte que des valeurs numériques comprises entre 0 et 255.

Sub ExempleGestionErreur2()
    Dim age As Byte
    age = InputBox("Entrer votre âge")
    MsgBox "L'âge est" & age
End Sub

Commentaires

■ Si une valeur numérique est entrée dans la zone de texte, elle sera affichée dans une boîte de message.

■ Si un texte est tapé, une erreur d’exécution se produira dans la macro, car la variable est de type numérique. Tapons par exemple le texte « Chancelin ».

Lorsque vous appuyez sur le bouton OK, l’erreur suivante apparaît:

Nous pouvons alors utiliser la gestion des erreurs. Dans cette situation, si un type d’erreur se produit, les commandes contenues dans l’étiquette de traitement seront exécutées.

Avec l’instruction On Error GoTo, en cas d’erreur, le processus passera à l’instruction de traitement, qui à son tour, contient la commande permettant d’afficher un message.

Sub ExempleGestionErreur3()
    On Error GoTo monErreur
    Dim age As Byte
    age = InputBox("Entrer votre âge")
    MsgBox "L’âge est " & age
    Exit Sub
    monErreur:
    MsgBox "Valeur invalide"
End Sub

Commentaires

■ S’il n’y a pas d’erreur lors de l’exécution, toutes les commandes seront exécutées, y compris le contenu du traitement, puisque les lignes de programmation sont exécutées en cascade.

■ Ainsi, pour que le message Valeur invalide ne s’affiche pas même lorsqu’une valeur numérique est entrée, il est nécessaire d’insérer l’instruction Exit Sub dans la ligne avant la routine de traitement.

e-  On Error GoTo 0

On Error GoTo 0 désactive la gestion des erreurs dans la procédure en cours. Il ne spécifie pas la ligne 0 comme début du code de gestion des erreurs, même si la procédure contient une ligne numérotée 0. Sans une instruction On Error GoTo 0, un gestionnaire d’erreurs est automatiquement désactivé lorsqu’une procédure est quittée.

Sub ExempleGestionErreur4()
    On Error GoTo 0
    Dim age As Byte
    age = InputBox("Entrer votre âge")
    MsgBox " L’âge est " & age
    Exit Sub
    monErreur:
    MsgBox "Valeur invalide"
End Sub

3 Erreurs logiques

Des erreurs logiques se produisent lorsqu’une application est compilée sans erreurs de syntaxe et exécutée sans erreurs d’exécution, mais ne fournit pas le résultat prévu.
Les erreurs logiques peuvent potentiellement passer inaperçues pendant une longue période ; cela est dû au fait que votre application, de par son apparence extérieure, semblera bien fonctionner. Les erreurs logiques ne sont pas découvertes par le compilateur au moment du développement ou de la compilation et ne vous gênent pas en affichant des erreurs d’exécution concises à vos utilisateurs finaux. Bien que la plupart des erreurs logiques soient détectées et ne causent pas de problèmes sérieux, certaines erreurs logiques peuvent être extrêmement difficiles à détecter et risquent de causer de graves dommages en fonction de l’utilisation de votre application.
Trouver la cause des erreurs logiques est souvent difficile et ne peut être effectué que par des tests et une analyse intensive des processus et des résultats. Un environnement de test est donc à votre disposition dans l’environnement de développement, que vous pouvez utiliser pour rechercher et éliminer rapidement les erreurs.

4 Débogage

Lors de l’apprentissage d’un langage de programmation, vous faites le plus d’erreurs. Il est donc nécessaire de savoir comment trouver et corriger les erreurs et quels outils sont disponibles à cet effet. Recherche et élimination des erreurs au cours de la programmation, il est inévitable que des erreurs de programmation se produisent. Cependant, il est toujours important de savoir jusqu’où et, surtout, si le programme s’est exécuté correctement avant l’erreur. Pour cette raison, un environnement de test est disponible dans l’environnement de développement que vous pouvez utiliser pour rechercher et corriger rapidement les erreurs.

a- La fenêtre de code

En cas d’erreur, vous pouvez entrer et modifier vos macros VBA dans la fenêtre de code. C’est la fenêtre où se trouve votre code. Si cette fenêtre n’est pas encore affichée, sélectionnez la commande Code dans le menu Affichage ou appuyez sur le raccourcis clavier F7.

La fenêtre de code contient les objets suivants:

■ Un champ déroulant Objet : les noms des objets sélectionnés sont affichés ici. Cliquez sur la flèche à droite de la zone de liste pour afficher une liste de tous les objets associés au formulaire.

■ Zone de liste déroulante Procédure : répertorie tous les événements que Visual Basic détecte pour le formulaire ou le contrôle qui apparaît dans la zone Objet. Lorsqu’un événement est sélectionné, la procédure événementielle associée à ce nom d’événement s’affiche dans la fenêtre de code. Par ailleurs, toutes les procédures sont affichées par ordre alphabétique dans le champ déroulant. Cela facilite grandement la recherche de modules spécifiques.

Si vous regardez le bord supérieur droit de la barre de défilement vertical de la fenêtre de code, vous pouvez voir le séparateur de fenêtre. Le séparateur de fenêtre est situé directement au-dessus du symbole de la flèche vers le haut, comme le montre la figure suivante.

Figure  : La fenêtre de code

Cela vous permet de diviser la fenêtre de code en deux zones horizontales qui peuvent être défilées séparément. De cette façon, vous pouvez afficher différentes parties telles que le début et la fin d’une macro en même temps.

Les informations affichées dans les champs Objet et Procédure concernent le code de la fenêtre actuellement active. Une fenêtre se ferme par un double clic sur le séparateur de fenêtre.

b- La Fenêtre Exécution

La fenêtre Exécution est utilisée pour essayer diverses instructions, fonctions et opérateurs présents dans le langage Visual Basic avant de les utiliser dans vos propres procédures VBA. C’est un excellent outil qui vous permet de taper des instructions VBA et de tester leurs résultats immédiatement sans avoir à écrire une procédure.  

Par exemple dans la fenêtre Exécution, tapez l’instruction suivante :

Worksheets.Add

Lorsque vous appuyez sur la touche Entrée, VBA ajoute une nouvelle feuille dans le classeur actuel. L’onglet Feuil2 en bas du classeur doit maintenant être mis en surbrillance.

La fenêtre Exécution vous permet également de poser des questions. Supposons que vous souhaitiez savoir quelles cellules sont actuellement sélectionnées, la valeur de la cellule active, le nom de la feuille active ou le numéro de la fenêtre actuelle. Lorsque vous travaillez dans la fenêtre Exécution, vous pouvez facilement obtenir des réponses à ces questions et à d’autres. Le point d’interrogation (?) Indique à Excel d’afficher le résultat de l’instruction dans la fenêtre Exécution. Au lieu du point d’interrogation, vous pouvez utiliser le mot-clé Print, comme indiqué à l’étape suivante.

La Fenêtre Exécution est un excellent moyen de tester une macro. Vous avez la possibilité de documenter le contenu des variables et des positions dans le code. Par exemple, vous pouvez afficher certains contenus de variables dans la Fenêtre Exécution afin de corriger les valeurs susceptibles de provoquer des erreurs. Prenons l’exemple suivant :

Sub FenetreExecution()
Dim maVariable As Integer
For maVariable = 1 To 12
Debug.Print "Passe en boucle: " & maVariable
Next maVariable
End Sub

Commentaires

■ Dans cette macro, la boucle est exécutée exactement douze fois.

■ Chaque fois que la boucle est exécutée, la commande Debug.Print est utilisée pour écrire une entrée dans la Fenêtre Exécution qui enregistre l’exécution en cours dans la boucle.

Placez le point d’insertion sur la première ligne de la macro et appuyez sur la touche F5 pour démarrer la macro. Vérifiez maintenant le résultat dans la Fenêtre Exécution.

Dans une nouvelle ligne de la fenêtre Exécution, entrez l’instruction suivante et

La fenêtre Exécution peut également être utilisée pour un calcul rapide.

Dans une nouvelle ligne de la fenêtre Exécution, entrez l’instruction suivante et appuyez sur Entrée :

? 24/6

Excel affiche le résultat de la division sur la ligne suivante.

c- Parcourez le code en mode Pas à Pas

Une autre façon de résoudre les problèmes d’Excel consiste à parcourir la macro ligne par ligne. Pour ce faire, placez le curseur sur la première ligne de la macro et appuyez sur la touche F8. Vous pouvez également sélectionner la commande de menu Débogage / Pas à pas détaillé. La macro s’arrête après chaque commande. Vous pouvez ensuite vérifier si l’action souhaitée a été effectuée en quittant l’environnement de développement pendant une courte période et en vérifiant les résultats dans votre classeur Excel.

Nous allons à nouveau nous servir de l’exemple de la section précédente. Pour la première exécution en mode Pas à pas détaillé, les nombres 100 et 25 doivent figurer dans les cellules.

Si vous placez maintenant le curseur sur une variable (par exemple sur la variable aa), vous verrez la valeur actuelle (ici la valeur 100 pour aa). Vous pouvez également voir que la variable cc a toujours la valeur 0, car l’instruction actuellement sélectionnée n’a pas encore été exécutée. Après l’étape suivante, la variable cc a la valeur 4.

Cet exemple simple montre que vous pouvez utiliser la méthode en une seule étape pour suivre le déroulement d’un programme morceau par morceau et ainsi localiser plus facilement la source d’une erreur logique.

Une autre variante consiste à définir le point d’insertion dans la macro ci-dessus dans la ligne jusqu’à laquelle la macro doit s’exécuter. Par exemple, placez le point d’insertion sur la ligne que vous souhaitez parcourir le code et appuyez sur la combinaison de touches Ctrl + F8.

Le code est maintenant exécuté jusqu’à la ligne actuellement marquée et s’arrête exactement à cette position. Vous pouvez maintenant vérifier si la macro a fonctionné correctement. Si tout est correct, vous pouvez appuyer sur le bouton F5 assurez-vous que la macro s’exécute jusqu’à la fin. Si quelque chose ne va pas avec la macro, annulez-la en utilisant la commande de menu Exécution / Réinitialiser.

d- Points d’arrêt

Si le mode Pas à Pas prend trop de temps pour un programme donné, vous pouvez également travailler avec des points d’arrêt. Le programme exécute ensuite toutes les instructions jusqu’à un tel point d’arrêt. Définissez un point d’arrêt à proximité de l’endroit où vous suspectez la source d’une erreur.

Pour définir un point d’arrêt, cliquez sur la marge gauche (en gris) où vous souhaitez placer le point d’arrêt. Un point rouge apparaît. Un point d’arrêt est défini dans la ligne sur laquelle se trouve le curseur. Dans l’exemple, la ligne dans laquelle cc = aa / bb est calculé convient pour cela.

Figure  : Définir le point d’arrêt

Le programme est maintenant lancé à l’aide de la touche F5. Il se brise avant d’exécuter la ligne avec le point d’arrêt. À partir de ce moment, vous pouvez réexécuter le programme en mode Pas à Pas et vérifier les valeurs des variables comme décrit ci-dessus.

Plusieurs points d’arrêt peuvent également être définis. Un point d’arrêt peut à nouveau être supprimé en plaçant le curseur sur la ligne appropriée et en appuyant à nouveau sur la touche [F9].

e- Ajouter un espion

De nombreuses erreurs dans les procédures sont causées par des variables qui prennent des valeurs inattendues. Si une procédure utilise une variable dont la valeur change à divers endroits, vous souhaiterez peut-être arrêter la procédure et vérifier la valeur actuelle de cette variable. Visual Basic propose une fenêtre Espion spéciale qui vous permet de garder un œil sur les variables ou les expressions pendant l’exécution de votre procédure.

Pour ajouter une fenêtre Espion, sélectionnez la commande Fenêtre Espion dans le menu Affichage (ou le raccourcis clavier Maj + F9). Ainsi, vous avez maintenant la possibilité de vérifier quand une variable particulière change.

Dans l’exemple suivant, une boucle est exécutée exactement douze fois. La variable maVariable est modifié à chaque passage de boucle. Selon la logique, la macro suivante doit alors être arrêtée après le premier passage de boucle.

Sub FenetreExecution()
    Dim maVariable As Integer
    For maVariable = 1 To 12
    Debug.Print "Passer en boucle: " & maVariable
    Next maVariable
End Sub

Pour définir maintenant la surveillance de la variable maVariable, suivez les étapes suivantes :

1. Dans le menu Déblogage de l’environnement de développement, sélectionnez Ajouter un espion.
2. Entrez la variable (maVariable) que vous souhaitez surveiller dans le champ Expression.
3. Activez l’option Arrêt si la valeur change.
4. Confirmez vos paramètres avec OK.

La macro s’arrête la première fois que la variable maVariable est modifiée.

Figure suivante: Le contenu actuel de la variable est affiché dans la Fenêtre espion.

Vous pouvez ajouter un Espion avant d’exécuter une procédure ou après que l’exécution de votre procédure a été suspendue.

1. La fenêtre Espion répertorie la procédure QuelleDate suivante :

Sub QuelleDate()
Dim LaDate As Date
Dim nouvelleDate As Date
Dim x As Integer
LaDate = Date
For x = 1 To 365
nouvelleDate = Date + x
Next
End Sub

La procédure QuelleDate utilise la boucle For … Next pour calculer la date qui correspond à x jours dans le futur. Si vous exécutez cette procédure, vous n’obtiendrez aucun résultat si vous n’insérez pas l’instruction suivante dans le code de la procédure :

MsgBox "Dans " & x & " jours, ce sera " & nouvelleDate

Dans cet exemple cependant, vous ne vous souciez pas d’afficher les dates individuelles, jour après jour. Que faire si tout ce que vous voulez faire est d’arrêter le programme lorsque la valeur de la variable x atteint 150? En d’autres termes, quelle date sera dans 150 jours à partir de maintenant? Pour obtenir la réponse, vous pouvez insérer la déclaration suivante dans votre procédure:

If x = 211 Then MsgBox « Dans  » & x &  » jours, ce sera  » & nouvelleDate

L’introduction de nouvelles instructions dans votre procédure juste pour obtenir une réponse sur la valeur d’une certaine variable lorsqu’une condition spécifique se produit ne sera pas toujours viable. Au lieu d’ajouter MsgBox ou d’autres instructions de débogage à votre code de procédure que vous devrez supprimer ultérieurement, vous pouvez utiliser la fenêtre Espion et éviter une maintenance supplémentaire du code. Si vous ajoutez des expressions de surveillance à la procédure, Visual Basic arrêtera la boucle For … Next lorsque la condition spécifiée est remplie, et vous pourrez vérifier les valeurs des variables souhaitées.

Pour définir maintenant la surveillance de la variable maVariable, suivez les étapes suivantes :

1. Dans le menu Débogage de l’environnement de développement, sélectionnez Ajouter un espion.
2. Dans la zone de texte Expression, entrez l’expression suivante: x = 150. Dans la section Contexte, choisissez QuelleDate dans la zone de liste déroulante Procédure. Dans la section Type d’espion, sélectionnez le bouton d’option Arrêt si la valeur est vrai.
3. Cliquez sur OK pour fermer la boîte de dialogue Ajouter un espion. Visual Basic ouvre la fenêtre Espion et y place votre expression x = 150. Ajoutons maintenant une autre expression à la fenêtre espion qui nous permettra de suivre la date actuelle.
4. Dans la fenêtre Code, placez le point d’insertion n’importe où dans le nom de la variable LaDate. Choisissez Débogage / Ajoutez un espion et cliquez sur OK avec la configurer par défaut Expression espionne. Notez que LaDate apparaît maintenant dans la colonne Expression de la fenêtre espion.
5. Dans la fenêtre Code, placez le point d’insertion n’importe où dans le nom de la variable nouvelleDate. Choisissez Déboguer | Ajoutez Watch et cliquez sur OK pour configurer le type de montre par défaut avec Watch Expression.

Notez que nouvelleDate apparaît maintenant dans la colonne Expression de la fenêtre espion. Après avoir effectué les étapes précédentes, la procédure QuelleDate contient les trois espion.

9. Placez le point d’insertion n’importe où à l’intérieur du code de la procédure QuelleDate et appuyez sur F5.

Notez que la valeur de la variable x dans la fenêtre espion est la même que la valeur que vous avez spécifiée dans la boîte de dialogue Ajouter un espion. En outre, la fenêtre Espion affiche la valeur des deux variables: LaDate et nouvelleDate. La procédure est en mode pause. Vous pouvez appuyer sur F5 pour continuer ou poser une autre question, telle que « Quelle sera la date dans 250 jours? » L’étape suivante montre comment procéder.

10. Choisissez Déboguer | Modifiez la montre et entrez l’expression suivante: x = 277.
11. Cliquez sur OK pour fermer la boîte de dialogue Modifier la montre.

Notez que la fenêtre Espion affiche désormais une nouvelle valeur pour l’expression. x est maintenant False.

12. Appuyez sur F5 pour poursuivre l’exécution de la procédure.

La procédure s’arrête à nouveau lorsque la valeur de x est égale à 277. La valeur de cur¬Date est la même; cependant, la variable newDate contient désormais une nouvelle valeur, une date dans 277 jours. Vous pouvez modifier à nouveau la valeur de l’expression ou terminer l’exécution de la procédure.

13. Appuyez sur F5 pour terminer l’exécution de la procédure.

Lorsque votre procédure est en cours d’exécution et qu’une expression de surveillance a une valeur, la fenêtre de surveillance affiche la valeur de l’expression de surveillance. Si vous ouvrez la fenêtre Espion une fois la procédure terminée, vous verrez <hors contexte> au lieu des valeurs de variable. En d’autres termes, lorsque l’expression de surveillance est hors contexte, elle n’a pas de valeur.

f- La fenêtre locale

La fenêtre locale n’est pas affichée dans l’environnement de développement par défaut. Cependant, vous pouvez afficher cette fenêtre à l’aide du menu Affichage. La fenêtre locale affiche toutes les variables déclarées dans la procédure en cours et leurs valeurs. Vous avez donc la possibilité de vérifier clairement les valeurs des variables.

Pour tester cette fonction, entrez la macro suivante, qui transfère toutes les cellules utilisées de la feuille Feuil5 à la feuille Feuil6:

Sub DonneesTransferees()
Dim FL1 As Worksheet
Dim FL2 As Worksheet
Dim maLigne As Integer
Set FL1 = Feuil5
Set FL2 = Feuil6
For maLigne = 1 To FL1.UsedRange.Rows.Count
FL2.Cells(maLigne, 1) = FL1.Cells(maLigne, 1)
Next maLigne
End Sub

Commentaires

■ Dans la première étape, déclarez deux variables d’objet du type de feuille de calcul. Utilisez ensuite l’instruction Set pour indiquer comment ils sont appelés. ■ Dans une boucle For, vous transférez ensuite toutes les cellules de la colonne A de Feuil5 vers la feuille de calcul cible Feuil6.

■ Vous utilisez la propriété Cells, qui nécessite deux arguments. Dans le premier argument, vous affichez la ligne actuellement active, dans le deuxième argument la colonne. Puisque la colonne reste constante (colonne A), vous pouvez remplir cet argument avec la valeur 1 et le laisser constant. L’argument de ligne est incrémenté à chaque passage de boucle.

Procédez maintenant comme suit pour pouvoir utiliser la fenêtre locale:

1. Placez le pointeur de la souris sur la ligne dans la boucle.
2. Appuyez sur le bouton | F9 | pour y définir un point d’arrêt.
3. Démarrez la macro en appuyant sur la touche | F5 | à presser.
4. La macro s’exécute jusqu’au point d’arrêt. Le contenu des variables est maintenant affiché dans la fenêtre locale. Parcourez à nouveau la boucle en appuyant sur la touche | F5 | appuyez à nouveau.

Les colonnes suivantes sont affichées dans la fenêtre locale.

■ Expression : répertorie les noms des variables. La première variable de la liste est une variable de module spéciale et peut être développée pour afficher toutes les variables de niveau module pour le module actuel. Les variables globales et les variables d’autres projets ne sont pas disponibles via la fenêtre locale.

■ Valeur : Si vous cliquez directement sur une entrée dans la colonne Valeur, le curseur prend la forme d’un curseur. Vous pouvez modifier cette valeur puis appuyer sur la touche | Enter l. Si la valeur n’est pas autorisée, le champ d’édition reste actif et la valeur est marquée. Une boîte de message s’affiche également décrivant l’erreur. En appuyant sur | Les modifications sont annulées. Appliqué à notre exemple, vous pouvez changer la valeur de la variable i en 7. Excel continuerait alors après la septième passe de boucle.

■ Type : cette colonne affiche le type de données de la variable. Mais vous ne pouvez pas changer ce type.

■ LISTE D’APPELS: en haut à droite de la fenêtre locale, vous trouverez un bouton avec quelques points dessus. Après avoir cliqué dessus, une liste des appels de procédure actuellement actifs en mode attente s’affiche. Lorsque le code est exécuté dans une procédure, il est ajouté à une liste d’appels de procédure actifs. Chaque fois qu’une autre procédure est appelée par une procédure ceci est ajouté à la liste. Les procédures appelées sont supprimées de la liste lorsque l’exécution est passée à la procédure appelante.

En passant, vous pouvez également supprimer le point d’arrêt pendant l’exécution. Après avoir à nouveau arrêté la macro, appuyez sur la touche | F9 |.

g- La barre d’outils de débogage

La barre d’outils débogage vous fournit des icônes qui simplifient le test rapide du code source.  Pour afficher cette barre d’outils, cliquez sur Barre d’outils dans l’onglet Affichage et ensuite, sélectionnez Débogage.

Les symboles suivants sont proposés dans cette barre d’outils de droite à gauche :

■ Mode Création : Active et désactive le mode brouillon.

■ Exécuter/Continuer : Exécute la procédure en cours si le curseur est dans une procédure ; exécute le formulaire UserForm si un formulaire UserForm est actif.

■ Arrêt : termine l’exécution d’un programme et passe en mode maintien. Vous pouvez également appuyer sur la touche (Echap) pour arrêter la macro.

■ Réinitialiser : efface la liste d’appels et les variables au niveau du module et met fin au projet.

■ Basculer le point d’arrêt : définit ou supprime un point d’arrêt dans la ligne actuelle. Vous pouvez aussi appuyer sur la touche (F9) pour définir ou supprimer un point d’arrêt.

■ Pas à pas détaillé : Exécute exactement une instruction dans le code. Vous pouvez également utiliser la touche (F8) pour parcourir un code ligne par ligne.

■ Pas à Pas principal : Exécute une procédure ou une instruction dans le code dans la fenêtre de code.

■ Pas à Pas sortant : Exécute les lignes restantes d’une procédure au point d’exécution actuel.

■ Fenêtre Locale : affiche la fenêtre locale.

■ Fenêtre Exécution : Affiche la fenêtre Exécution. Vous pouvez également appuyer sur la combinaison de touches (Ctrl) + (G) pour afficher la fenêtre Exécution.

■ Fenêtre Espions : affiche la fenêtre de surveillance.

■ Espion Express : affiche la boîte de dialogue Espion express avec la valeur actuelle de l’expression sélectionnée.

■ Pile des appels : affiche la boîte de dialogue Pile des appels, qui montre les appels de procédure actuellement actifs (procédures qui ont démarré mais qui ne se sont pas terminées).5 Messages d’erreurs

Ce qui suit est un tableau avec le nombre d’erreurs interceptables. Comme nous pouvons le voir, cette liste saute certains chiffres. Parmi les nombres ignorés, ceux de 1 à 1000 seront utilisés à l’avenir par Visual Basic.

6 Protéger les projets VBA

Si vous avez investi beaucoup de temps dans la programmation de vos projets VBA et que vous souhaitez maintenant les protéger contre les accès non autorisés, vous avez plusieurs options:

■ Attribution d’un mot de passe

■ Création d’un complément

Si vous souhaitez attribuer un mot de passe pour protéger votre code, procédez comme suit:

1. Basculez vers l’environnement de développement.
2. Cliquez avec le bouton droit sur dans l’Explorateur de projets

Classeur dont vous souhaitez protéger le code et sélectionnez la commande Propriétés de VBAProject dans le menu contextuel.

3. Passez à l’onglet Protection.
4. Cochez la case Verrouiller le projet pour l’affichage.

5.Attribuez un mot de passe et confirmez-le. 6. Lorsque vous avez terminé, cliquez sur le bouton OK.

6.Enregistrez, fermez et rouvrez le fichier Excel. Essayez d’afficher le code.

La boîte de dialogue suivante apparaîtra :

Si vous souhaitez protéger par mot de passe la macro contre l’exécution, ajoutez les lignes de code suivantes :

Sub protectionProjet
Dim motpasse As Variant
motpasse = Application.InputBox ("Entrer un mot de passe", "Mot de passe")
Select Case motpasse
    Case Is = False
        'ne rien faire
    Case Is = "facile"
        Range ("A1"). Value = "Ceci est un code secret "
    Case Else
        MsgBox" Mot de passe incorrect "
End Select
End Sub

Commentaires

■ La macro utilise la méthode InputBox de l’objet Application. Si les utilisateurs cliquent sur Annuler, cette méthode renvoie False et rien ne se passe (InputBox disparaît). 

■ Ce n’est que lorsque l’utilisateur connaît le mot de passe (encore «facile») que le code secret sera exécuté. Si le mot de passe entré est incorrect, une MsgBox s’affiche.

■ Notez que l’utilisateur ne peut pas examiner le mot de passe dans Visual Basic Editor car le projet est protégé contre l’affichage.

La deuxième façon de protéger votre code consiste à créer un complément. Le code est compilé et ne peut pas être modifié par la suite.