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 le contexte d'objets du système de fichiers pour fonctionner 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

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 :

1. Boucles avec un nombre fixe de répétitions ( boucles contrées).
2. 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é de forcer l'achèvement (l'interruption) du 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

Leçon de la série : « Programmation en Visual Basic.NEN pour les écoliers"

Vous êtes familiarisé avec le contrôle ComboBox.
Dans cette leçon, nous continuerons notre étude des opérateurs du langage Visual Basic.Net, en nous concentrant sur les opérateurs de boucle.
Il existe trois types de structures algorithmiques cycliques :

1. des contre-boucles, dans lesquelles le corps de la boucle est exécuté un certain nombre de fois ;
2. boucles pour traiter des tableaux ou des collections ;
3. boucles conditionnelles, dans lesquelles le corps de la boucle est exécuté lorsque la condition est vraie (ou jusqu'à ce que la condition devienne vraie).

Dans cette leçon, nous examinerons l'opérateur de boucle avec un compteur (For . . . Next). Écrivons un projet en utilisant cet opérateur.

Faire du vélo avec compteur Pour. . . Suivant t est utilisé lorsqu'on sait à l'avance combien de répétitions doivent être effectuées.

Diagramme

Vue générale de l'opérateur

Pour le compteur = StartValue To EndValue Corps de la boucle suivant [Compteur]

La syntaxe de l'opérateur est la suivante : la ligne commençant par le mot-clé For est le début de la boucle, et la ligne avec le mot-clé Next est la fin de la boucle, entre elles se trouvent les instructions qui constituent le corps de la boucle.

Algorithme d'exécution de l'opérateur For. . . Suivant

1. La valeur de la variable Counter est définie comme étant égale à StartValue.
2. La condition Compteur est cochée<= КонЗнач
3. Si la condition est remplie, alors le corps de la boucle est exécuté. La variable Compteur est modifiée par la valeur du pas : Compteur = Compteur + pas.
4. Lorsque la variable Counter atteint la valeur ConValue, la boucle se termine et les instructions suivantes sont exécutées.

Le programmeur peut organiser une sortie prématurée de la boucle à l'aide de la construction Exit For. Dans ce cas, la boucle est automatiquement quittée et le contrôle est transféré à la commande suivante suivant la boucle.

Projet "Revenus en dépôt"

Écrivez un projet qui calcule le revenu d'un dépôt et fournit le calcul des intérêts simples et composés. Les intérêts simples sont accumulés à la fin de la durée du dépôt, les intérêts composés sont accumulés mensuellement et sont ajoutés au montant du dépôt initial, et les intérêts du mois suivant sont accumulés sur le nouveau montant. La forme recommandée est indiquée dans la figure.

Technologie d'exécution

Ce didacticiel a montré comment utiliser une boucle For...Next pour répéter le code un nombre de fois spécifié.

Un cycle est une structure algorithmiqueà l'aide duquel on réalise la répétition répétée d'un bloc d'opérateurs.

Instruction de boucle avec compteur (Pour ... Suivant)

L'instruction For...Next vous permet d'exécuter de manière cyclique un ensemble d'instructions (opérateurs) un nombre de fois spécifié. Syntaxe des instructions :

Pour compteur = valeur_débutÀ valeur_fin

[instructions]

[instructions]

Suivant [ comptoir]

Paramètre comptoir est une variable numérique qui change automatiquement sa valeur en étape après chaque répétition du cycle. La boucle se déroule jusqu'à comptoir£ valeur_fin avec une valeur de paramètre positive étape ou jusqu'à comptoir³ valeur_fin avec une valeur de paramètre négative étape. Ainsi, la boucle ne sera pas exécutée une seule fois si, avec une valeur de pas positive valeur_début plus que valeur_fin. Si le paramètre Step étape est omis, alors par défaut l'incrément de la variable compteur est défini sur 1.

L'instruction Exit For termine 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'opérateur For, le paramètre comptoir– une variable arithmétique de n'importe quel type, il est quand même 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 est lié à la manière dont les numéros 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 " Réinitialiser 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écuter la boucle, dans cet exemple 10 fois

Ensuite je " Fin du cycle. La valeur du paramètre de boucle est augmentée d'un pas.

Dans ce fragment de programme, la boucle sera exécutée exactement 10 fois.

Exemple 2

Affichez dans la 1ère colonne de la feuille de calcul (à partir de la 2ème ligne) les valeurs x comprises entre 0 et 3,2 par incréments de 0,4.

Sous-onglet public()

Dim x comme simple, i comme entier

Pour x = 0 à 3,2 Étape 0,4

Bien que la longueur de l'intervalle soit divisée exactement par incréments de 0,4, le résultat sur la feuille de calcul 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 à l'aide d'un compteur de type entier.

Dans ce cas, le programme prendra la forme :

Sous-onglet public1()

Dim x comme simple, i comme entier, n comme entier

n = CInt((3,2 - 0) / 0,4)

Pour i = 0 À n Étape 1

Cellules (i + 2, 1) = x

Instruction de boucle pour chaque...Suivant

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– 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 le tableau ou la 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

Moyenne de la fonction publique (plage en tant que plage) en double

Élément Dim comme variante

Diminuer le montant en double

Faible quantité sous forme d'entier

Quantité = 0

Pour chaque élément de la plage

Montant = Montant + Élément

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 les unes dans les autres dans n'importe quel ordre.