Le langage VBA pour l'instruction de boucle suivante est utilisé pour exécuter un bloc d'instructions un nombre fixe de fois, le plus souvent cette boucle est utilisée lors du traitement de tableaux. La boucle for next est la plus simple dans sa portée, ici les valeurs initiales et finales sont définies, et vous pouvez également définir le pas du compteur.
Regardons la syntaxe générale :
Pour le compteur = début À la fin
Les opérateurs
Compteur suivant
Comptoir- ici, nous spécifions le nom de la variable qui stockera les informations sur le nombre d'itérations (le nombre de boucles exécutées).
Début– la valeur initiale du compteur, est une expression numérique
Finir– la valeur finale du compteur, une expression numérique qui spécifie le nombre de passages.
Étape– un paramètre facultatif qui permet de définir le pas d'exécution. Si ce paramètre n'est pas présent, alors l'incrément du compteur à chaque passe est égal à un. L'utilisation d'un pas est pertinente si vous avez besoin de résoudre l'équation par énumération, vous pouvez donc fixer la valeur initiale à 1, la valeur finale à 3 et le pas à 0,2.
À la toute fin de la boucle, vous ne pouvez pas spécifier le nom de la variable (compteur), mais cela est vrai si une boucle for imbriquée est utilisée, cela rendra le code plus lisible.
Par exemple, créez un formulaire avec deux étiquettes de texte et un bouton, écrivez dans l'éditeur de code :
| Private Sub CommandButton1_Click() Dim i, j, a, b For i = 1 To 10 Step 2 a = a & i & " " Next i For j = 1 To 10 Step 3 b = b & j & " " Next j Label1 .Caption = a Label2.Caption = b End Sub Private Sub UserForm_Initialize() Label1.Caption = "" Label1.FontSize = 14 Label1.ForeColor = vbBlue Label2.Caption = "" Label2.FontSize = 14 Label2.ForeColor = vbRed CommandButton1. Légende = "Valeurs" End Sub |
Dans cet exemple, nous avons deux paramètres de boucle, chacun avec les mêmes valeurs de début et de fin, mais le premier a l'étape 2 et le second a l'étape 3.
Dans le paramètre Step, vous pouvez également spécifier une valeur négative, auquel cas le compteur s'incrémentera dans l'ordre inverse, par exemple :
| Private Sub CommandButton1_Click() Dim i, j, SummA, SummB For i = 1 To 10 SummA = SummA + i Next For j = 10 To 1 Step -1 SummB = SummB + j Next Label1.Caption = "Commande directe: "&SummA Label2.Caption= "Ordre inverse: "& SummB End Sub |
Ici, nous calculons la somme des nombres de 1 à 10 dans l'ordre direct et inverse.
Assez souvent, lors de l'utilisation de l'opérateur de boucle for next dans le langage VBA, une situation peut survenir lorsque, dans une condition donnée, il est nécessaire d'arrêter d'itérer sur les données, dans ce cas, l'expression est utilisée Quitter pour, par exemple:
Cet exemple utilise un VBA imbriqué pour la boucle suivante. Dans le premier cas, la sommation des nombres de 1 à 100 se produit, tandis que la sommation est répétée 100 fois. Dans le second cas, nous avons écrit une condition en utilisant l'instruction conditionnelle if - si le montant est supérieur à 10 000, quittez la boucle.
D'accord, essayons maintenant d'écrire un exemple plus pratique - la solution par force brute d'une équation quadratique :
| Private Sub CommandButton1_Click() Const a = -2, b = 6, c = 20 Dim x, result, res For x = -10 To 10 Step 0.5 result = a * (x * x) + b * x + c If result = 0 Then res = res & " " & x End If Next x Label1.Caption = " x exactement : " & res End Sub |
Dans cet exemple, nous avons déclaré trois constantes a, b et c, avec les valeurs -2, 6 et 20, ce sont les paramètres de l'équation quadratique (a*x*x + b*x + c = 0). La boucle modifie la variable x dans la plage de -10 à 10 par incréments de 0,5. A chaque itération, la condition est vérifiée pour l'égalité à zéro, si la condition est remplie, la valeur de la variable x est écrite dans la variable res. En conséquence, l'équation aura deux solutions : -2 et 5.
Et donc, dans cet article, nous avons examiné la boucle for next du langage VBA, qui sert à traiter les mêmes actions un certain nombre de fois, dans le prochain article, nous examinerons, qui sert à traiter les collections, et là nous allons considérez également les collections elles-mêmes.
Un cycle est une structure algorithmique,à l'aide de laquelle la répétition multiple d'un bloc d'instructions est mise en œuvre.
Instruction de boucle avec compteur (For … Next)
L'instruction For … Next vous permet de parcourir un ensemble d'instructions (instructions) un nombre de fois spécifié. Syntaxe des instructions :
Pour compteur = start_value Pour end_value
[instructions]
[instructions]
Suivant[ comptoir]
Paramètre comptoir est une variable numérique qui change automatiquement sa valeur par la valeur étape après chaque itération du cycle. Le cycle est exécuté jusqu'à comptoir£ end_value avec une valeur positive du paramètre étape ou jusqu'à comptoir³ end_value avec une valeur négative du paramètre étape. Ainsi, la boucle ne sera jamais exécutée si, avec une valeur de pas positive valeur_début plus que end_value. Si le paramètre Step étape est omis, alors par défaut l'incrément de la variable compteur est mis à 1.
L'instruction Exit For termine l'exécution de la boucle "plus tôt" et transfère le contrôle à l'instruction qui suit l'instruction de boucle. Exit For est généralement placé dans une instruction conditionnelle, par exemple :
Si condition Puis quittez pour
Note. Selon la syntaxe de l'instruction For, le paramètre comptoir- une variable arithmétique de n'importe quel type, il est toujours préférable d'utiliser le type entier de la variable, car la partie fractionnaire de la valeur d'une variable de type réel comporte généralement une erreur. Cela a à voir avec la façon dont les nombres sont stockés dans un ordinateur.
Exemple 1
Trouver la somme du premier 10 nombres naturels: S = 1 + 2 + 3 + ...+ 10 . Fragment de programme :
Dim I comme entier, S comme entier
S=0 " Remise à zéro de la valeur de la variable S
Pour i = 1 à 10 "
Début du cycle. Définir les valeurs de début et de fin
"Paramètre de boucle. Le pas de boucle par défaut est 1.
S = S + je "
L'opérateur d'affectation est exécuté à chaque fois
" exécution de la boucle, dans cet exemple 10 fois
Ensuite je " Fin de cycle. La valeur du paramètre cycle est incrémentée.
Dans ce fragment de programme, la boucle sera exécutée exactement 10 fois.
Exemple 2
Afficher dans la 1ère colonne de la feuille de calcul (à partir de la 2ème ligne) x valeurs comprises entre 0 et 3,2 avec un pas de 0,4.
Sous-onglet public()
Dim x As Single, i As Integer
Pour x = 0 À 3,2 Étape 0,4
Bien que la longueur de l'intervalle soit exactement divisible par le pas 0,4, le résultat sur la feuille de travail est :
Ce qu'il faut faire?
1. Vous pouvez augmenter légèrement la valeur finale, dans cet exemple, au lieu de 3,2, écrivez 3,201.
2. Déterminez le nombre de répétitions du chicle et écrivez une boucle sur un compteur de type entier.
Dans ce cas, le programme ressemblera à :
Sous-onglet public1()
Dim x As Single, i As Integer, n As Integer
n = CInt((3.2 - 0) / 0.4)
Pour i = 0 À n Étape 1
Cellules(i + 2, 1) = x
Pour chaque … Instruction de boucle suivante
La boucle For Each … Next permet de répéter l'exécution d'un groupe d'instructions pour chaque élément d'un tableau ou d'une famille. Cette instruction a la syntaxe suivante :
Pour chaque élément Dans groupe
[instructions]
[instructions]
Suivant[ élément]
Paramètre élément est une variable qui représente un élément d'une famille ou d'un tableau. Argument groupe est le nom du tableau ou de la famille. Les instructions ne sont exécutées qu'une seule fois pour chaque membre du groupe. L'utilisation de l'instruction est pratique car vous n'avez pas besoin de savoir à l'avance combien d'éléments se trouvent dans un tableau ou une famille. Variable élément doit être de type Variant.
Exemple 1
Trouver la moyenne arithmétique de tous les éléments de la plage sélectionnée
Fonction publique moyenne (plage en tant que plage) en tant que double
Dim Element As Variant
Dim Sum en double
Dim nombre comme entier
Quantité = 0
Pour chaque élément de la plage
Montant = Montant + Article
Quantité = Quantité + 1
Élément suivant
Moyenne = Montant / Quantité
Application. La plage sélectionnée de cellules adjacentes doit contenir des nombres. Les nombres dans les cellules vides sont considérés comme 0. Le texte dans la cellule entraînera une erreur.
Les instructions If … End If, Select … Case, For … Next, For Each … Next répertoriées ci-dessus sont un groupe d'instructions de contrôle qui modifient l'ordre dans lequel les commandes sont exécutées. Les instructions de contrôle peuvent être imbriquées dans n'importe quel ordre.
Il peut arriver que vous deviez exécuter plusieurs fois un bloc de code. En général, les instructions sont exécutées séquentiellement : la première instruction de la fonction est exécutée en premier, puis la seconde, et ainsi de suite.
Les langages de programmation fournissent diverses structures de contrôle qui fournissent des chemins d'exécution plus complexes.
L'instruction de boucle nous permet d'exécuter plusieurs fois une instruction ou un groupe d'instructions. Voici la vue générale de l'instruction de boucle dans VBA.
VBA fournit les types de boucles suivants pour gérer les exigences de bouclage. Cliquez sur les liens suivants pour vérifier leurs détails.
pour la boucle
La boucle for est une structure de contrôle de répétition qui permet à un développeur d'écrire efficacement une boucle qui doit être exécutée un certain nombre de fois.
Syntaxe
Voici la syntaxe d'une boucle for dans VBA.
Pour compteur = début Pour finir .... .... Suivant
représentation schématique
Voici le flux de contrôle en mode boucle -
- La première étape est en cours. Cette étape vous permet d'initialiser toutes les variables de contrôle de boucle et d'incrémenter la variable du compteur de pas.
- Deuxièmement, la condition est évaluée. Si vrai, le corps de la boucle est exécuté. S'il est faux, le corps de la boucle n'est pas exécuté et le flux de contrôle passe à l'instruction suivante immédiatement après la boucle For.
- Une fois la boucle for exécutée, le flux de contrôle passe à l'instruction suivante. Cette instruction vous permet de mettre à jour toutes les variables de contrôle de boucle. Il est mis à jour en fonction de la valeur du compteur de pas.
- La condition est à nouveau évaluée. Si c'est vrai, la boucle est exécutée et le processus est répété (le corps de la boucle, puis le pas est incrémenté, puis la condition à nouveau). Une fois que la condition devient fausse, la boucle For se termine.
Exemple
Ajoutez un bouton et ajoutez la fonction suivante.
Private Sub Constant_demo_Click() Dim a As Integer a = 10 For i = 0 To a Step 2 MsgBox "La valeur est i est : " & i Next End Sub
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant.
La valeur est i est : 0
La valeur est i est : 2
La valeur est i est : 4
La valeur est i est : 6
La valeur est i est : 8
La valeur est i est : 10
Exécute une séquence d'instructions plusieurs fois et raccourcit le code qui contrôle la variable de boucle.
pour... boucle
Pour chaque boucle est utilisée pour exécuter une instruction ou un groupe d'instructions sur chaque élément d'un tableau ou d'une collection.
Pour chaque boucle est similaire à la boucle For ; cependant, la boucle est exécutée pour chaque élément du tableau ou du groupe. Par conséquent, le compteur de pas n'existera pas dans ce type de boucle. Il est principalement utilisé avec des tableaux ou utilisé dans le contexte d'objets de système de fichiers pour fonctionner de manière récursive.
Syntaxe
Voici la syntaxe d'une boucle For Each dans VBA.
Pour chaque élément du groupe .... Suivant
Exemple
Private Sub Constant_demo_Click() "fruits est un tableau fruits = Array("apple", "orange", "cherries") Dim fruitnames As Variant "itérer en utilisant For each loop. Pour chaque article Dans fruits noms de fruits = noms de fruits & Article & Chr(10) Next MsgBox noms de fruits End Sub
Lorsque le code ci-dessus est exécuté, il imprime tous les noms de fruits avec un élément par ligne.
Pomme
orange
cerise
Ceci est exécuté s'il y a au moins un élément dans le groupe et est répété pour chaque élément du groupe.
boucle while..wend
Dans une boucle While While ... Wend, si la condition est vraie, toutes les instructions sont exécutées jusqu'à ce que le mot-clé Wend soit rencontré.
Si la condition est fausse, la boucle se termine et le contrôle passe à l'instruction suivante après le mot clé Wend.
Syntaxe
Voici la syntaxe de la boucle While..Wend dans VBA.
Tant que condition(s) ... Wend
représentation schématique
Exemple
Private Sub Constant_demo_Click() Dim Counter : Compteur = 10 Tandis que Compteur< 15 " Test value of Counter. Counter = Counter + 1 " Increment Counter. msgbox "The Current Value of the Counter is: " & Counter Wend " While loop exits if Counter Value becomes 15. End Sub
Lorsque le code ci-dessus est exécuté, il affichera ce qui suit dans la boîte de message.
La valeur actuelle du compteur est : 11
La valeur actuelle du compteur est : 12
La valeur actuelle du compteur est : 13
La valeur actuelle du compteur est : 14
La valeur actuelle du compteur est : 15
Cela vérifie la condition avant d'exécuter le corps de la boucle.
boucle do..while
La boucle do...while est utilisée lorsque nous voulons répéter un ensemble d'instructions alors qu'une condition est vraie. La condition peut être vérifiée au début de la boucle ou à la fin de la boucle.
Syntaxe
Voici la syntaxe de la boucle Do...While dans VBA.
Condition Do While ... ... Boucle
représentation schématique
Exemple
L'exemple suivant utilise une boucle Do ... while pour vérifier l'état au début de la boucle. Les instructions à l'intérieur de la boucle ne sont exécutées que si la condition devient True.
Private Sub Constant_demo_Click() Faire pendant que je< 5 i = i + 1 msgbox "The value of i is: " & i Loop End Sub
La valeur de i est : 1
La valeur de i est : 2
La valeur de i est : 3
La valeur de i est : 4
La valeur de i est : 5
Syntaxe alternative
Il existe également une syntaxe alternative pour la boucle Do ... while qui vérifie l'état à la fin de la boucle. La principale différence entre ces deux syntaxes est expliquée dans l'exemple suivant.
Do ... ... Loop while condition
Exemple
L'exemple suivant utilise une boucle Do ... while pour vérifier l'état à la fin de la boucle. Les instructions à l'intérieur de la boucle sont exécutées au moins une fois, même si la condition est fausse.
Private Sub Constant_demo_Click() i = 10 Do i = i + 1 MsgBox "La valeur de i est : " & i Loop While i< 3 "Condition is false.Hence loop is executed once. End Sub
Lorsque le code ci-dessus est exécuté, il imprime la sortie suivante dans une boîte de message.
La valeur de i est : 11
Les instructions do..While seront exécutées tant que la condition est vraie. (c'est-à-dire) La boucle doit se répéter jusqu'à ce que la condition soit fausse.
boucle do..intil
La boucle Do ... intil ne sera pas utilisée lorsque nous voulons répéter un ensemble d'instructions alors que la condition est fausse. La condition peut être vérifiée au début de la boucle ou à la fin de la boucle.
Syntaxe
Voici la syntaxe de la boucle Do..Until dans VBA.
Faire jusqu'à la condition ... ... Boucle
représentation schématique
Exemple
L'exemple suivant utilise Do ... Before Loop pour tester une condition au début de la boucle. Les instructions à l'intérieur de la boucle ne sont exécutées que si la condition est fausse. Il sort de la boucle lorsque la condition devient vraie.
Private Sub Constant_demo_Click() i = 10 Do Until i>15 "La condition est fausse. La boucle sera donc exécutée i = i + 1 msgbox ("La valeur de i est : " & i) Loop End Sub
Lorsque le code ci-dessus est exécuté, il imprime la sortie suivante dans une boîte de message.
La valeur de i est : 11
La valeur de i est : 12
La valeur de i est : 13
La valeur de i est : 14
La valeur de i est : 15
La valeur de i est : 16
Syntaxe alternative
Il existe également une syntaxe alternative Do ... Before Loop qui teste la condition à la fin de la boucle. La principale différence entre ces deux syntaxes est expliquée par l'exemple suivant.
Faire ... ... Boucler jusqu'à la condition
représentation schématique
Exemple
L'exemple suivant utilise Do ... Before Loop pour rechercher une condition à la fin de la boucle. Les instructions à l'intérieur de la boucle sont exécutées au moins une fois, même si la condition est vraie.
Private Sub Constant_demo_Click() i = 10 Do i = i + 1 msgbox "La valeur de i est : " & i Loop Until i more15 "La condition est vraie. Par conséquent, la boucle est exécutée une fois. End Sub
Lorsque le code ci-dessus est exécuté, il imprime la sortie suivante dans une boîte de message.
La valeur de i est : 11
Les instructions do..Until seront exécutées tant que la condition est fausse. (c'est-à-dire) La boucle doit se répéter jusqu'à ce que la condition soit vraie.
Enregistrements de contrôle de boucle
Les instructions de contrôle de boucle changent l'exécution de leur séquence normale. Lorsque l'exécution sort de la portée, toutes les autres instructions de boucle ne sont pas exécutées.
Énoncé de contrôle et description
Sortie opérateur
La sortie pour est utilisée lorsque nous voulons quitter une boucle For en fonction de certains critères. Lorsque Exit For est exécuté, le contrôle passe à l'instruction suivante immédiatement après la boucle For.
Syntaxe
Voici la syntaxe de Exit For Statement dans VBA.
représentation schématique
Exemple
L'exemple suivant utilise Exit For . Si le nombre atteint 4, la boucle For se termine et le contrôle passe à l'instruction suivante immédiatement après la boucle For.
Private Sub Constant_demo_Click() Dim a As Integer a = 10 For i = 0 To a Step 2 "i est la variable du compteur et elle est incrémentée de 2 MsgBox ("La valeur est i est : " & i) If i = 4 Then i = i * 10 "Ceci n'est exécuté que si i=4 MsgBox ("La valeur est i est : " & i) Exit For "Exited when i=4 End If Next End Sub
Lorsque le code ci-dessus est exécuté, il imprime la sortie suivante dans la boîte de message.
La valeur est i est : 0
La valeur est i est : 2
La valeur est i est : 4
La valeur est i est : 40
Termine l'instruction de boucle For et transfère l'exécution à l'instruction immédiatement après la boucle
Quitter Faire
L'instruction Exit Do est utilisée lorsque nous voulons quitter les boucles Do en fonction de certains critères. Il peut être utilisé à la fois dans les boucles Do Do ... While et Do ... Before.
Lorsqu'un Exit Do est exécuté, le contrôle passe à l'instruction suivante immédiatement après la boucle Do.
Syntaxe
Voici la syntaxe de l'instruction Exit Do dans VBA.
Exemple
L'exemple suivant utilise Exit Do . Si le compteur atteint 10, la ligne de sortie Do se termine et le contrôle passe à l'instruction suivante immédiatement après la boucle For.
Private Sub Constant_demo_Click() i = 0 Do While i<= 100 If i >10 Then Exit Do " Loop Exits if i>10 End If MsgBox ("La valeur de i est : " & i) i = i + 2 Loop End Sub
Lorsque le code ci-dessus est exécuté, il imprime la sortie suivante dans une boîte de message.
La valeur de i est : 0
La valeur de i est : 2
La valeur de i est : 4
La valeur de i est : 6
La valeur de i est : 8
La valeur de i est : 10
Termine une instruction Do While et transfère l'exécution à l'instruction immédiatement après la boucle
L'instruction de boucle est une indication à partir de laquelle il est clair quel ensemble d'instructions (cet ensemble d'instructions est appelé le corps de la boucle) doit être exécuté de manière répétée et quelle est la règle pour terminer l'exécution de la boucle.
7.2.1. Boucle paramétrique pour…Suivant
Cette boucle est contrôlée par un paramètre qui, lorsque le corps de la boucle est répété, change sa valeur avec un pas donné d'une valeur initiale donnée à une valeur finale donnée. Un tel cycle est utilisé dans le cas où l'on sait à l'avance combien de répétitions de l'exécution du corps doivent être effectuées.
Syntaxe de la boucle : Pour IPC=NHCP Pour KZPC[ étape CHIC] Corps de la boucle (une ou plusieurs instructions) Suivant[IPC]
Mots Pour(pour), Pour(avant), étape(étape), Suivant(alors) sont réservés.
Désignations appliquées :
CPI – nom du paramètre de cycle (variable de n'importe quel type numérique) ;
NZPC – la valeur initiale du paramètre de cycle (une expression de n'importe quel type numérique), que le paramètre de cycle aura à la première exécution du corps du cycle ;
KZPC est la valeur finale du paramètre de cycle (une expression de n'importe quel type numérique), avec laquelle la valeur actuelle du paramètre de cycle est comparée ;
CHIC - étape de modification du paramètre de boucle (une expression de n'importe quel type numérique) - une partie facultative de l'instruction de boucle.
Les valeurs numériques de NCPC et CDPC définissent l'intervalle dans lequel le paramètre de cycle changera. Le paramètre facultatif SHICZ spécifie l'étape de modification du compteur de boucle à chaque passage. Par défaut, s'il est absent, il est pris égal à 1. Enfin, après les instructions qui composent le corps de la boucle, suit une commande qui indique la frontière de la boucle. Dans le cas de boucles imbriquées (le corps de la boucle comprend une instruction de boucle), il est utile d'indiquer à laquelle d'entre elles appartient la commande. Suivant. Ceci est réalisé en ajoutant après le mot Suivant nom du paramètre de boucle.
Processus d'exécution des instructions Pour… Suivant pour une étape positive est illustrée à la Figure 7.4.
Prenons des exemples.
Dans le premier exemple, nous écrirons des instructions pour calculer la somme de tous les entiers impairs de 1 à 100.
Dim I en tant qu'entier, somme en tant qu'entier
Pour i = 1 à 100 Étape 2
Montant = Montant +i
L'exemple suivant illustre deux possibilités : une étape de boucle explicite et un comptage à rebours. Ce dernier est obtenu en fixant un pas négatif et par le fait que la valeur initiale du paramètre de cycle est supérieure à la valeur finale.
Dim N comme entier
Pour N = 100 à 60 Pas -10
Ce code sortira sur le formulaire actuel :
L'instruction suivante fait émettre 50 bips à l'ordinateur. Instruction Pour définit que le paramètre de boucle est une variable X, ses valeurs initiale et finale. Commande Suivant change le compteur par incréments.
Dim x En tant qu'entier
instruction Pour...Suivant peut être terminé plus tôt avec l'instruction Exit For. L'exécution de cette instruction entraîne une sortie immédiate de la boucle.
7.2.2. Instruction Do While...Loop ou Do...Loop While
Ici Tandis que(pour l'instant) et boucle(boucle) mots réservés. Cycles types Tandis que sont destinés aux situations où le nombre de répétitions du corps de la boucle (itérations) n'est pas connu à l'avance. Voici la syntaxe des deux variétés de boucle Tandis que:
Faire pendant Groupe Instruction ConditionRepetition boucle
Faire Groupe d'instructions boucle pendant ConditionRépétitions
La différence entre eux réside dans le fait que la condition de récurrence (la condition de répétition de l'exécution du corps de la boucle) est vérifiée dans le premier cas avant l'exécution du corps de la boucle (la boucle - while), et dans le second cas - après l'exécution du corps de la boucle (la boucle - avant).
Passons aux exemples.
Considérez l'action de la section suivante du programme.
Compteur = 0
Faire tant que le nombre > 10
Nombre = Nombre - 1
Compteur = Compteur + 1
MsgBox("Terminé" & Compteur & _
" itérations de boucle.")
Lorsque cette section du programme est exécutée, les éléments suivants s'affichent dans la fenêtre de la fonction MsgBox :
10 itérations de la boucle ont été réalisées.
Dans ce programme, la condition est vérifiée avant d'entrer dans la boucle. Si la variable Number est définie sur 9 au lieu de 20, les instructions à l'intérieur de la boucle ne seront pas exécutées.
Dans le programme suivant, les instructions à l'intérieur de la boucle ne sont exécutées qu'une seule fois avant que la condition ne soit pas remplie.
Compteur = 0
Nombre = Nombre - 1
Compteur = Compteur + 1
Boucle tant que le nombre > 10
MsgBox ("Fait en boucle " & Compteur & _
"itérations".)
instruction Faire... Boucle peut être complété plus tôt que prévu avec des instructions Quitter Faire.
VBA. Organisation des cycles.
Les instructions de boucle sont utilisées pour répéter l'exécution d'une action ou d'un groupe d'actions un nombre de fois spécifié. Le nombre de répétitions (itérations de boucle) peut être prédéfini ou calculé.
VBA prend en charge deux types de constructions en boucle :
- Boucles avec un nombre fixe de répétitions ( cycles avec compteur).
- Boucles avec un nombre indéfini de répétitions ( boucles conditionnelles).
Pour tous les types de cycles, le concept est utilisé corps de boucle A qui définit un bloc d'instructions entre les instructions de début et de fin de la boucle. Chaque répétition des instructions dans le corps de la boucle est appelée itération.
Cycles fixes
VBA fournit deux structures de contrôle pour organiser une boucle fixe : For ... Next (une boucle avec un compteur) et For Each ... Next (une boucle avec une énumération).
Pour… Déclaration suivante c'est une boucle typique avec un compteur qui effectue un nombre donné d'itérations. La syntaxe de l'instruction For … Next est la suivante :
Pour<счетчик> = <начЗначение>Que<конЗначение>
<блок операторов>
Suivant[<счетчик>]
Exemple d'utilisation de l'instruction For … Next.
Listing 1. Pour … Instruction suivante
‘ OBJECTIF : Écrire un programme qui reçoit deux nombres de l'utilisateur.
‘ Additionne tous les nombres dans la plage donnée par ces deux nombres, puis
‘ Affiche la somme résultante.
Sous-échantillon7()
Compteur de boucle Dim i As Integer
Dim sStart 'valeur du compteur de démarrage
Dim sEnd ' valeur finale du compteur
Dim sSum As Long 'somme résultante
sStart = InputBox("Entrez le premier nombre :")
sEnd = InputBox("Entrez le deuxième numéro :")
sSomme = 0
Pour i = CInt(sStart) Vers CInt(sEnd)
sSomme = sSomme + i
Ensuite je
MsgBox « La somme des nombres de » & sStart & » à « & sEnd & » est : » & sSum
fin sous
Pour chaque … Instruction de boucle suivanteappartient à la catégorie des opérateurs de type objet, c'est-à-dire s'applique principalement aux collections des objets ainsi que des tableaux . Le corps de la boucle est exécuté un nombre fixe de fois, correspondant au nombre d'éléments du tableau ou de la collection. Le format de l'instruction For Each … Next est :
Pour chaque<элемент>Dans<группа> <блок операторов>Suivant[<элемент>]
Boucles conditionnelles (boucles indéfinies)
Les boucles conditionnelles sont utilisées lorsque des actions répétées ne doivent être effectuées que sous certaines conditions. Le nombre d'itérations n'est pas défini et dans le cas général peut être égal à zéro (en particulier, pour les boucles avec une précondition). VBA propose aux développeurs plusieurs structures de contrôle pour organiser les boucles conditionnelles :
- Quatre types de boucles Do..Loop, qui diffèrent par le type de condition vérifiée et le temps d'exécution de ce contrôle.
- Une boucle While… Wend ininterrompue.
Faire pendant que... Boucle - Typique boucle avec précondition. La condition est vérifiée avant l'exécution du corps de la boucle. Le cycle continue son travail jusqu'à ce qu'il<условие>est exécuté (c'est-à-dire est vrai). Comme la vérification est effectuée au début, le corps de la boucle peut ne jamais être exécuté. Format de la boucle Do While … :
Faire pendant<условие>
<блок операторов>
boucle
Listing 2. Faire pendant que… Boucle
‘ OBJECTIF : Écrire un programme qui accepte les entrées de l'utilisateur
‘ une séquence arbitraire de nombres. L'entrée doit être terminée
‘ uniquement lorsque la somme des nombres impairs entrés dépasse 100.
Sous-échantillon8()
Dim OddSum As Integer
Dim OddStr As String 'chaîne avec des nombres impairs
Dim Num 'pour accepter les nombres d'entrée
OddStr="" 'initialisation de la chaîne de sortie
OddSum = 0' initialisation de la somme OddSum
Faire pendant que OddSum< 100 ‘начало цикла
Num = InputBox("Entrez le nombre : ")
Si (Num Mod 2)<>0 Alors ‘parité paire
OddSum = OddSum + Num' accumulation de la somme des nombres impairs
OddStr = OddStr & Num & ” ”
Fin si
boucle
'affiche une chaîne avec des nombres impairs
Invite MsgBox := "Numéros impairs : " & OddStr
fin sous
Instruction Do...Loop Whiledestiné à l'organisationboucle avec postcondition. La condition est vérifiée après que le corps de la boucle a été exécuté au moins une fois. Le cycle se poursuit jusqu'à<условие>reste vrai. Faire... Boucler pendant le format :
Faire<блок операторов>boucle pendant<условие>
Listing 3. Boucle avec postcondition
‘ OBJECTIF : Réaliser un programme pour le jeu « Devinez le nombre ». Le programme doit être aléatoire
' de manière à générer un nombre compris entre 1 et 1000, l'utilisateur doit
‘Devinez ce numéro. Le programme affiche un indice pour chaque numéro saisi.
' "plus ou moins".
Sous-échantillon8()
Randomize Timer ' initialisation du générateur de nombres aléatoires
Dim msg As String ' chaîne de message
Dim SecretNumber As Long, UserNumber As Variant
Begin : SecretNumber = Round(Rnd * 1000) ‘ nombre généré par ordinateur
UserNumber = Empty ' le numéro entré par l'utilisateur
Faire du gameplay
Sélectionnez la casse vraie
Case IsEmpty(UserNumber): msg = "Veuillez entrer un numéro"
Cas UserNumber > SecretNumber : msg = « Trop ! »
Numéro d'utilisateur du dossier< SecretNumber: msg = “Слишком мало!”
Fin de sélection
UserNumber = InputBox(prompt:=msg, Title:=”Devinez le numéro”)
Boucle pendant le numéro d'utilisateur<>numéro secret
' examen
Si MsgBox("Voulez-vous rejouer ?", vbOuiNon + vbQuestion, "Vous avez bien deviné !") = vbOui Alors
Aller au début
Fin si
fin sous
Faire jusqu'à… boucler et faire… boucler jusqu'à boucles sont des inversions de boucles conditionnelles précédemment considérées. En général, ils fonctionnent de manière similaire, sauf que le corps de la boucle est exécuté sous une condition fausse (c'est-à-dire<условие>= Faux). Le format de la boucle Faire jusqu'à ... est :
Faire jusqu'à ce que<условие> <блок операторов>boucle
Le format de la boucle Do … Loop Until est :
<блок операторов>
Boucle jusqu'à ce que<условие>
Tâche pratique :Réécrivez les programmes des Listings 10 et 11 en utilisant des instructions de boucle inversée.
Tandis que Boucle ... Wend s'applique également aux boucles conditionnelles. Cette instruction correspond parfaitement à la structure Do While … Loop. Le format de la boucle While … Wend est :
Tandis que<условие>
<блок операторов>
Wend
Une caractéristique distinctive de cette instruction est l'impossibilité d'une terminaison forcée (interruption) du corps de la boucle (l'instruction Exit Do ne fonctionne pas dans la boucle While ... Wend).
Interruption de boucle
L'instruction Exit est utilisée pour terminer l'itération et quitter la boucle. Cette instruction est applicable dans n'importe quelle structure cyclique, sauf While ... Wend. La syntaxe générale pour utiliser Exit pour rompre une boucle est :
<начало_цикла>
[<блок операторов1>]
Quitter (Pour | Faire)
[<блок операторов2>]
<конец_цикла>
Lorsque l'instruction Exit est exécutée, la boucle est interrompue et le contrôle est transféré à l'instruction suivant l'instruction<конец_цикла>. Le corps de la boucle peut contenir plusieurs instructions Exit.
Listing 4. Sortie de boucle forcée
Sous-échantillon9()
Pour i = 1 à 10000000
If i = 10 Then Exit For ' sort de la boucle lorsque le compteur atteint 10
Suivant