Pour le prochain vba excel passer au suivant. Instructions de boucle dans VBA. Projet "Revenu 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 plusieurs fois le même bloc de code). Cela peut être fait en utilisant des boucles VBA.
Instruction de boucle "For" dans Visual Basic
Structure de l'instruction de boucle Pour dans Visual Basic peut être organisé sous l'une des deux formes suivantes : en tant que boucle Pour … Suivant ou en boucle Pour chaque.
La boucle "Pour...Suivant"
Cycle Pour … Suivant utilise une variable qui prend séquentiellement des valeurs dans une plage donnée. A chaque changement de la valeur de la variable, les actions contenues dans le corps de la boucle sont exécutées. C'est facile à comprendre à partir d'un exemple simple :
Pour i = 1 à 10 Total = Total + iTableau(i) Prochain 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 somme les éléments du tableau iTableau dans une variable Total.
Dans l'exemple ci-dessus, le pas d'incrémentation de la boucle n'est pas spécifié, donc pour incrémenter la variable je Incrément par défaut de 1 à 10 1 . Cependant, dans certains cas, il est nécessaire d'utiliser d'autres valeurs d'incrément pour la boucle. Cela peut être fait avec le mot-clé marcher, comme le montre l'exemple simple suivant.
Pour d = 0 à 10 Étape 0,1 dTotal = dTotal + d Prochain d
Puisque dans l'exemple ci-dessus, le pas d'incrémentation est égal à 0.1 , alors la variable dTotal pour chaque itération de la boucle prend les valeurs 0.0, 0.1, 0.2, 0.3, ... 9.9, 10.0.
Vous pouvez utiliser une valeur négative pour définir le pas de boucle dans VBA, comme ceci :
For i = 10 To 1 Step -1 iArray(i) = i Next i
Ici l'augmentation est -1 , donc la variable jeà chaque itération de la boucle prend les valeurs 10, 9, 8, ... 1.
Pour chaque boucle
Cycle Pour chaque comme un cycle Pour … Suivant, mais au lieu d'itérer sur la séquence de valeurs de la variable compteur, la boucle Pour chaque exécute un ensemble d'actions pour chaque objet du groupe d'objets spécifié. Dans l'exemple suivant, en utilisant une boucle Pour chaqueénumère toutes les feuilles du classeur Excel actuel :
Dim wSheet As Worksheet For Each wSheet in Worksheets MsgBox "Sheet Found: " & wSheet.Name Next wSheet
Instruction de rupture de boucle "Quitter pour"
Opérateur Quitter pour utilisé pour rompre la boucle. 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 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, chaque élément du tableau est visualisé à l'aide d'une boucle. Dès que l'élément requis est trouvé, il n'est pas nécessaire de parcourir le reste - la boucle est interrompue.
Demande d'opérateur Quitter pour démontré dans l'exemple suivant. Ici, la boucle parcourt 100 entrées du tableau et compare chacune avec la valeur de la variable dVal. Si une correspondance est trouvée, la boucle se rompt :
For i = 1 To 100 If dValues(i) = dVal Then IndexVal = i Exit For End If Next i
Boucle Do While en Visual Basic
Cycle Faire pendant exécute un bloc de code jusqu'à ce que la condition spécifiée soit remplie. Voici un exemple de procédure Sous, dans lequel à l'aide du cycle Faire pendant Les nombres de Fibonacci ne dépassant pas 1000 sont affichés séquentiellement :
"La procédure Sub génère des nombres de Fibonacci ne dépassant pas 1000 Sub Fibonacci() Dim i As Integer "un compteur pour indiquer la position de l'élément dans la séquence Dim iFib As Integer "stocke la valeur actuelle de la séquence Dim iFib_Next As Integer "stocke la valeur suivante de la séquence Dim iStep As Integer "stocke la taille de l'incrément suivant" 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 Alors 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_Next< 1000 vérifié en début de cycle. Ainsi, si la première valeur iFib_Next S'il y en avait plus de 1000, la boucle ne serait jamais exécutée.
Une autre façon d'implémenter une boucle Faire pendant- placer 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 remplie ou non.
Schématiquement, un tel cycle Faire pendant avec la condition à vérifier à la fin ressemblera à ceci :
Faire ... Boucler pendant que iFib_Next< 1000
Faire jusqu'à la boucle dans Visual Basic
Cycle Faire jusqu'à ce que très similaire au 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 remplie (le résultat de l'expression conditionnelle est Vrai). Dans la procédure suivante Sousà l'aide d'un cycle Faire jusqu'à ce que récupérer les valeurs de toutes les cellules d'une colonne UN feuille de calcul jusqu'à ce qu'il y ait une cellule vide dans la colonne :
IRow = 1 Do Until IsEmpty(Cells(iRow, 1)) "La valeur de la cellule courante 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 indiqué dans les exemples de boucle Faire pendant, dans certaines situations, il est nécessaire 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 ... Boucler jusqu'à ce que IsEmpty(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ération).
Les boucles avec compteur sont utilisées dans les cas où il est nécessaire d'effectuer une action un certain nombre de fois.
Les boucles conditionnelles sont utilisées lorsqu'une action du programme doit être répétée jusqu'à ce qu'une certaine condition soit remplie.
Cycles avec un paramètre Pour … Suivant
Structure du cycle :
Pour Paramètre_de_boucle = Valeur_initiale Pour Valeur_finale
[Étape Étape]
Les opérateurs
[sortie pour]
Suivant [Paramètre_boucle]
où pour mot-clé VBA (depuis), désignant le début du cycle ;
variable loop_parameter définie comme compteur de boucle ;
Start_Value un nombre qui spécifie la valeur initiale du paramètre de cycle ;
Au mot-clé VBA (avant) diviser
Start_Value et End_Knowledge ;
End_Value un nombre qui spécifie la valeur du paramètre de boucle,
À laquelle le cycle se termine ;
Mot-clé d'étape VBA (étape) utilisé pour
Affectations d'étape de boucle, argument facultatif ;
Step est un nombre spécifiant l'étape du cycle, c'est-à-dire la valeur à laquelle
Augmente (ou diminue) la valeur du paramètre
Faites du vélo à chaque étape. Ce nombre pourrait être
négatif;
Quitter pour Opérateur de sortie anticipée de boucle (optionnel);
Suivant mot-clé VBA (suivant) désignant
Fin de cycle.
Travail cycliste :
Étape 1 Tout d'abord, le paramètre de boucle est déterminé et les valeurs de début et de fin 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 de début du paramètre de boucle est comparée à la valeur de fin.
Si le paramètre de boucle est supérieur à la valeur de fin, le programme quitte immédiatement la boucle et saute à 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 affectée au paramètre de boucle. Passez à l'étape 3.
Note.
1. Si le mot clé est utilisé marcher , alors le paramètre cycle change selon le nombre spécifié après ce mot. Si le mot marcher manquant, 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 interrompu prématurément lorsqu'une condition quelconque est atteinte. Pour ce faire, au bon endroit dans la boucle, vous devez placer l'opérateur Quitter pour .
Exemple 2
Dim S en tant qu'entier
Dim j en tant qu'entier
S=2
Pour j = 1 à 10
S = S + j
Si S > 6 Alors
Quitter pour (Sortie de la boucle si la valeur S > 6)
Fin si
J suivant
MsgBox(S)
Boucles conditionnelles (itératives)
Si une action (plusieurs actions) doit être effectuée plusieurs fois, mais que le nombre de fois n'est pas connu à l'avance et que cela dépend de certaines conditions, vous devez utiliser une boucle avec une précondition ou une postcondition.
En VBA il y a deux cycles principaux FAIRE... BOUCLE avec condition entrée par mot-clé Alors que , et avec la condition introduite par le mot clé Jusqu'à . Les deux peuvent être précondition ou postcondition.
Syntaxe:
où faire mot-clé (faire);
Alors que mot-clé (encore);
Jusqu'à mot-clé (aussi longtemps que);
boucle un mot clé indiquant la fin du cycle ;
<условие>expression logique dont la véracité 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
La construction Do … Until se lit comme suit : continuer 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 en elle, contrairement à la conception 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 ici tout à fait 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 exécuté à nouveau.
Exemple 1
Formulation du problème. Calculer la somme d'une série finie à l'aide d'une procédure de sous-programme.
Technologie d'exécution des tâches :
1. Données initiales : je Z
Résultat : S R .
2. Tapez dans le module standard du projet la procédure utilisateur suivante à l'aide d'une boucle avec un précondition alors que:
sous-somme()
Dim S en tant qu'entier
Dim i comme entier
S=0
je = 1
Faire pendant que je<= 10
S=S+i^2
je = je + 1
boucle
MsgBox(S)
fin sous
3. Tapez dans le module standard du projet la procédure utilisateur suivante à l'aide d'une boucle avec une condition préalable Jusqu'à :
sous-somme()
Dim S en tant qu'entier
Dim i comme entier
S=0
je = 1
Faire jusqu'à i > 10
S=S+i^2
je = je + 1
boucle
MsgBox(S)
fin sous
4 Saisissez dans le module standard du projet la procédure utilisateur suivante, en utilisant une boucle avec une postcondition alors que:
sous-somme()
Dim S en tant qu'entier
Dim i comme entier
S=0
je = 1
S=S+i^2
je = je + 1
Boucle pendant que je<= 10
MsgBox(S)
fin sous
5 Tapez dans le module standard du projet la procédure utilisateur suivante, en utilisant une boucle avec une postcondition Jusqu'à :
sous-somme()
Dim S en tant qu'entier
Dim i comme entier
S=0
je = 1
S=S+i^2
je = je + 1
Boucle jusqu'à i > 10
MsgBox(S)
fin sous
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 système de fichiers travailler 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 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.
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
Travail de 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 à l'aide de structures arborescentes et cycliques dans le système Visual Basic.
Il existe trois types d'instructions de boucle dans VB :
cycle de comptage : For…To…Next
Boucles avec préconditions : Do While...Loop, Do Until...Loop, While…WEnd
Boucles avec postconditions : Do...Loop While, Do...Loop Until.
Cycle de comptage - vous permet de parcourir un ensemble d'instructions un nombre de fois spécifié. Sa syntaxe est la suivante :
Pour comptoir = Commencer Pour fin
[les opérateurs]
[les opérateurs]
Suivant[ comptoir]
Paramètre comptoir est une variable numérique (entier, réel ou Date, Variante, Devise) qui est automatiquement incrémentée après chaque itération. Valeur initiale comptoirégal au paramètre Commencer, et le dernier paramètre est 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 pour 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 remplie et la boucle entrera. A l'intérieur de la boucle, la procédure est appelée et la valeur de C diminue de 1. Puis la condition est à nouveau vérifiée (C > 0) et les instructions de la boucle sont à nouveau exécutées (elles seront exécutées 100 fois au total), jusqu'à C = 0. Lorsque la condition C > 0 devient fausse et la boucle s'arrête.
Faire Tant que C > 0
Le même fragment de programme exécuté à l'aide d'une boucle de précondition dans la syntaxe 2 :
Dans ce cas, la boucle est exécutée 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 dans les syntaxes 3 et 4 sont très similaires aux deux premières, sauf que la condition Pas est évalué jusqu'à ce que la boucle se soit exécutée au moins une fois.
Dans les syntaxes de ces boucles, vous pouvez utiliser les opérateurs de sortie inconditionnelle de la boucle Exit For et Exit Do, qui permettent de 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, la boucle s'arrêtera immédiatement.
Faire jusqu'à C<= 0
MsgBox "Démarrer. la valeur est supérieure à celle autorisée", "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 le test de condition est effectué à la fin de la boucle. De plus, il n'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 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<счетчик> = <начЗначение>Ce<конЗначение>
<блок операторов>
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 saisi 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'à<условие>
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. Cet opérateur correspond entièrement à la structure Do While … Loop. Le format de la boucle While … Wend est :
Alors que<условие>
<блок операторов>
Wend
Une particularité de cet opérateur est l'impossibilité résiliation forcée(interruptions) du corps de la boucle (l'instruction Exit Do ne fonctionne pas dans une 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
