Pour le prochain vba Excel, passez au suivant. Instructions de boucle dans VBA. Projet "Revenus en dépôt"
Il existe des situations où un programme VBA doit effectuer le même ensemble d'actions plusieurs fois de suite (c'est-à-dire répéter le même bloc de code plusieurs fois). Cela peut être fait en utilisant des boucles VBA.
Instruction de boucle For dans Visual Basic
Structure de l'instruction de boucle Pour en Visual Basic peut être organisé sous l'une des deux formes suivantes : en boucle Pour… Suivant ou comme un cycle Pour chaque.
Cycle « Pour... Suivant »
Faire du vélo Pour… Suivant utilise une variable qui prend séquentiellement les valeurs d'une plage donnée. A chaque changement de valeur de la variable, les actions contenues dans le corps de la boucle sont effectuées. Ceci est facile à comprendre à partir d’un exemple simple :
Pour i = 1 à 10 Total = Total + iArray(i) Suivant i
Dans cette simple boucle Pour… Suivant la variable est utilisée je, qui prend séquentiellement les valeurs 1, 2, 3, ... 10, et pour chacune de ces valeurs le code VBA à l'intérieur de la boucle est exécuté. Ainsi, cette boucle additionne les éléments du tableau iArray dans une variable Total.
Dans l'exemple ci-dessus, l'étape d'incrémentation de la boucle n'est pas spécifiée, donc pour incrémenter la variable je De 1 à 10, la valeur par défaut est incrément 1 . Cependant, dans certains cas, il est nécessaire d'utiliser des valeurs d'incrément différentes pour la boucle. Cela peut être fait en utilisant le mot-clé Étape, comme le montre l’exemple simple suivant.
Pour d = 0 à 10 Étape 0,1 dTotal = dTotal + d Suivant d
Puisque dans l'exemple ci-dessus, le pas d'incrémentation est défini sur 0.1 , alors la variable dTotal pour chaque répétition du cycle prend les valeurs 0,0, 0,1, 0,2, 0,3, ... 9,9, 10,0.
Pour déterminer l'étape de boucle dans VBA, vous pouvez utiliser une valeur négative, par exemple, comme ceci :
Pour i = 10 À 1 Étape -1 iArray(i) = i Suivant i
Ici, le pas d'incrémentation est -1 , donc la variable jeà chaque répétition du cycle il prend les valeurs 10, 9, 8, ... 1.
Pour chaque boucle
Faire du vélo Pour chaque on dirait un cycle Pour… Suivant, mais au lieu de parcourir la séquence de valeurs de la variable compteur Pour chaque effectue un ensemble d'actions pour chaque objet dans un groupe d'objets spécifié. Dans l'exemple suivant, en utilisant une boucle Pour chaque Répertorie toutes les feuilles du classeur Excel actuel :
Dim wSheet comme feuille de calcul pour chaque wSheet dans les feuilles de calcul MsgBox "Feuille trouvée : " & wSheet.Name Next wSheet
Sortie pour l'opérateur d'interruption de boucle
Opérateur Quitter pour utilisé pour interrompre le cycle. Dès que cette instruction est rencontrée dans le code, le programme termine l'exécution de la boucle et procède à l'exécution des instructions trouvées dans le code immédiatement après cette boucle. Cela peut être utilisé, par exemple, pour rechercher une valeur spécifique dans un tableau. Pour ce faire, utilisez une boucle pour parcourir chaque élément du tableau. Une fois l’élément recherché trouvé, il n’est pas nécessaire de parcourir le reste : le cycle est interrompu.
Application opérateur Quitter pour démontré dans l’exemple suivant. Ici, la boucle parcourt 100 entrées du tableau et compare chacune d'entre elles avec la valeur de la variable. dVal. Si une correspondance est trouvée, la boucle est interrompue :
Pour i = 1 à 100 Si dValues(i) = dVal Then IndexVal = i Quitter pour End If Next i
Faire une boucle While dans Visual Basic
Faire du vélo Faire pendant exécute un bloc de code tant qu'une condition donnée est remplie. Ce qui suit est un exemple de la procédure Sous, dans lequel, à l'aide d'une boucle Faire pendant Les nombres de Fibonacci ne dépassant pas 1000 sont affichés séquentiellement :
"La procédure Sub imprime des nombres de Fibonacci ne dépassant pas 1000 Sub Fibonacci() Dim i As Integer "un compteur pour indiquer la position d'un élément dans la séquence Dim iFib As Integer "stocke la valeur actuelle de la séquence Dim iFib_Next As Integer "stocke le valeur suivante de la séquence Dim iStep As Integer "stocke la taille du prochain incrément" initialise les variables i et iFib_Next i = 1 iFib_Next = 0 "la boucle Do While sera exécutée jusqu'à ce que la valeur du "nombre de Fibonacci actuel dépasse 1000 Do Tandis que iFib_Next< 1000 If i = 1 Then "особый случай для первого элемента последовательности iStep = 1 iFib = 0 Else "сохраняем размер следующего приращения перед тем, как перезаписать "текущее значение последовательности iStep = iFib iFib = iFib_Next End If "выводим текущее число Фибоначчи в столбце A активного рабочего листа "в строке с индексом i Cells(i, 1).Value = iFib "вычисляем следующее число Фибоначчи и увеличиваем индекс позиции элемента на 1 iFib_Next = iFib + iStep i = i + 1 Loop End Sub
Dans l'exemple donné, la condition iFib_Suivant< 1000 vérifié en début de cycle. Par conséquent, si la première valeur iFib_Suivant S'il y en avait plus de 1 000, la boucle ne serait pas exécutée une seule fois.
Une autre façon d'implémenter une boucle Faire pendant– placez la condition non pas au début, mais à la fin de la boucle. Dans ce cas, la boucle sera exécutée au moins une fois, que la condition soit vraie ou non.
Schématiquement un tel cycle Faire pendant avec la condition vérifiée à la fin, cela ressemblera à ceci :
Faire... Boucler pendant iFib_Next< 1000
Faire jusqu'à la boucle dans Visual Basic
Faire du vélo Faire jusqu'à ce que très similaire à un cycle Faire pendant: Le bloc de code dans le corps de la boucle est exécuté encore et encore jusqu'à ce que la condition spécifiée soit satisfaite (le résultat de l'expression conditionnelle est Vrai). Dans la procédure suivante Sous en utilisant une boucle Faire jusqu'à ce que extrait les valeurs de toutes les cellules d'une colonne UN feuille de calcul jusqu'à ce qu'une cellule vide soit rencontrée dans la colonne :
IRow = 1 Do Until IsEmpty(Cells(iRow, 1)) "La valeur de la cellule actuelle est stockée dans le tableau dCellValues dCellValues(iRow) = Cells(iRow, 1).Value iRow = iRow + 1 Loop
Dans l'exemple ci-dessus, la condition EstVide(Cellules(iRow, 1)) situé au début de la structure Faire jusqu'à ce que, donc la boucle sera exécutée au moins une fois si la première cellule prise n'est pas vide.
Cependant, comme l'ont montré les exemples de boucles Faire pendant, dans certaines situations, vous souhaitez que la boucle soit exécutée au moins une fois, quel que soit le résultat initial de l'expression conditionnelle. Dans ce cas, l’expression conditionnelle doit être placée à la fin de la boucle, comme ceci :
Faire... Boucle jusqu'à ce qu'il soit vide (Cells (iRow, 1))
Instructions de boucle
En VBA Il existe deux principaux types de boucles : les boucles avec un compteur (paramétrique) et les boucles avec une condition (itérative).
Les contre-boucles sont utilisées dans les cas où il est nécessaire d'effectuer certaines actions un certain nombre de fois.
Les boucles conditionnelles sont utilisées lorsque certaines actions d'un programme doivent être répétées jusqu'à ce qu'une certaine condition soit remplie.
Boucles avec paramètre Pour… Suivant
Structure des cycles :
Pour Cycle_parameter = Initial_ValueÀ Valeur_finale
[Étape Étape]
Les opérateurs
[Sortie pour]
Suivant [Paramètre_cycle]
où pour mot-clé VBA (de), indiquant le début du cycle ;
variable loop_parameter définie comme compteur de boucle ;
Initial_Value un nombre qui spécifie la valeur initiale du paramètre de boucle ;
Vers le mot-clé VBA (avant), diviser
Initial_Value et Final_Knowledge ;
Final_Value un nombre précisant la valeur du paramètre de boucle,
À quel moment le cycle se termine ;
Mot-clé d'étape VBA (étape) utilisé pour
Spécifications des étapes de boucle, argument facultatif ;
Étape un numéro spécifiant l'étape du cycle, c'est-à-dire la valeur par laquelle
Augmente (ou diminue) la valeur du paramètre
Faites du vélo à chaque étape. Ce numéro pourrait être
Négatif;
Quitter pour opérateur de sortie anticipée de la boucle (facultatif) ;
Suivant mot-clé VBA (suivant) désignant
Fin du cycle.
Travail en vélo :
Étape 1 Tout d'abord, le paramètre de boucle est déterminé et les valeurs initiales et finales de cette variable sont calculées et stockées.
Étape 2 Le paramètre de boucle reçoit une valeur initiale.
Étape 3 La valeur initiale du paramètre de boucle est comparée à la valeur finale.
Si le paramètre de boucle est supérieur à la valeur finale, le programme quitte immédiatement la boucle et passe à la ligne de code qui suit la boucle.
Étape 4 Le corps de la boucle est exécuté.
Étape 5 Après avoir exécuté le corps de la boucle, la valeur suivante est attribuée au paramètre de boucle. Passez à l'étape 3.
Note.
1. Si un mot-clé est utiliséÉtape , alors le paramètre de boucle change en fonction du numéro spécifié après ce mot. Si le motÉtape est absent, alors la valeur du pas est égale à un.
Exemple 1.
Pour I = 0 à 10 Étape 2 (Valeur I augmentera de 2)
2. Pour... Boucle suivante peut être résilié de manière anticipée lorsqu’une condition est atteinte. Pour ce faire, au bon endroit dans la boucle vous devez placer l'opérateur Quitter pour.
Exemple 2.
Dim S comme entier
Dim j comme entier
S=2
Pour j = 1 à 10
S = S + j
Si S > 6 Alors
Quitter pour (Sortez de la boucle si la valeur S > 6)
Fin si
Suivant j
Boîte de message(S)
Boucles conditionnelles (itératives)
Si une action (plusieurs actions) doit être effectuée plusieurs fois, mais que l'on ne sait pas à l'avance combien de fois et que cela dépend d'une condition, vous devez alors utiliser une boucle avec une précondition ou une postcondition.
En VBA il y a deux boucles principales FAIRE... BOUCLE avec une condition saisie par un mot clé Alors que , et avec la condition renseignée par le mot-clé Jusqu'à . Les deux peuvent être avec précondition ou postcondition.
Syntaxe:
où faire mot-clé (faire);
Alors que mot-clé (encore) ;
Jusqu'à mot-clé (jusqu'à);
Boucle un mot-clé indiquant la fin du cycle ;
<условие>une expression logique dont la vérité est vérifiée
Au début de chaque exécution du corps de la boucle ;
<тело_цикла>séquence arbitraire d'opérateurs ;
À faire...Pendant la construction lit : faire tant que la condition est remplie. En conception Faire... pendant que pour
Le faire... Jusqu'à ce que la construction indique : faire jusqu'à ce que la condition soit remplie. En conception Faire jusqu'à ce que Pour augmenter le pas, vous devez écrire un opérateur spécial, car dedans, contrairement au design Pour , cela ne se fait pas automatiquement.
Condition écrite après le mot clé Jusqu'à , est vérifié à la fin de chaque itération (après l'exécution du corps de la boucle). Notez que cela ne fonctionne pas exactement de la même manière que dans la boucle. Alors que . Si la condition est vraie ( Vrai ), puis la boucle se termine. Si la condition n'est pas remplie (est faux FAUX ), puis le corps de la boucle est à nouveau exécuté.
Exemple 1.
Formulation du problème. Calculez la somme d’une série finie à l’aide d’une procédure de sous-programme.
Technologie d'exécution de tâches :
1. Données initiales : je Z
Résultat : S R .
2.Tapez la procédure personnalisée suivante dans le module de projet standard à l'aide d'une boucle avec une précondition Alors que:
Sous-somme()
Dim S comme entier
Dim i comme entier
S=0
je = 1
Faire pendant que je<= 10
S = S + je^2
je = je + 1
Boucle
Boîte de message(S)
Fin du sous-marin
3.Tapez la procédure personnalisée suivante dans le module de projet standard à l'aide d'une boucle avec une précondition Jusqu'à:
Sous-somme()
Dim S comme entier
Dim i comme entier
S=0
je = 1
Faire jusqu'à i > 10
S = S + je^2
je = je + 1
Boucle
Boîte de message(S)
Fin du sous-marin
4 Tapez la procédure personnalisée suivante dans le module projet standard à l'aide d'une boucle avec une postcondition Alors que:
Sous-somme()
Dim S comme entier
Dim i comme entier
S=0
je = 1
S = S + je^2
je = je + 1
Boucle pendant que je<= 10
Boîte de message(S)
Fin du sous-marin
5 Tapez la procédure personnalisée suivante dans le module projet standard à l'aide d'une boucle avec une postcondition Jusqu'à:
Sous-somme()
Dim S comme entier
Dim i comme entier
S=0
je = 1
S = S + je^2
je = je + 1
Boucle jusqu'à i > 10
Boîte de message(S)
Fin du sous-marin
Il peut arriver que vous deviez exécuter un bloc de code plusieurs fois. En général, les instructions sont exécutées de manière séquentielle : la première instruction d'une fonction est exécutée en premier, puis la seconde, etc.
Les langages de programmation fournissent différentes structures de contrôle qui permettent des chemins d'exécution plus complexes.
L'instruction loop nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Vous trouverez ci-dessous une vue générale d'une instruction de boucle dans VBA.
VBA fournit les types de boucles suivants pour gérer les exigences de boucle. Cliquez sur les liens suivants pour vérifier leurs détails.
pour la boucle
Une 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
Vous trouverez ci-dessous la syntaxe de la boucle for dans VBA.
Pour compteur = début Pour terminer .... .... Suivant
Représentation schématique
Vous trouverez ci-dessous le flux de contrôle en mode Boucle -
- La première étape est terminée. 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 c'est 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 maintenant à nouveau évaluée. Si vrai, la boucle est exécutée et le processus est répété (corps de la boucle, puis incrémentation d'étape, puis 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 is: " & 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
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 à For Loop ; cependant, la boucle est exécutée pour chaque élément du tableau ou du groupe. Le compteur de pas n’existera donc pas dans ce type de boucle. Il est principalement utilisé avec des tableaux ou utilisé dans un contexte d'objet système de fichiers travailler de manière récursive.
Syntaxe
Vous trouverez ci-dessous la syntaxe de la boucle For Each dans VBA.
Pour chaque élément du groupe....Suivant
exemple
Private Sub Constant_demo_Click() "fruits est un tableau fruits = Array("pomme", "orange", "cerises") Dim fruitnames As Variant "itérant en utilisant For chaque boucle. Pour chaque élément dans fruits fruitnames = fruitnames & Item & Chr(10) Next MsgBox fruitnames End Sub
Lorsque le code ci-dessus est exécuté, il imprime tous les noms des fruits avec un élément sur chaque ligne.
pomme
orange
cerises
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
Vous trouverez ci-dessous 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 : Counter = 10 While Counter< 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 le champ 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.
faire..pendant la boucle
Une 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
Vous trouverez ci-dessous la syntaxe de la boucle Do...While dans VBA.
Faire la condition 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 vraie.
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.
Faire... ... Condition de boucle While
exemple
L'exemple suivant utilise une boucle Do ... while pour vérifier l'état à la fin de la boucle. Les instructions dans une 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 être répétée jusqu'à ce que la condition soit fausse.
faire..intil boucle
Une boucle do ... intil ne sera pas utilisée lorsque l'on souhaite 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
Vous trouverez ci-dessous 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 quitte la boucle lorsque la condition devient vraie.
Private Sub Constant_demo_Click() i = 10 Do Jusqu'à i>15 "La condition est fausse. Par conséquent, la boucle sera 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... ... Boucle jusqu'à la condition
Représentation schématique
exemple
L’exemple suivant utilise Do...Before une boucle pour tester une condition à la fin de la boucle. Les instructions au sein d'une 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 Jusqu'à ce que i more15 " La condition soit True. 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 False. (C'est-à-dire) La boucle doit être répétée jusqu'à ce que la condition soit vraie.
Enregistrements de contrôle de cycle
Les instructions de contrôle de boucle modifient l'exécution hors de leur séquence normale. Lorsque l'exécution quitte la portée, toutes les autres instructions de boucle ne sont pas exécutées.
Énoncé de contrôle et description
Sortie de l'opérateur
Exit for est utilisé lorsque nous voulons quitter la 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
Vous trouverez ci-dessous la syntaxe de l'instruction Exit For dans VBA.
Représentation schématique
exemple
L’exemple suivant utilise Exit For. Si le compteur 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) Si i = 4 Alors i = i * 10 "Ceci n'est exécuté que si i=4 MsgBox ("La valeur est i est : " & i) Exit For "Quitter quand 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 une 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é dans les boucles Do Do...While et Do...Before.
Lorsque Exit Do est exécuté, le contrôle passe à l'instruction suivante immédiatement après la boucle Do.
Syntaxe
Vous trouverez ci-dessous 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 Faire pendant que je<= 100 If i >10 Then Quitter Do " La boucle se termine si 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
Complète une instruction Do While et transfère l'exécution à l'instruction immédiatement après la boucle
Travail en laboratoire sur les bases de la programmation
2.1. Tabulation des fonctions représentées analytiquement
et convergeant à proximité
But du travail
· Consolidation des connaissances théoriques sur les bases de l'organisation des structures ramifiées et cycliques.
· Acquisition de compétences pratiques en programmation utilisant des structures de branchement et cycliques dans le système Visual Basic.
Il existe trois types d'instructions de boucle en VB :
cycle de comptage : Pour...À...Suivant
boucles avec des préconditions : Do While...Loop, Do Until...Loop, While...WEnd
· boucles avec des postconditions : Do...Loop While, Do...Loop Until.
Boucle de comptage – vous permet de parcourir un ensemble d'instructions un nombre de fois spécifié. Sa syntaxe est la suivante :
Pour comptoir = CommencerÀ fin
[les opérateurs]
[les opérateurs]
Suivant [ comptoir]
Paramètre comptoir est une variable numérique (entier, type réel ou type Date, Variant, Devise) qui est automatiquement incrémentée après chaque répétition. Valeur initiale comptoirégal au paramètre Commencer, et le paramètre final – fin. S'il n'est pas spécifié, le pas est considéré comme égal à 1 ; la valeur du pas peut être modifiée. Il peut s'agir d'un nombre positif ou négatif.
Il existe quatre constructions syntaxiques de la boucle Do....Loop :
Les instructions entre les mots-clés Do... Loop sont exécutées un nombre de fois spécifié en fonction de la condition. Par exemple, dans le fragment de programme suivant, lorsque C = 100, la condition sera satisfaite et la boucle sera entrée. A l'intérieur de la boucle, la procédure est appelée et la valeur de C est diminuée de 1. Ensuite la condition (C > 0) est à nouveau vérifiée et les opérateurs de boucle sont à nouveau exécutés (ils seront exécutés 100 fois au total), jusqu'à ce que C = 0. Lorsque la condition C > 0 devient fausse et que la boucle s'arrête.
Faire pendant que C > 0
Le même fragment de programme exécuté à l'aide d'une boucle avec une précondition dans la syntaxe 2 :
Dans ce cas, la boucle s'exécute tant que la condition est fausse, contrairement au cas précédent, c'est-à-dire qu'elle continue avant réalisation de la condition C = 0.
Les instructions de boucle 3 et 4 ont une syntaxe très similaire aux deux premières, sauf que la condition Pas est calculé jusqu'à ce que la boucle soit exécutée au moins une fois.
Ces syntaxes de boucle peuvent utiliser les instructions de sortie de boucle inconditionnelles Exit For et Exit Do pour transférer le contrôle à l'opérateur derrière la boucle. Par exemple, dans le fragment de programme suivant, si la valeur initiale de C est >50, alors la boucle s'arrêtera immédiatement.
Faire jusqu'à C<= 0
MsgBox « Démarrer » la valeur est supérieure à la valeur acceptable », « Erreur de saisie »
La boucle While...Wend était utilisée dans les premières versions de Visual Basic. Sa syntaxe est la suivante :
Alors que<условие>
<Операторы>
Contrairement à la boucle Do..Loop, la boucle While ..Wend n'a pas de deuxième option dans laquelle la condition est vérifiée en fin de boucle. De plus, il n'y a pas d'instruction de sortie de boucle, comme Exit Do.
VBA. Organisation des cycles.
Les instructions de boucle sont utilisées pour répéter une action ou un groupe d'actions un nombre de fois spécifié. Le nombre de répétitions (itérations de boucle) peut être prédéterminé ou calculé.
VBA prend en charge deux types de constructions en boucle :
- Boucles avec un nombre fixe de répétitions ( boucles contrées).
- 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 , qui définit un bloc d'instructions placé entre les instructions de début et de fin de la boucle. Chaque répétition de l'exécution des instructions du corps de la boucle est appelée itération
Cycles fixes
VBA propose deux structures de contrôle pour organiser une boucle fixe : For ... Next (boucle avec un compteur) et For Each ... Next (boucle avec une énumération).
Opérateur pour...Suivant Il s'agit d'une boucle de compteur typique qui exécute un nombre spécifié d'itérations. La syntaxe de l'instruction For...Next est la suivante :
Pour<счетчик> = <начЗначение>Que<конЗначение>
<блок операторов>
Suivant [<счетчик>]
Un exemple d'utilisation de l'opérateur For...Next.
Listing 1. Pour… Opérateur suivant
‘ TÂCHE : Créer un programme qui reçoit deux numéros de l’utilisateur.
‘ Ajoute tous les nombres dans la plage spécifiée par ces deux nombres, puis
' affiche le montant obtenu.
Sous-échantillon7()
Dim i As Integer 'compteur de cycles
Dim sStart ‘valeur initiale du compteur
Dim sEnd' fin de la valeur du compteur
Dim sSum As Long ‘somme résultante
sStart = InputBox (« Entrez le premier chiffre : »)
sEnd = InputBox (« Entrez le deuxième numéro : »)
sSomme = 0
Pour i = CInt(sStart) À CInt(sEnd)
sSomme = sSomme + i
Ensuite je
MsgBox « La somme des nombres de « & sStart & » à « & sEnd & » est : « & sSum
Fin du sous-marin
Instruction de boucle pour chaque...Suivantappartient à la catégorie des opérateurs de type objet, c'est-à-dire s'applique principalement aux collections les objets, ainsi que les 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. Format de l'instruction Pour chaque... Suivant :
Pour chaque<элемент>Dans<группа> <блок операторов>Suivant [<элемент>]
Boucles conditionnelles (boucles non définies)
Les boucles conditionnelles sont utilisées lorsque des actions répétées doivent être effectuées uniquement sous certaines conditions. Le nombre d'itérations n'est pas défini et peut en général être égal à zéro (notamment 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 Do..Loops, qui diffèrent par le type de condition vérifiée et le temps nécessaire pour effectuer cette vérification.
- Boucle continue Tandis que... Wend.
La boucle Do While... est 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 a la valeur True). La vérification étant effectuée au début, le corps de la boucle risque de ne jamais être exécuté. Faire While... Format de boucle :
Faire pendant<условие>
<блок операторов>
Boucle
Listing 2. Faire une boucle While...
‘ TÂCHE : Créer un programme qui nécessite la saisie de l'utilisateur
« une séquence arbitraire de nombres. La saisie doit être terminée
‘ seulement après que la somme des nombres impairs saisis dépasse 100.
Sous-échantillon8()
Dim OddSum As Integer 'somme de nombres impairs
Dim OddStr As String 'une chaîne avec des nombres impairs
Dim Num 'pour accepter les numéros saisis
OddStr = "" 'initialisation de la chaîne de sortie
OddSum = 0 'initialiser OddSum
Faire pendant OddSum< 100 ‘начало цикла
Num = InputBox (« Entrez un nombre : »)
Si (Num Mod 2)<>0 Puis ‘contrôle de parité
OddSum = OddSum + Num' cumul de la somme des nombres impairs
OddStr = OddStr & Num & ” ”
Fin si
Boucle
'imprimer une chaîne avec des nombres impairs
Invite MsgBox :="Nombres impairs : " & OddStr
Fin du sous-marin
Faire... Boucle while instructionconçu pour 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 continue son travail jusqu'à<условие>reste vrai. Faire... Boucle pendant le formatage :
Faire<блок операторов>Boucle pendant<условие>
Listing 3. Boucle avec postcondition
‘ TÂCHE : Créez un programme pour le jeu « Devinez le nombre ». Le programme doit être aléatoire
‘ manière de 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 'initialise le générateur de nombres aléatoires
Dim msg As String ‘ chaîne de message
Dim SecretNumber As Long, UserNumber comme variante
Début : SecretNumber = Round(Rnd * 1000) ‘ numéro généré par ordinateur
UserNumber = Vide ‘numéro saisi par l’utilisateur
Faire du gameplay
Sélectionnez Case vrai
Case IsEmpty (UserNumber) : msg = « Entrez un numéro »
Cas UserNumber > SecretNumber : msg = « Trop ! »
Numéro d'utilisateur du cas< SecretNumber: msg = “Слишком мало!”
Fin de la sélection
UserNumber = InputBox(prompt:=msg, Title:=”Devinez le numéro”)
Boucle pendant le numéro d'utilisateur<>Numéro secret
' examen
Si MsgBox("Rejouer ?", vbOuiNon + vbQuestion, "Vous l'avez deviné !") = vbOui Alors
AllerPour Commencer
Fin si
Fin du sous-marin
Les boucles font jusqu'à... Boucler et faire... Boucler jusqu'à sont des inversions des boucles conditionnelles discutées précédemment. En général, ils fonctionnent de la même manière, sauf que le corps de la boucle est exécuté si la condition est fausse (c'est-à-dire<условие>=Faux). Faire jusqu'à... Format de boucle :
Faire jusqu'à ce que<условие> <блок операторов>Boucle
Faire... Boucle jusqu'au format de boucle :
<блок операторов>
Boucle jusqu'à<условие>
Tâche pratique :Réécrivez les programmes des listings 10 et 11 en utilisant des instructions en boucle inversée.
Boucle pendant... Wend s'applique également aux boucles conditionnelles. Cet opérateur est entièrement cohérent avec la structure Do While... Loop. Tandis que...Format de boucle Wend :
Alors que<условие>
<блок операторов>
Wende
Une particularité de cet opérateur est l'impossibilité licenciement forcé(interrompre) le corps de la boucle (l'opérateur Exit Do ne fonctionne pas dans la boucle While ... Wend).
Interrompre un cycle
Pour terminer l'itération plus tôt et quitter la boucle, l'instruction Exit est utilisée. Cet opérateur est applicable dans n'importe quelle structure cyclique sauf While... Wend. La syntaxe générale pour utiliser Exit pour rompre une boucle est la suivante :
<начало_цикла>
[<блок операторов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 qui suit l'instruction<конец_цикла>. Il peut y avoir plusieurs instructions Exit dans le corps d'une boucle.
Listing 4. Forcer la sortie de la boucle
Sous-échantillon9()
Pour i = 1 à 10000000
Si i = 10 Then Exit For ‘ quitte la boucle lorsque le compteur atteint 10
Suivant
