Structure de boucle
Les structures en boucle permettent d’exécuter une ou plusieurs lignes de code de manière répétée. Les structures de boucles prises en charge par Visual Basic sont :
1.Faire... une boucle
2.Pour...Suivant
3.PourChaque...Suivant
Faire... une boucle
Utilisez une boucle Do pour exécuter de manière répétée un bloc d’instructions un nombre variable de fois. Il existe plusieurs variantes de l'instruction Do...Loop, mais chacune évalue une condition numérique pour décider de poursuivre ou non l'exécution. Like If...Thencondition doit être une valeur numérique ou une expression dont la valeur est True (différente de zéro) ou False (zéro). Dans la boucle Do...Loop suivante, les instructions sont exécutées tant que la condition est vraie.
DoWhilecondition
déclarations
Boucle
Lorsque Visual Basic exécute cette boucle Do, il teste d'abord la condition. Si la condition est False (zéro), toutes les instructions sont ignorées. Si la condition est True (différente de zéro), Visual Basic exécute l'instruction, puis revient à l'instruction DoWhile pour tester à nouveau la condition.
Par conséquent, la boucle peut être exécutée autant de fois que souhaité tant que la condition est vraie ou non nulle. Si la condition est fausse depuis le début, l'instruction ne sera pas exécutée. Par exemple, la procédure suivante comptera le nombre de fois qu'une chaîne cible apparaît dans une autre chaîne et bouclera chaque fois que la chaîne cible est trouvée :
FunctionCountStrings (chaîne longue, cible)
Dimposition, compte
position=1
DoWhileInStr(position,chaîne longue,cible)
position=InStr(position,chaîne longue,cible)_
1
compte = compte 1
Boucle
CountStrings=compte
FinFonction
Si la chaîne cible n'apparaît pas dans une autre chaîne, InStr renvoie 0 et la boucle n'est plus exécutée.
Une autre variante de l'instruction Do...Loop consiste à exécuter d'abord l'instruction, puis à tester la condition après chaque exécution. Ce formulaire garantit que les instructions sont exécutées au moins une fois :
Faire
déclarations
BoucleWhilecondition
Les deux autres variantes sont similaires aux deux premières, sauf qu'elles exécutent la boucle chaque fois que la condition est False au lieu de True.
Pour...Suivant000
Lorsque vous ne savez pas combien de fois l'instruction doit être exécutée dans la boucle, il convient d'utiliser une boucle Do. Cependant, lorsque vous savez combien de fois vous souhaitez exécuter, il est préférable d'utiliser une boucle For...Next. Contrairement à la boucle Do, la boucle For utilise une variable appelée compteur Chaque fois que la boucle est répétée, la valeur de la variable compteur augmente ou diminue. La syntaxe de la boucle For est la suivante :
Forcounter=startToend[Stepincrement]
déclarations
Suivant[compteur]
Les paramètres Compteur, Début, Fin et incrément sont tous numériques.
Notez que le paramètre d'incrément peut être positif ou négatif. Si l'incrément est positif, Start doit être inférieur ou égal à end, sinon l'instruction dans la boucle ne peut pas être exécutée. Si l'incrément est négatif, Start doit être supérieur ou égal à end pour que le corps de la boucle puisse être exécuté. Si Step n’est pas défini, la valeur par défaut de l’incrément est 1.
Lors de l'exécution d'une boucle For, Visual Basic
1. Réglez le compteur égal au démarrage.
2. Testez si le compteur est supérieur à la fin. Si tel est le cas, Visual Basic quitte la boucle. (Si l'incrément est négatif, Visual Basic teste si le compteur est inférieur à la fin.)
3. Exécutez l'instruction.
4. Le compteur augmente de un ou d'un incrément (si spécifié).
5. Répétez les étapes 2 à 4.
Le code suivant imprime tous les noms de polices d'écran valides :
PRivateSubForm_Click()
DimIAsInteger
Fori=0ToScreen.FontCount
PrintScreen.Fonts(i)
Suivant
EndSub
Dans l’exemple d’application VCR, la procédure HighlightButton utilise une boucle For...Next pour parcourir la collection de contrôles du formulaire VCR et afficher le contrôle Shape approprié :
SubHighlightButton (MyControlAsVariant)
DimiAsInteger
Fori=0TofrmVCR.Controls.Count-1
IfTypeOffrmVCR.Controls(i)IsShapeThen
IffrmVCR.Controls(i).Name=MyControlThen
frmVCR.Controls(i).Visible=True
Autre
frmVCR.Controls(i).Visible=False
FinSi
FinSi
Suivant
EndSub
PourChaque...Suivant
La boucle ForEach...Next est similaire à la boucle For...Next, mais elle répète un ensemble d'instructions pour chaque élément d'un tableau ou d'une collection d'objets, plutôt que de répéter les instructions un certain nombre de fois. La boucle ForEach...Next est utile si vous ne savez pas combien d'éléments contient une collection.
La syntaxe de la boucle ForEach...Next est la suivante :
PourEchelementIngroup
déclarations
Élément suivant
Par exemple, le sous-programme suivant ouvre Biblio.mdb et ajoute le nom de chaque table à une zone de liste.
Sous-ListeTableDefs()
DimobjDbAsBase de données
DimMyTableDefasTableDef
SetobjDb=OpenDatabase(c:/vb/biblio.mdb,_
Vrai, faux)
ForEachMyTableDefInobjDb.TableDefs()
Liste1.AddItemMyTableDef.Name
SuivantMaTableDef
EndSub
Veuillez garder à l'esprit quelques limitations lors de l'utilisation de ForEach...Suivant :
1. Pour les collections, l'élément ne peut être qu'une variable Variant, une variable Objet générale ou un objet répertorié dans le "Navigateur d'objets".
2. Pour les tableaux, l'élément ne peut être qu'une variable Variant.
3.ForEach...Next ne peut pas être utilisé avec des tableaux de types définis par l'utilisateur, car Variant ne peut pas contenir de types définis par l'utilisateur.
Utiliser des structures de contrôle
Les structures de contrôle imbriquées placent une structure de contrôle dans une autre structure de contrôle (comme un bloc If...Then dans une boucle For...Next). Une structure de contrôle contenant une autre structure de contrôle est appelée un nid. Dans Visual Basic, il n'y a pas de limite au nombre de niveaux imbriqués de structures de contrôle. En règle générale, afin de rendre les structures de jugement et les structures de boucles plus lisibles, le texte des structures de jugement ou des boucles est toujours écrit en indentation.
Par exemple, le processus suivant imprime tous les noms de polices communs à l'imprimante et à l'écran :
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
SiSFont=PFontThen
ImprimerSFont
FinSi
SuivantPFont
SuivantSFont
EndSub
Notez que le premier Next ferme la boucle For interne et le dernier For ferme la boucle For externe. De même, dans les instructions If imbriquées, l’instruction EndIf est automatiquement associée à l’instruction If précédente la plus proche. Les structures imbriquées Do...Loop fonctionnent de la même manière, l'instruction Loop la plus interne correspondant à l'instruction Do la plus interne.
structure de contrôle de sortie
Utilisez l'instruction Exit pour quitter directement la boucle For, la boucle Do, le sous-processus ou le processus de fonction. La syntaxe de l'instruction Exit est très simple : il n'y a pas de limite au nombre de fois ExitFor peut apparaître dans la boucle For, et il n'y a pas de limite au nombre de fois ExitDo peut apparaître dans la boucle Do.
Pourcompteur=débutVersfin
[incrément par incrément]
[bloc d'instructions]
[SortiePour]
[bloc d'instructions]
Suivant[counter[,counter][,...]]
Faire[{Pendant|Jusqu'à}condition]
[bloc d'instructions]
[SortieFaire]
[bloc d'instructions]
Boucle
L'instruction ExitDo peut être utilisée dans toutes les versions de la syntaxe de boucle Do.
ExitFor et ExitDo sont utiles car il est parfois approprié de quitter une boucle immédiatement sans exécuter d'autres itérations ou instructions dans la boucle. Par exemple, dans l'exemple précédent d'une police partagée entre l'écran d'impression et l'imprimante, le programme a continué à comparer la police de l'imprimante à une police d'écran donnée, même après avoir trouvé une police de machine à écrire correspondante. Il existe une version plus efficace de cette fonction qui sort de la boucle dès qu'une police correspondante est trouvée :
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
SiSFont=PFontThen
ImprimerSfont
ExitFor 'Quitter la boucle interne.
FinSi
SuivantPFont
SuivantSFont
EndSub
Comme l'illustre cet exemple, les instructions Exit apparaissent presque toujours à l'intérieur des instructions If ou des instructions SelectCase, qui sont imbriquées dans des boucles.
Lorsqu'une boucle est interrompue par une instruction Exit, la valeur de la variable compteur différera selon la manière dont la boucle est quittée :
1. Lorsque le cycle est terminé, la valeur du compteur est égale à la valeur limite supérieure plus la valeur de pas.
2. En sortie anticipée de la boucle, la variable compteur conserve sa valeur, sous réserve des règles générales concernant les plages de valeurs.
3. Lors d'une itération en dehors de la collection, si la variable compteur est de type Objet, sa valeur est Nothing ; si la variable compteur est de type Variant, sa valeur est Vide.
Quitter un sous-programme ou une procédure de fonction
Une procédure peut également être quittée depuis une structure de contrôle. La syntaxe de ExitSub et ExitFunction est similaire à ExitFor et ExitDo dans la section précédente « Structure de contrôle de sortie ». ExitSub peut apparaître n'importe où dans le corps du sous-processus, autant de fois que nécessaire.
ExitSub et ExitFunction sont utiles lorsque la procédure a terminé chaque tâche et peut revenir directement. Par exemple, si vous souhaitez modifier l'exemple précédent afin que seule la première police trouvée pour l'imprimante et l'écran soit imprimée, vous pouvez utiliser ExitSub :
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
SiSFont=PFontThen
ImprimerSfont
ExitSub 'Quitter le processus.
FinSi
SuivantPFont
SuivantSFont
EndSub
->