Excel VBA : les Boucles For… Next

Les boucles For...Next constituent un pilier de la programmation en VBA, offrant la capacité de répéter un bloc de code un nombre défini de fois.

Cette structure de contrôle est particulièrement adaptée pour parcourir des collections d'objets ou des tableaux, mais elle est également incontournable pour exécuter une suite d'opérations de manière itérative, en fonction d'une condition prédéfinie.

Typiquement, le nombre d'itérations dans une boucle For est déterminé par la propriété Count d'une collection, ce qui permet une grande flexibilité et précision dans la gestion des données et des processus automatisés.

REMARQUE : Pour les débutants en VBA, la boucle For Next à décrémentation est souvent une fonctionnalité peu connue, mais incroyablement utile. En particulier, elle brille lorsque vous avez besoin de supprimer des lignes spécifiques d'un tableau.

La syntaxe de base d'une boucle For...Next en VBA est structurée de la manière suivante :

For Compteur = start To end
    ' Bloc de code à répéter
Next Compteur

Dans cette structure :

• Compteur est la variable de contrôle de la boucle, qui est typiquement un nombre entier. Cette variable est aussi appelée l'incrément de boucle, et le nom i est fréquemment utilisé pour sa simplicité et sa concision.
• start correspond à la valeur initiale assignée à Compteur.
• end définit la valeur finale que Compteur atteindra. La boucle s'exécutera jusqu'à ce que Compteur soit égal à end.

Cette syntaxe précise permet de contrôler le nombre exact de fois qu’un bloc de code sera exécuté, ce qui est essentiel pour la manipulation de données et la réalisation de tâches répétitives de manière efficace.

Exemple Simple : Boucle For VBA

Sub DemoForNext()
    Dim i As Integer
    For i = 1 To 5
        Debug.Print "Itération numéro : " & i
    Next i
End Sub

Ce script simple illustre l'utilisation de la boucle For...Next en VBA. La variable i est initialisée à 1 et incrémente à chaque itération jusqu'à atteindre la valeur de 5. À chaque passage dans la boucle, le numéro de l'itération est affiché dans la fenêtre Immediate de l'éditeur VBA, grâce à l'instruction Debug.Print.

L'exécution pas à pas de ce code via la touche F8 permet de suivre en détail chaque étape de la procédure. Cela aide non seulement à comprendre le flux de la boucle For, mais également à visualiser comment les valeurs de la variable i évoluent de 1 à 5. Chaque pression sur F8 exécute une itération du bloc de code, rendant visibles les résultats intermédiaires dans la fenêtre Immediate, où les numéros de 1 à 5 seront affichés séquentiellement, démontrant ainsi le comptage par la boucle.

Utilisation de Step dans For…Next (Boucle à incrémentation)

Le mot-clé Step joue un rôle crucial dans la personnalisation du comportement d'incrément de la variable de boucle dans les structures For...Next en VBA.

Par défaut, l'incrément est fixé à 1, ce qui signifie que la variable de boucle augmente de 1 à chaque itération. Cependant, en utilisant Step, vous pouvez modifier cette valeur d'incrément pour adapter la boucle à des besoins spécifiques.

Syntaxe avec Step
(Boucle à incrémentation)

La syntaxe complète pour une boucle For...Next avec un incrément spécifié est la suivante :

For Compteur = start To end Step increment
    ' Bloc de code à répéter
Next Compteur

Dans cette structure :

• Compteur est la variable de contrôle de la boucle.
• start définit la valeur initiale de Compteur.
• end est la valeur finale que Compteur doit atteindre ou dépasser pour que la boucle se termine.
• increment spécifie de combien Compteur sera augmenté (ou diminué, si l'incrément est négatif) après chaque itération. Cela permet de contrôler le pas de l'itération, offrant ainsi une grande flexibilité dans le traitement des données.

Cette capacité à ajuster l'incrément permet des itérations plus complexes, telles que sauter certains éléments dans une séquence, ou itérer à travers des valeurs en ordre décroissant, en ajustant simplement la valeur de l'incrément.

Exemple avec Step
(Boucle à incrémentation)

Sub DemoForNextStep()
    Dim i As Integer
    For i = 0 To 60 Step 5
        Debug.Print "Compteur de 5 en 5 : " & i
    Next i
End Sub

Ce script montre comment utiliser Step pour incrémenter la variable i de la boucle par 5 à chaque itération, comptant ainsi de 0 à 60. Cela démontre l'efficacité de Step pour ajuster l'incrément à des intervalles spécifiques, facilitant le parcours d'une gamme de valeurs à pas réguliers.

Exemple de boucle à décrémentation

L’utilisation de Step – n,  initiera une boucle à décrémentation ou boucle à rebours

Sub DemoForNextStepCountdown()
    Dim i As Integer
    For i = 24 To 0 Step -1
        Debug.Print "Compte à rebours : " & i
    Next i
End Sub

Ce code implémente une boucle à décrémentation, où i commence à 24 et diminue jusqu'à 0. L'utilisation de Step -1 permet de réduire la variable de boucle d'une unité à chaque itération, idéal pour créer un effet de compte à rebours.

Pourquoi utiliser la boucle à décrémentation ?

La boucle For...Next avec Step -1 est extrêmement utile pour parcourir des éléments dans l'ordre inverse. Cela est particulièrement pertinent lorsqu'on manipule des collections ou des tableaux où l'ordre des opérations peut influencer le résultat final.

Scénario d'Utilisation

Supposons que vous ayez un tableau de 50 lignes, et que vous souhaitiez supprimer les lignes impaires :

Sub RowsRemove()
    Dim ws As Worksheet, i As Integer
    Set ws = Worksheets(1)
    ' Remplir les cellules de A1 à A50 avec le numéro de ligne
    For i = 1 To 50
        ws.Cells(i, 1) = i
    Next i
    ' Supprimer les lignes impaires
    For i = 50 To 1 Step -1
        If Not i Mod 2 = 0 Then
            ws.Rows(i).Delete
        End If
    Next i
    Set ws = Nothing
End Sub

Lorsque nous souhaitons supprimer des lignes d'un tableau, en effectuant dans une boucle un test sur une cellule de chaque ligne, nous utiliserons une boucle à décrémentation.

Cela garantit que les numéros de ligne ne seront pas altérés lors de l'itération à travers le tableau. En effet, lorsque l’on supprime une ligne d’un tableau, toutes les lignes se situant sous la ligne supprimée changeront d’indice.

Optimiser les temps d’exécution d’une boucle For…Next

Le développeur utilisera très souvent la boucle For Next pour rechercher une valeur dans un tableau de valeur. Une fois la valeur trouvée, il sera possible de sortir de la boucle pour optimiser le temps d’exécution d’une boucle.

Exemple de sortie de boucle :

Sub ExitLoop()
' Déclaration des variables
    Dim MyVar As Variant
    Dim i As Integer
' Assignation d'une chaîne de caractères à la variable MyVar
    MyVar = "Pomme,Poire,Cerise,Abricot,Orange,Pêche"
' Division de la chaîne MyVar en un tableau en utilisant la virgule comme séparateur
    MyVar = Split(MyVar, ",")
' Boucle For itérant à travers les éléments du tableau MyVar
    For i = LBound(MyVar) To UBound(MyVar)
' Vérification si l'élément en cours est "Cerise"
        If MyVar(i) = "Cerise" Then
' Affichage d'un message indiquant l'indice de l'élément "Cerise" dans le tableau
            MsgBox "Cerise est à l'indice " & i & " du tableau"
' Sortie de la boucle For
            Exit For
        End If    
    Next i ' Passage à l'élément suivant du tableau
End Sub

Explication :

Dans cet exemple, nous déclarons une variable MyVar de type Variant. Nous lui attribuons une chaîne de caractères contenant des mots séparés par des virgules (que nous appellerons le "séparateur de texte"). La fonction Split divise cette chaîne en un tableau mémoire unidimensionnel, plaçant chaque mot dans une cellule du tableau.

Nous démarrons ensuite une boucle For qui parcourt tous les index de notre nouveau tableau mémoire MyVar. Le plus petit index d'un tableau mémoire unidimensionnel est LBound(Tableau) (Limite Inférieure : Borne Inférieure), et dans un tableau mémoire unidimensionnel de type Variant, le plus petit index est 0. Le plus grand index est UBound(Tableau) (Limite Supérieure : Borne Supérieure).

Pendant la boucle, si l'élément en scrutation du tableau correspond à "Cerise", nous affichons dans une boîte de dialogue le numéro de l'index où se trouve le mot "Cerise". Après avoir trouvé ce que nous recherchions, nous sortons de la boucle pour optimiser son temps d'exécution en utilisant la commande Exit For. Nous retrouverons ensuite End if la fin de condition puis la commande Next i pour incrémenter notre boucle.

End Sub pour clôturer notre procédure.

Pour information dans une base de données faisant appel à un tableau bidimensionnel que l’on pourrait appeler MyArray, avec pour ordonnées des enregistrements et pour origine des champs de données le plus grand indice des ordonnées sera égale à Ubound(MyArray, 1) et le plus grand indice de champ sera égale à Ubound(MyArray, 2)

Les boucles imbriquées

Les boucles imbriquées ou Nested Loop sont définies avec une boucle que l’on appelle externe à l’interieur de laquelle peut être initiée une ou plusieurs boucles internes. Bien que le nombre de boucles imbriquées ne soit pas limité, en pratique, il est rare d'avoir besoin de plus de quelques niveaux d'imbrication de boucles.

Dans l’exemple suivant, nous avons deux boucles imbriquées pour réaliser un planning hebdomadaire dont l’unité est 1 heure :

Sub NestedLoopExemple()
    ' Déclaration des variables
    Dim ws As Worksheet 'Définir une variable Objet ws comme étant une feuille de travail
    Dim RowCount As Integer, ColumnCount As Integer 'Définir deux variables de type entier pour définir le nombre de lignes et de comonne du tableau
    Dim TimeStart As Integer, TimeEnd As Integer 'Définir deux variables de type entier pour définir la plage horaire du planning
    Dim StartRow As Integer, StartCol As Integer 'Définir deux variables de type entier pour définir l’origine du tableau
    Dim r As Integer, c As Integer 'Définir deux variables de type entier pour les incréments de la boucle externe et la boucle interne
    
    ' Attribuer la feuille 1 à la variable Objet Worksheet ws
    Set ws = Worksheets(1)
    
‘Définir l’origine du tableau son nombre de ligne et de colonne pour une plage horaire paramétrable
    StartRow = 4 ' Ligne d'origine du tableau
    StartCol = 2 ' Colonne d'origine du tableau
    TimeStart = 8 ' Heure de départ du planning
    TimeEnd = 18 ' Heure de fin du Planning
    RowCount = 8 ' Nombre de jours de la semaine + 1
    ColumnCount = TimeEnd - TimeStart + 2 ' Calcul du nombre de colonnes du tableau
    
    ' Nettoyer le contenu de la feuille de travail tout en conservant le format
    ws.Cells.ClearContents
    ' Initier une boucle externe sur le nombre de lignes
    For r = 1 To RowCount
        ' Initier une boucle interne sur le nombre de colonnes
        For c = 1 To ColumnCount
            ' Si r = 1 et c différent de 1
            If r = 1 And Not c = 1 Then
                ' Insérer les horaires dans la première ligne du tableau
                ws.Cells(StartRow + r, StartCol + c) = Format(TimeStart + c - 2, "00") & ":00"
            ElseIf r > 1 And c = 1 Then
                ' Insérer les noms des jours de la semaine dans la première colonne du tableau
                ws.Cells(StartRow + r, StartCol + c) = WeekdayName(r - 1, False, vbMonday)
            End If
        Next c ' Fin de la boucle interne
    Next r ' Fin de la boucle externe
    Set ws = Nothing
End Sub

Pour aller plus loin

Les boucles For...Next ; For...Next Step et For...Next Step -1 sont des outils de programmation puissants en VBA qui offrent une flexibilité considérable pour itérer à travers des ensembles de données dans différents ordres.

En maîtrisant ces structures, les développeurs peuvent écrire des codes plus efficaces et adaptés à une gamme plus large de situations.

Rejoignez les professionnels qui ont choisi Morpheus Formation pour automatiser leurs fichiers et gagner en efficacité. Une formation basée sur :

• Des cas concrets et des exercices sur mesure
• Un accompagnement personnalisé par un formateur VBA expert
• Une pédagogie orientée résultats
• Une certification TOSA reconnue
• Le tout, finançable via le CPF

Déjà plus de 850 apprenants accompagnés, avec une note moyenne de 9,7/10 et plus de 14 000 heures de formation réalisées.