Vous répétez souvent les mêmes actions dans Excel : parcourir une liste, vérifier chaque cellule, copier des données ou appliquer une mise en forme ? Si vous faites ces opérations à la main, une boucle VBA peut probablement vous faire gagner un temps précieux.

Une boucle permet de demander à Excel de répéter automatiquement une ou plusieurs instructions. Elle devient particulièrement utile dès que vous travaillez sur des tableaux volumineux ou des tâches répétitives. Dans cet article, nous allons voir comment fonctionnent les principales boucles VBA, quand les utiliser et comment éviter les erreurs les plus courantes.

Pourquoi utiliser une boucle VBA dans Excel ?

Une macro classique exécute les instructions dans l’ordre. Mais que faire lorsque la même action doit être réalisée sur 10, 100 ou 10 000 lignes ? Écrire chaque instruction une par une serait long, difficile à maintenir et franchement peu élégant.

Les boucles permettent notamment de :

  • parcourir les cellules d’une plage ;
  • traiter automatiquement les lignes d’un tableau ;
  • rechercher une valeur dans plusieurs feuilles ;
  • appliquer une mise en forme selon une condition ;
  • copier, déplacer ou supprimer des données ;
  • répéter une action jusqu’à ce qu’une condition soit remplie.

Imaginez un tableau contenant 5 000 commandes. Vous souhaitez colorer en rouge les commandes dont le montant dépasse 1 000 €. Une boucle va examiner chaque ligne et appliquer la mise en forme uniquement lorsque cela est nécessaire. Excel travaille pendant que vous vous occupez du café. Tout le monde y gagne.

La boucle For…Next : la plus simple pour commencer

La boucle For...Next répète un bloc d’instructions un nombre déterminé de fois. Elle utilise généralement une variable compteur, qui commence à une valeur donnée et augmente jusqu’à une valeur finale.

Sub CompterJusqua10()    Dim i As Integer    For i = 1 To 10        Debug.Print i    Next iEnd Sub

Dans cet exemple, la variable i prend successivement les valeurs de 1 à 10. L’instruction Debug.Print affiche chaque valeur dans la fenêtre Exécution de l’éditeur VBA.

La structure générale est la suivante :

For variable = valeur_depart To valeur_fin    ' Instructions à répéterNext variable

Le mot-clé Next indique à VBA qu’il doit passer à la valeur suivante du compteur. Il est possible d’utiliser un incrément différent de 1 avec Step.

Sub CompterDeDeuxEnDeux()    Dim i As Integer    For i = 2 To 20 Step 2        Debug.Print i    Next iEnd Sub

Cette macro affiche les nombres pairs de 2 à 20. Pour parcourir les valeurs dans l’ordre décroissant, utilisez un incrément négatif :

For i = 10 To 1 Step -1    Debug.Print iNext i

Parcourir les lignes d’une feuille Excel

Dans la pratique, une boucle sert très souvent à parcourir les lignes d’un tableau. Supposons que les noms des clients se trouvent dans la colonne A et que leur chiffre d’affaires soit indiqué dans la colonne B.

Le code suivant écrit “À relancer” dans la colonne C lorsque le chiffre d’affaires est inférieur à 500 € :

Sub IdentifierClients()    Dim i As Long    Dim derniereLigne As Long    derniereLigne = Cells(Rows.Count, 1).End(xlUp).Row    For i = 2 To derniereLigne        If Cells(i, 2).Value < 500 Then            Cells(i, 3).Value = "À relancer"        Else            Cells(i, 3).Value = "Client actif"        End If    Next iEnd Sub

La ligne suivante est particulièrement utile :

derniereLigne = Cells(Rows.Count, 1).End(xlUp).Row

Elle recherche la dernière ligne utilisée dans la colonne A. La boucle commence à la ligne 2 afin d’ignorer l’en-tête du tableau.

Pour rendre votre code plus fiable, précisez toujours la feuille concernée. Sans cela, VBA utilise la feuille active, ce qui peut produire des résultats surprenants si l’utilisateur change d’onglet pendant l’exécution.

Sub IdentifierClientsAvecFeuille()    Dim ws As Worksheet    Dim i As Long    Dim derniereLigne As Long    Set ws = ThisWorkbook.Worksheets("Clients")    derniereLigne = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row    For i = 2 To derniereLigne        If ws.Cells(i, 2).Value < 500 Then            ws.Cells(i, 3).Value = "À relancer"        Else            ws.Cells(i, 3).Value = "Client actif"        End If    Next iEnd Sub

L’utilisation de ThisWorkbook fait référence au fichier contenant la macro, et non nécessairement au classeur actuellement visible à l’écran. Cette petite précaution évite bien des déconvenues.

La boucle For Each : idéale pour parcourir des objets

La boucle For Each est très pratique lorsque vous souhaitez parcourir chaque élément d’un ensemble : cellules, feuilles, classeurs, graphiques ou plages.

Pour examiner toutes les cellules d’une plage, utilisez par exemple :

Sub VerifierLesCellules()    Dim cellule As Range    For Each cellule In Range("A2:A20")        If cellule.Value = "" Then            cellule.Interior.Color = RGB(255, 230, 230)        End If    Next celluleEnd Sub

Cette macro colore en rose clair les cellules vides de la plage A2:A20. La variable cellule représente une cellule différente à chaque passage dans la boucle.

Vous pouvez également parcourir toutes les feuilles d’un classeur :

Sub ListerLesFeuilles()    Dim feuille As Worksheet    Dim ligne As Long    ligne = 1    For Each feuille In ThisWorkbook.Worksheets        Worksheets("Synthèse").Cells(ligne, 1).Value = feuille.Name        ligne = ligne + 1    Next feuilleEnd Sub

For Each est souvent plus lisible que For…Next lorsque vous n’avez pas besoin de connaître la position numérique de l’élément parcouru.

Les boucles Do While et Do Until

Les boucles Do While et Do Until sont utiles lorsque le nombre de répétitions n’est pas connu à l’avance. Elles continuent tant qu’une condition est vraie ou jusqu’à ce qu’une condition devienne vraie.

Voici un exemple avec Do While. La macro parcourt la colonne A tant qu’elle rencontre des cellules non vides :

Sub ParcourirUneListe()    Dim ligne As Long    ligne = 2    Do While Cells(ligne, 1).Value <> ""        Cells(ligne, 2).Value = "Ligne traitée"        ligne = ligne + 1    LoopEnd Sub

La condition est évaluée avant chaque passage. Si la cellule A2 est vide dès le départ, aucune instruction ne sera exécutée.

Avec Do Until, la boucle continue jusqu’à ce que la condition soit vraie :

Sub RechercherLaPremiereCelluleVide()    Dim ligne As Long    ligne = 2    Do Until Cells(ligne, 1).Value = ""        ligne = ligne + 1    Loop    MsgBox "La première cellule vide se trouve à la ligne " & ligneEnd Sub

Attention : dans une boucle conditionnelle, vous devez toujours vous assurer que la condition finira par être remplie. Sinon, la macro risque de tourner indéfiniment. C’est la fameuse boucle infinie, généralement peu appréciée par Excel… et encore moins par la personne qui attend que le fichier réponde.

Sortir d’une boucle avec Exit For ou Exit Do

Il n’est pas toujours nécessaire de parcourir l’ensemble des éléments. Si vous avez trouvé la valeur recherchée, vous pouvez quitter immédiatement la boucle avec Exit For.

Sub RechercherUneValeur()    Dim cellule As Range    Dim valeurRecherchee As String    valeurRecherchee = "Durand"    For Each cellule In Range("A2:A1000")        If cellule.Value = valeurRecherchee Then            cellule.Interior.Color = RGB(255, 255, 0)            Exit For        End If    Next celluleEnd Sub

La macro s’arrête dès qu’elle trouve “Durand”. C’est plus rapide que de continuer à examiner les cellules restantes, surtout dans une grande plage.

De la même manière, Exit Do permet de sortir d’une boucle Do While ou Do Until.

Utiliser des boucles imbriquées

Une boucle peut contenir une autre boucle. On parle alors de boucles imbriquées. Cette technique est utile pour parcourir un tableau ligne par ligne et colonne par colonne.

Sub ParcourirUnTableau()    Dim ligne As Long    Dim colonne As Long    For ligne = 2 To 10        For colonne = 1 To 5            If Cells(ligne, colonne).Value = "" Then                Cells(ligne, colonne).Interior.Color = RGB(255, 230, 230)            End If        Next colonne    Next ligneEnd Sub

Dans cet exemple, la première boucle parcourt les lignes 2 à 10, tandis que la seconde examine les colonnes 1 à 5 de chaque ligne.

Les boucles imbriquées sont puissantes, mais elles peuvent ralentir l’exécution si elles traitent beaucoup de données. Pour un tableau de plusieurs dizaines de milliers de cellules, il faudra parfois optimiser le code.

Accélérer une macro qui utilise des boucles

Lorsqu’une boucle modifie un grand nombre de cellules, Excel peut devenir lent, notamment parce qu’il actualise l’écran et recalcule les formules après chaque modification.

Vous pouvez désactiver temporairement ces fonctions :

Sub MacroRapide()    On Error GoTo GestionErreur    Application.ScreenUpdating = False    Application.Calculation = xlCalculationManual    ' Votre boucle iciSortiePropre:    Application.ScreenUpdating = True    Application.Calculation = xlCalculationAutomatic    Exit SubGestionErreur:    MsgBox "Une erreur est survenue : " & Err.Description    Resume SortiePropreEnd Sub

ScreenUpdating = False empêche Excel de rafraîchir l’affichage à chaque étape. Le gain peut être très important. En revanche, pensez toujours à réactiver les options à la fin, y compris si une erreur survient. Le bloc de gestion d’erreur présenté ci-dessus joue précisément ce rôle.

Autre conseil : évitez de sélectionner les cellules dans vos boucles. Le code suivant fonctionne, mais il est inutilement lent :

For i = 2 To 1000    Cells(i, 1).Select    Selection.Font.Bold = TrueNext i

Préférez une référence directe :

For i = 2 To 1000    Cells(i, 1).Font.Bold = TrueNext i

Dans Excel VBA, moins de mouvements à l’écran signifie généralement une macro plus rapide et plus fiable.

Les erreurs fréquentes à éviter

Quelques précautions vous aideront à écrire des boucles plus robustes :

  • déclarez vos variables avec Dim ;
  • utilisez Option Explicit en haut de vos modules ;
  • qualifiez les objets avec un classeur et une feuille ;
  • vérifiez la dernière ligne avant de lancer la boucle ;
  • évitez de modifier la collection que vous êtes en train de parcourir ;
  • prévoyez une condition de sortie dans les boucles Do ;
  • réactivez toujours les paramètres Excel modifiés pendant la macro.

Pour activer la déclaration obligatoire des variables, ajoutez cette ligne tout en haut du module :

Option Explicit

Elle vous obligera à déclarer chaque variable et vous évitera de perdre du temps à chercher une faute de frappe dans un nom utilisé une seule fois.

Une macro complète pour traiter des commandes

Voici un exemple réunissant plusieurs bonnes pratiques. La macro parcourt une feuille nommée “Commandes”, vérifie le statut de chaque commande et colore les lignes livrées.

Option ExplicitSub MettreEnFormeLesCommandes()    Dim ws As Worksheet    Dim derniereLigne As Long    Dim i As Long    On Error GoTo GestionErreur    Set ws = ThisWorkbook.Worksheets("Commandes")    derniereLigne = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row    Application.ScreenUpdating = False    For i = 2 To derniereLigne        If ws.Cells(i, 4).Value = "Livrée" Then            ws.Range(ws.Cells(i, 1), ws.Cells(i, 4)).Interior.Color = RGB(220, 245, 220)        ElseIf ws.Cells(i, 4).Value = "En retard" Then            ws.Range(ws.Cells(i, 1), ws.Cells(i, 4)).Interior.Color = RGB(255, 220, 220)        End If    Next iSortiePropre:    Application.ScreenUpdating = True    Exit SubGestionErreur:    MsgBox "Impossible de traiter les commandes : " & Err.Description    Resume SortiePropreEnd Sub

Cette macro est simple, mais elle constitue une excellente base pour automatiser un suivi commercial, un reporting ou une mise à jour quotidienne. Il suffit ensuite d’adapter les colonnes, les statuts et les couleurs à votre fichier.

Quel type de boucle choisir ?

Pour faire le bon choix, posez-vous simplement la question suivante : est-ce que je connais à l’avance le nombre de passages ?

  • For…Next : lorsque vous connaissez le début et la fin du compteur.
  • For Each : lorsque vous parcourez les éléments d’une plage, d’une feuille ou d’une collection.
  • Do While : lorsque la boucle doit continuer tant qu’une condition est vraie.
  • Do Until : lorsque la boucle doit continuer jusqu’à ce qu’une condition devienne vraie.

Commencez par une boucle courte, testez-la sur une copie de votre fichier, puis ajoutez progressivement les conditions et les actions nécessaires. Une boucle bien pensée peut transformer une tâche répétitive de plusieurs minutes en une opération exécutée en quelques secondes.