VBA Debug.Print dans Excel — pourquoi votre sortie part dans une fenêtre que vous ne voyez pas

TL;DR — Debug.Print expr écrit une ligne dans l'Immediate Window et laisse la macro continuer. Aucun popup, aucune pause — l'exact opposé de MsgBox. C'est ce qui en fait la bonne façon de regarder une boucle faire défiler ses valeurs. Le hic : l'Immediate Window est fermée par défaut, donc la plainte numéro un — Debug.Print ne fait rien — n'est presque toujours qu'une sortie que vous ne pouvez pas voir. Appuyez sur Ctrl+G pour l'ouvrir. Quand le journal doit survivre à la session, cessez d'imprimer dans la fenêtre et écrivez dans un fichier à la place.

Sub DebugPrintBasics()
    Dim i As Long
    For i = 1 To 3
        Debug.Print "row " & i, Cells(i, 1).Value   ' defile vers l'Immediate Window
    Next i
    Debug.Print "done"                              ' aucun popup, la macro ne s'arrete jamais
End Sub
' Rien ne s'affiche ? L'Immediate Window est fermee. Appuyez sur Ctrl+G.

Ce que vous allez apprendre

Le modèle mental — Debug.Print est un journal silencieux et non bloquant, pas une boîte de dialogue
Les trois observateurs, de puissance croissante, et la question à laquelle chacun répond
Pourquoi Debug.Print semble ne rien faire (et le correctif Ctrl+G)
Pourquoi l'Immediate Window jette discrètement vos toutes premières sorties
Pourquoi imprimer une expression peut déclencher de vrais effets de bord
Debug.Print contre MsgBox, et quand le journal doit devenir un vrai fichier

Le modèle mental : un journal silencieux, pas une boîte de dialogue

Debug.Print est une ligne de journal. Il ajoute du texte à l'Immediate Window et rend immédiatement la main à votre code — la macro ne s'arrête pas, rien ne surgit, et personne n'a à cliquer quoi que ce soit. Cette seule propriété est toute sa raison d'être. Quand vous diagnostiquez une boucle, vous voulez voir 5 000 valeurs défiler dans un panneau que l'on peut faire défiler, pas cliquer « OK » 5 000 fois.

La bonne question à se poser n'est donc jamais « comment afficher cette valeur ? » — MsgBox affiche une valeur. C'est « comment enregistrer une valeur sans interrompre l'exécution ? ». Tout ce qui suit découle de ce seul cadrage : parce que Debug.Print ne bloque jamais, sa sortie doit vivre quelque part où vous allez la consulter, et cet endroit est une fenêtre qu'Excel garde cachée jusqu'à ce que vous la demandiez.

Les trois observateurs, de puissance croissante

Debug.Print est le premier barreau d'une échelle. Quand une macro se comporte mal, ce ne sont pas les indices qui vous manquent — c'est que vous ne regardez pas. VBA vous tend trois façons de regarder, chacune répondant à une question différente et chacune vous mentant à sa manière :

Observateur	La question à laquelle il répond	Son mensonge caractéristique
`Debug.Print`	Quelles étaient les valeurs pendant l'exécution ?	Imprime dans une fenêtre fermée par défaut
Immediate Window	Qu'est-ce qui est vrai à l'instant, à cette pause ?	Une requête `?` exécute réellement le code
Breakpoint + F8	Sur quelle ligne cela dérape-t-il ?	Ils disparaissent à la fermeture du classeur

Saisissez le passif et vous devinez quelle ligne a cassé ; saisissez le lourd et vous parcourez 10 000 itérations à la main. Le savoir-faire, c'est de savoir si vous devez voir les valeurs ou trouver la ligne. Debug.Print répond à la question la plus lâche — il vous montre ce qui s'est passé après coup — ce qui en fait le plus rapide à saisir et le plus facile à traverser du regard sans rien voir.

Piège 1 : il imprime dans une fenêtre fermée par défaut

Le rapport « Debug.Print ne fonctionne pas » numéro un n'est pas un bug dans votre code. Les valeurs s'impriment exactement comme écrit — dans un panneau que vous n'avez jamais ouvert.

Sub WhereDidItGo()
    Debug.Print "I am running fine"   ' cette ligne fonctionne
End Sub                                ' vous ne voyez juste pas ou elle a atterri

L'Immediate Window s'ouvre avec Ctrl+G (ou View > Immediate Window) dans l'éditeur VBA. Jusque-là, chaque Debug.Print réussit en silence et vous concluez que rien ne s'est passé. Avant d'ajouter le moindre MsgBox pour « vérifier si le code tourne », ouvrez l'Immediate Window — neuf fois sur dix, votre preuve était déjà là.

Piège 2 : la fenêtre jette discrètement vos toutes premières sorties

L'Immediate Window n'est pas un journal infini. Elle ne garde que les ~200 dernières lignes ; les lignes plus anciennes défilent par le haut et disparaissent. Dans un petit test, vous ne le remarquez jamais. Dans une boucle de 10 000 lignes, les lignes que vous voulez le plus — les premières, là où le motif casse d'habitude — sont les premières écartées.

Sub LosesTheStart()
    Dim i As Long
    For i = 1 To 10000
        Debug.Print i, Cells(i, 1).Value   ' a la fin, les lignes 1..9800 ont disparu
    Next i
End Sub

Quand vous avez besoin de tout l'historique — chaque ligne, dans l'ordre, conservée après l'exécution — Debug.Print est le mauvais outil. Ouvrez un fichier texte et utilisez Print # à la place : il n'a aucune limite de tampon et laisse un fichier que vous pouvez rouvrir (VBA Print et Write). Debug.Print sert à un coup d'œil ; un fichier sert à garder une trace.

Piège 3 : imprimer une expression peut déclencher de vrais effets de bord

« Journaliser est passif » n'est vrai que lorsque ce que vous journalisez est passif. Debug.Print évalue son argument, donc si vous imprimez le résultat d'une fonction, cette fonction s'exécute — avec toutes ses conséquences.

Debug.Print DeleteOldRows()   ' ceci SUPPRIME des lignes, puis imprime le compte
Debug.Print Cells(1, 1).Value ' ceci est vraiment passif - lit juste une valeur

Imprimer DeleteOldRows() pour « voir combien il en supprimerait » les supprime réellement. Gardez les arguments de Debug.Print à de simples variables et lectures de propriétés, et ne faites jamais transiter par lui une fonction à effets de bord juste pour inspecter la valeur de retour. S'il le faut, capturez d'abord le résultat dans une variable, puis imprimez la variable.

Debug.Print contre MsgBox

Ils semblent interchangeables — les deux vous montrent une valeur — mais ce sont des opposés, et choisir le mauvais est une catégorie de douleur à part entière :

	`Debug.Print`	`MsgBox`
Bloque la macro ?	Non, elle continue	Oui, attend un clic
Où cela va	Immediate Window (dev seulement)	À l'écran, pour tout le monde
Dans une boucle	Fait défiler des milliers de lignes	Une boîte modale par itération
Historique	Défilable (~200 dernières lignes)	Perdu dès que vous cliquez OK

La règle s'écrit d'elle-même : si vous devez voir quelque chose en développant, Debug.Print. Si une personne en production doit voir quelque chose, c'est un vrai message — MsgBox pour une vraie invite, ou une mise à jour d'état (VBA MsgBox). La seule chose à ne jamais faire, c'est déboguer une boucle avec MsgBox ; c'est ainsi qu'un diagnostic de cinq secondes se transforme en quatre cents clics sur OK.

Astuce pour une sortie lisible : séparez les valeurs par ; pour les concaténer serré, ou par , pour les aligner sur des tabulations — Debug.Print i; x; y contre Debug.Print i, x, y.

L'avis : Debug.Print est un journal, pas un système de journalisation

Debug.Print gagne sa place comme la façon la plus rapide de surveiller des valeurs pendant le développement, et c'est presque toujours la bonne réponse plutôt que MsgBox pour tout ce qui se répète. Mais c'est une ligne de journal, pas un système de journalisation. Dès l'instant où la sortie doit survivre à la session, porter un horodatage, ou provenir d'une macro qui tourne sur la machine de quelqu'un d'autre sans éditeur VBA ouvert, vous l'avez dépassé.

Deux habitudes le gardent honnête. D'abord, retirez Debug.Print du code livré ou verrouillez-le derrière une constante comme Const DEBUG_MODE As Boolean = False — laissé dans une boucle chaude, il formate encore des chaînes et écrit dans le tampon à chaque appel, ce qui est un coût réel et mesurable. Ensuite, quand l'exigence est une trace durable plutôt qu'un coup d'œil, passez à Print # et un fichier texte. Le travail de Debug.Print s'arrête à l'instant où vous fermez l'éditeur VBA ; ne lui demandez pas d'être votre piste d'audit.

Quand tout le travail est de trouver le bug — décrivez-le plutôt

La moitié du temps, la vraie tâche n'est pas « imprime cette valeur » mais « trouve la seule ligne sur 8 000 où le total cesse de correspondre, et dis-moi ce qu'elle a de différent ». Le temps d'avoir parsemé Debug.Print dans une macro de 200 lignes, relancé, fait défiler une Immediate Window tronquée et reconstruit le motif à l'œil, l'instrumentation a coûté plus cher que le correctif. ExcelMaster vous laisse énoncer ce but en langage courant — « trouve chaque ligne où la colonne E n'égale pas C plus D, et montre-moi ces lignes » — et il écrit du Python qui lit les données, sauvegarde d'abord votre fichier, applique le contrôle, et vous rend les lignes exactes qui échouent. Vous décrivez la question ; il fait le travail de regarder.

Foire aux questions

Où va la sortie de Debug.Print en VBA ?

Vers l'Immediate Window dans l'éditeur VBA. Ouvrez-la avec Ctrl+G ou View > Immediate Window. La sortie n'est visible que là — elle n'apparaît jamais sur la feuille ni dans une boîte de dialogue — et c'est pourquoi une Immediate Window fermée est la raison habituelle pour laquelle Debug.Print semble ne rien faire.

Pourquoi Debug.Print n'affiche-t-il rien ?

Presque toujours parce que l'Immediate Window est fermée (appuyez sur Ctrl+G), ou parce que votre sortie a défilé au-delà du tampon d'environ 200 lignes, ou parce que la macro a levé une erreur avant d'atteindre la ligne. Vérifiez que la fenêtre est ouverte et ajoutez un marqueur Debug.Print "reached here" pour contrôler que le chemin de code s'exécute vraiment.

Quelle est la différence entre Debug.Print et MsgBox ?

Debug.Print écrit en silence dans l'Immediate Window et laisse la macro continuer ; MsgBox arrête la macro avec une boîte modale que vous devez fermer. Utilisez Debug.Print pour les boucles et l'historique des valeurs pendant le développement, et MsgBox seulement quand une personne a réellement besoin de voir ou de répondre à quelque chose.

Comment imprimer plusieurs valeurs sur une ligne en VBA ?

Séparez-les par un point-virgule ou une virgule : Debug.Print i; x; y concatène les valeurs serré, tandis que Debug.Print i, x, y les aligne sur des tabulations (colonnes). Utilisez ; pour des lignes compactes et , pour un tableau lisible dans l'Immediate Window.

Faut-il laisser Debug.Print dans le code de production ?

Non. Retirez-le, ou verrouillez-le derrière une constante comme Const DEBUG_MODE As Boolean = False. Même d'apparence inoffensive, il évalue tout de même son argument et écrit dans le tampon plafonné de l'Immediate Window à chaque appel, ce qui ralentit une boucle chaude. Pour une sortie qui doit persister, journalisez dans un fichier avec Print # à la place.

Testé dans

Testé dans : Excel 365 (Windows 11), VBA 7.1 — vérifié le 05/09/2026.

Guides associés : VBA Immediate Window · VBA Breakpoint · VBA MsgBox · VBA Print et Write · VBA Boucle For