ISET Mahdia Programmation évènementielle

Chapitre 2 : Les éléments de base de VB.Net

Objectif Général

Ce chapitre présente les structures de base de la programmation en Visual Basic. Il présente

d’abord la notion des variables, les différents types standards, les opérateurs arithmétiques, Les
modificateurs d’accès, les structures usuelles: structures de contrôles conditionnelles et répétitives
et finalement les structures de données élaborées (tableau, structure).

Objectifs Spécifiques

A la fin de ce chapitre les étudiants auront les connaissances nécessaires pour :

 décrire les différents types de données utilisables pour la déclaration de variables ;

 nommer, déclarer, initialiser et utiliser des variables et des constantes ;
 déclarer des variables avec différents niveaux de portée ;
 créer des structures de données ;
 convertir des valeurs de variables d’un type de données en un autre type ;
 stocker des données dans des tableaux.
 créer des formules et des expressions conditionnelles à l’aide d’opérateurs arithmétiques,
logiques et de comparaison ;
 utiliser des instructions If.Then pour évaluer si une condition est vraie ou fausse et canaliser
le flux du programme en conséquence ;
 utiliser des instructions Select Case pour tester les différentes valeurs d’une même
expression et exécuter les instructions correspondantes ;
 utiliser des instructions Do.Loop pour exécuter des instructions jusqu’à ce qu’une condition
spécifique soit remplie ou pendant qu’elle est remplie ;
 utiliser des instructions For.Next pour exécuter des instructions un nombre de fois déterminé
 choisir la structure de décision ou la boucle appropriées en fonction des conditions requises
par l’application.

Pré-requis
Algorithmique, programmation.

Mme. BOUGHAMMOURA Héla 1

ISET Mahdia Programmation évènementielle

Volume horaire
3 Heures

Table des matières

1. Variable et opérations arithmétiques ....................................................................................... 3

1.1. Notion de Variable ......................................................................................................................... 3

1.2. Les différents types de variables ............................................................................................. 4

1.3. Opérateurs arithmétiques ........................................................................................................... 5

1.4. Convertir des variables................................................................................................................. 6

1.5. La portée des variables ................................................................................................................ 7

2. Déclaration des constantes ......................................................................................................... 9

3. Les énumérations ........................................................................................................................... 9

4. Structure et tableaux ................................................................................................................ 11

4.1. Les Structures ............................................................................................................................. 11

4.2. Les Tableaux ................................................................................................................................. 12

5. Instructions conditionnelles ...................................................................................................... 15

5.1. If … Then … Else … End If ......................................................................................................... 15

5.1.1. Forme simple : .............................................................................................................. 16

5.2. Select case … Case … Case … Case Else … End Select ......................................................... 18

6. Instructions répétitives ............................................................................................................ 19

6.1. For … To … Next .................................................................................................................... 19

6.2. Do While … Loop / Do … Loop While … .................................................................................... 20

6.3. Do Until … Loop / Do … Loop Until …........................................................................................ 21

6.4. For … Each … Next .......................................................................................................... 22

Mme. BOUGHAMMOURA Héla 2

ISET Mahdia Programmation évènementielle

Chapitre 2 : Les éléments de base de VB.Net

1. Variable et opérations arithmétiques

1.1. Notion de Variable

Les variables sont nécessaires pour stocker une valeur dynamique et réutilisable. C'est en
fait une simple zone mémoire qui porte un nom choisi par le programmeur. Le nom de la variable
est une adresse mémoire. Il faut déclarer chaque variable en précisant le type de celle-ci. La
déclaration se fait avec le mot réservé Dim.

Syntaxe :

Dim <NomVariable> As <Type>

Pour la lisibilité du code on peut les commenter après une apostrophe ( ‘ ).

En ce qui concerne les noms des variables, on peut utiliser des majuscules, minuscules et
chiffres. Les espaces et autres caractères spéciaux ne sont pas acceptés (accents, @, #). Le nom de
la variable ne peut pas commencer par un chiffre.
'Exemples de noms de variables
MaVariable 'est acceptée
COOL 'est acceptée
Je_Suis_1_Variable 'est acceptée
2Variable 'est refusée

2_Variable 'est refusée

The Variable 'est refusée
Différent 'est refusée

Pour utiliser une variable, il faut avant tout la déclarée et l'instancier. Pour cela on utilise le
mot clé " Dim " pour la déclarée et " new " pour 'instancier.

'Exemples de déclarations de variables

Dim Ma_Variable As String

Dim Nombre As Integer

Mme. BOUGHAMMOURA Héla 3

ISET Mahdia Programmation évènementielle

Dim Compteur As Integer

'Instancier des variables

Dim Msn As New Msn_Protocol ' Msn_Protocol est une class
Dim Test As New Class

Vous pouvez affecter des valeurs aux variables une fois qu’elles sont déclarées, comme montré
dans l’exemple suivant :

Dim birthday As Date

birthday = #3/9/1974#

Dim birthday As Date = #3/9/1974#

Dim goodNews As String = "Votre chèque est au courrier."

Dim testCondition As Boolean = True

Lorsque vous créez une variable à l’aide de l’instruction Dim, Visual Basic initialise
automatiquement les variables numériques sur 0, les chaînes de texte sur vide ("") et les variables de
type date sur Janvier 1, 0001.
1.2. Les différents types de variables

Le langage VB utilise plusieurs types de données dont les plus utilisés sont le type String
(chaîne de caractères), le type Integer (entier) et le type Single (décimal). Les types standards de
données en VB sont résumés dans le tableau ci-dessous.

Mémoire occupée Plage Utilisation principale

Type de variable

Pour les conditions

Boolean 2 octets
Byte 1 octet Pour les fichiers
Char 2 octets Pour les caractères
8 octets
Date Pour les dates
Decimal 16 octets Pour les nombres décimaux

Mme. BOUGHAMMOURA Héla 4

ISET Mahdia Programmation évènementielle

4 octets
Integer Pour les nombres entiers
Pour les entiers longs
Long 8 octets
2 octets
Short Pour les entiers courts
4 octets Pour les grands nombres à virgules
Single
(avec simple précision)
Variable
String Pour les chaînes de caractères

Tableau 2.1 : Les différents types de variables

1.3. Les opérateurs arithmétiques

Opérateur Description Exemples

+ ,- Addition et soustraction 12+34 ; 87.33 _ 456.66

* Multiplication 34*67

/ Division décimale 36 /25 = 1 .44

^ Puissance 5^3= 125

\ Division entière 36\25 = 1

MOD Modulo (reste de la division entière) 36 MOD 25 = 11

Tableau 2.2 : Les opérateurs arithmétiques

Si, dans une expression arithmétique plusieurs opérateurs sont utilisés, les priorités sont résolues
comme indiqué dans le tableau qui suit :
Opérateur Description Priorité

() Parenthèses 1

^ Puissance 2

- Négation 3

*,/ Multiplication, Division décimale 4

\ Division entière 5

MOD Modulo (reste de la division entière) 6

Mme. BOUGHAMMOURA Héla 5

ISET Mahdia Programmation évènementielle

+, - Addition et soustraction 7

Tableau 2.3 : Les priorités des opérateurs arithmétiques

1.4. Convertir des variables

Dans tous langages de programmation, il peut être utile de convertir des variables d'un type dans un
autre type. Cela permet d'éviter la création de nouvelles variables qui alourdiraient le programme.
Le tableau suivant résume les fonctions permettant de convertir les variables.

Fonction de conversion Convertir vers le type

CBool Boolean

CByte Byte

CChar Char

CDate Date

CDbl Double

CDec Decimal

CInt Integer

CLng Long

CObj Object

CShort Short

CSng Single

CStr String

Tableau 2.4 : Les fonctions de conversion du type d’une variable

Exemple :

Dim myDateString, myTimeString As String

Dim myDate, myTime As Date

myDateString = "Février 12, 1969"

myTimeString = "4:35:47 PM"

’ Convertit en type de données Date

myDate = CDate(myDateString)

Mme. BOUGHAMMOURA Héla 6

ISET Mahdia Programmation évènementielle

myTime = CDate(myTimeString)

Pour convertir un Object dans un type (String, Integer...), on utilise la commande 'CType'

CType(a, String) 'a va être convertit en 'String'

1.5. La portée des variables

1.5.1. Définitions

Une variable peut être utilisée que si elle est visible dans le programme. Pour définir le niveau de
visibilité de chaque variable, il existe un mot clé propre à chaque cas.

 Public : Partout dans le programme.

 Friend : Les membres Friend ne sont accessibles qu'à l'intérieur du projet, et pas par des
éléments extérieurs au projet en cours.
 Private : Partout dans la classe ou le module où elle a été créée.
 Dim : Seulement dans la procédure ou la fonction créée
 Protected : Les membres Protected sont similaires aux Private, mais ils ont une particularité
en cas d'héritage.

Module ou classe publique

Public A As Integer

Module ou classe Friend

Friend B As Date

Module ou classe Private

Private C As String

Procédure ou bloc

Dim D As Integer

Figure 2.1 : La portée des variables

La variable A est accessible à partir de n’importe quel projet de la solution.

La variable B est accessible n’ importe où dans le projet.

Mme. BOUGHAMMOURA Héla 7

ISET Mahdia Programmation évènementielle

La variable C est accessible n’ importe où dans le module.

La variable D est accessible uniquement dans la procédure ou le bloc.

1.5.2. Déclaration de variables locales

Les variables déclarées dans un bloc ou dans une procédure sont appelées variables locales, leur
portée sont donc limitée à la procédure ou au bloc dans lequel elles sont déclarées.

 Exemple de variable locale : au niveau du bloc

If x < > 0 then

Dim var as number

Var = x + 1

End

 Exemple de variable locale : au niveau de la procédure

Private Sub permutation ( valeur1 As Integer, valeur2 As Integer )

Dim variable As Integer

variable = valeur1

valeur1 = valeur2

valeur2 = variable

End Sub

La durée de vie d’une variable locale commence au moment où une procédure l’appelle et s’achève
lorsque celle-ci se termine. Une fois la durée de vie de la variable locale écoulée, l’instance de la
variable est détruite et sa valeur perdue.

1.5.3. Déclaration de variables statiques

Une variable statique survit tant que l’application s’exécute. Ces variables statiques demeurent en
vie et conservent leurs valeurs les plus récentes entre les appels faits à la procédure dans laquelle
elles sont déclarées. La déclaration d’une variable statique se fait à travers le mot clé static et sans
modificateur d’accès.
Syntaxe :

static <NomVariable> As <Type>

Exemple :
Sub AddItem_Click( )

Mme. BOUGHAMMOURA Héla 8

ISET Mahdia Programmation évènementielle

Static items As Integer

‘Ajouter 1 au compteur
items += 1

MessageBox.Show (" Le compte est actuellement de " & items)

End Sub

Les variables statiques sont utiles pour la mise à jour des compteurs utilisés exclusivement
au sein d’une procédure. L’exemple suivant montre comment déclarer une variable statique
enregistrant le nombre de fois que la procédure AddItem s’exécute. À chaque exécution, la valeur
stockée dans items est incrémentée de 1.

1.5.4. Déclaration de variables de module

Les variables qui ne sont pas déclarées dans une procédure, mais dans un module, une classe
ou une structure s’appellent des variables de module. Après avoir déclaré une variable de module,
vous pouvez lui affecter une valeur et lui assigner une portée par l’intermédiaire d’un modificateur
d’accès.
Exemple :
Private myModuleMessage As String

Friend myProjectMessage As String

Public mySolutionMessage As String

2. Déclaration des constantes

Pour déclarer une constante, utilisez l’instruction Const avec la syntaxe suivante :
Syntaxe :

Const NomConstant As Type

Exemple :

Dim surface, rayon, périmètre As Double

Const Pi As Double = 3.1415

surface = Pi * rayon ^ 2

périmètre = 2 * Pi * rayon

3. Les énumérations

Mme. BOUGHAMMOURA Héla 9

ISET Mahdia Programmation évènementielle

Une énumération va nous permettre de définir un ensemble des constantes qui sont liées entre elles.
La déclaration se fait de la manière suivante :

Enum jours
Dimanche
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
End Enum

Par défaut, la première valeur de l’énumérateur est initialisée à zéro. Les constantes suivantes sont
ensuite initialisées avec un incrément de un. La déclaration précédente aurait pu s’écrire :

Const Dimanche = 0
Const Lundi = 1
Const Mardi = 2
Const Mercredi = 3
Const Jeudi = 4
Const Vendredi = 5
Const Samedi = 6

La séquence d’incrémentation automatique dans une énumération peut être interrompue, voire ne
pas être utilisée comme dans l’exemple suivant :

Enum Taille
Ali = 156
Samia = 163
Saber = 173
Sofien = 187
End Enum

Il faut toutefois que les valeurs utilisées dans l’énumération soient des valeurs entières.

Une fois elle est définie, une énumération peut être ensuite être utilisée comme un type de
variable spécifique.

Dim T1 NomConstant As Taille

Les seules valeurs que vous pouvez affecter à votre variable Taille sont celles qui sont
définies dans l’énumérateur.

Mme. BOUGHAMMOURA Héla 10

ISET Mahdia Programmation évènementielle

T1 Taille.Joe

Console.WriteLine(T1)

4. Structure et tableaux
4.1. Les Structures
4.1.1. Déclaration de structures

Vous pouvez déclarer des structures dans un fichier source, à l’intérieur d’un module ou
d’une classe, mais pas dans une procédure.
Syntaxe :

<ModificateurAccès > Structure < NomDeLaStructure>

’ Déclarer les membres de la structure ici

End Structure

Vous devez déclarer chaque donnée membre d’une structure et spécifier pour chacune son
niveau d’accès. Ceci implique que chaque instruction située dans la section de déclaration des
variables de la structure utilise Dim, Friend, Private ou Public.
Il est impossible d’initialiser des données membres dans la déclaration de structure. En
déclarant une variable comme étant de type structure, vous affectez des valeurs aux membres alors
accessibles par l’intermédiaire de la variable.
Exemple :

Public Structure Employe

’ Membres Public, accessibles dans toute la région de déclaration

Public Nom As String

Public Prenom As String

’ Membres Friend, accessibles de n’importe quel endroit dans le même assembly

Friend Mobile As Integer

Friend Tel As Long

’ Membres Private, accessibles uniquement dans la structure elle-même

Private Salaire As Double

End Structure

Mme. BOUGHAMMOURA Héla 11

ISET Mahdia Programmation évènementielle

4.1.2. Utilisation de structures

Une fois la structure créée, vous pouvez déclarer des variables de niveau de procédure et de
niveau de module comme étant de type structure. Vous pouvez ensuite affecter des valeurs aux
membres de données de la structure des variables et écrire le code permettant d’utiliser les membres
de la structure.
Exemple :

Dim Employe_1 As Employe

Pour affecter et récupérer des valeurs à partir des différents éléments d’une variable de
structure, utilisez le nom de la variable que vous avez créée avec l’élément dans le bloc de la
structure. Séparez le nom de l’élément par un point.

Employe_1. Nom =”Ahmed”

Employe_1. Prenom =”Ben Salah”

Employe_1. Mobile =92 345 678

Employe_1. Tel =72 344 655

Employe_1. Salaire =900.567

4.2. Les Tableaux

Un tableau est une séquence d’éléments de données appartenant à un même type. Vous
pouvez accéder aux éléments individuels d’un tableau en utilisant le nom du tableau et un ou
plusieurs index (commençant à 0) pour spécifier la position de l’élément dans le tableau. Un tableau
peut présenter une ou plusieurs dimensions avec un ou plusieurs éléments dans chaque dimension.

4.2.1. Déclaration d’un tableau unidimensionnel

Vous déclarez un tableau en spécifiant les éléments suivants :

 Nom du tableau
 Taille (nombre d’éléments)
 Type de données des éléments du tableau
 Modificateur d’accès (si nécessaire)

Mme. BOUGHAMMOURA Héla 12

ISET Mahdia Programmation évènementielle

Syntaxe :

ModificateurAccès NomTableau(N) As Type

Cette instruction déclare un tableau NomTableau de taille N+1. Pour accéder au i ème élément du
tableau, il faut préciser l’indice entre parenthèses comme suit : NomTableau(i-1), i doit être compris
dans l’intervalle [0, N].
Vous pouvez déclarer des tableaux locaux au moyen de l’instruction Dim et en intégrant la
déclaration à l’intérieur d’une procédure. Pour créer un tableau public, utilisez le mot clé Public à la
place de Dim.
Exemples :

’ Déclarations d’un tableau local

Sub initialisation( )

’ Allouer 31 éléments (0) à (30)

Dim Tab(30) As Decimal
Dim number As Integer
For number = 0 to 30

Tab(number) = 100

Next number

End Sub

’ Déclarations d’un tableau public

Public entiers(14) As Integer

Public réels(20) As Double

Public entiers( ) As Integer = {1, 2, 3, 4, 5, 6, 7}

Public Grille ( , ) As Integer ={{1,2},{3,4}}

Mme. BOUGHAMMOURA Héla 13

ISET Mahdia Programmation évènementielle

4.2.2. Déclaration de tableaux multidimensionnels

Pour déclarer une variable de tableau multidimensionnel, ajoutez une paire de parenthèses
après le nom de la variable et utilisez des virgules à l’intérieur pour séparer les dimensions.

Syntaxe :

’ Tableau quadridimensionnel

Dim My4DArray(2, 6, 4, 1) As Integer

Exemples :

Dim 2DArray(3, 2) As Double

2DArray (2, 1) = 24

2DArray (2, 1) = 12

2DArray (2, 1) = 24

4.2.3. Redimensionnement des tableaux

Dans Visual Basic .NET, vous pouvez redimensionner un tableau à tout moment en lui
spécifiant une nouvelle grandeur. Vous pouvez même changer le nombre de dimensions du tableau.
Redimensionner les tableaux permet de gérer plus efficacement la mémoire. Vous pouvez par
exemple utiliser un grand tableau pour une courte durée et ensuite le réduire. En agissant ainsi, vous
libérez la mémoire dont vous n’avez plus besoin.
Syntaxe :

ReDim tableauExistant ( NouvelleGrandeur )

Mme. BOUGHAMMOURA Héla 14

ISET Mahdia Programmation évènementielle

Exemple :
Dim number, myArray( ) As Integer
’ Allouer 6 éléments
ReDim myArray(5)
For number = 0 to 5

’ Initialiser tableau
myArray(number) = number

Next number

’ Redimensionner à 11 éléments
ReDim myArray(10)
For number = 0 To 10

’ Initialiser tableau
myArray(number) = number

Next number

Lorsque vous redimensionnez (ReDim) un tableau, ses valeurs existantes sont normalement
perdues. Toutefois, vous pouvez les conserver en incluant le mot clé Preserve dans l’instruction
ReDim.
Exemple :

ReDim Preserve myArray(10)

Cette l’instruction alloue un nouveau tableau, initialise ses éléments à partir des éléments
correspondants de myArray existant et assigne le nouveau tableau à myArray.

5. Instructions conditionnelles

Les deux instructions conditionnelles le plus utilisées en VB sont : If Then et Select Case.

5.1. If … Then … Else … End If

Si la condition se trouvant après le mot réservé If est vraie, les instructions qui suivent le
mot réservé Then sont exécutées sinon, ce sont celles qui suivent le mot réservé Else qui sont
exécutées. L’instruction If se termine (obligatoirement) avec les mots réservés End If.

Mme. BOUGHAMMOURA Héla 15

ISET Mahdia Programmation évènementielle

5.1.1. Forme simple :

Syntaxe :

If condition(s) Then
Instruction11
Instruction12
Else
Instruction21
Instruction22
End If

Exemple :

If Moyenne >= 12 Then

Admis = Admis + 1

MsgBox(" Candidat admis ")

Else

Ajournés = Ajournés + 1

MsgBox(" Candidat ajourné ")

End If

5.1.2. Forme imbriquée

Syntaxe

If condition(s) Then
Instruction11
If condition Then
Instruction12
Else if condition Then
Instruction13
Else
Instruction14
End If
Else
Instruction21
Instruction22

End If

Exemple :

If NombreProposé > NombreATrouver Then

Mme. BOUGHAMMOURA Héla 16

ISET Mahdia Programmation évènementielle

MsgBox("Votre nombre est trop grand !")

ElseIf NombreProposé < NombreATrouver Then

MsgBox("Votre nombre est trop petit !")

Else

MsgBox("Gagné !")

End If

A. Les opérateurs de comparaison

Opérateur Signification Exemple Résultat

= Égal à 15 = 11 +4 true

> Supérieur à 15 > 11 true

< Inférieur à 11 = 15 false

<> Diddérent de 23 <> 23.1 true

>= Supérieur ou égale à 23 >= 23.1 false

<= Inférieur ou égale à 23 <= 23.1 true

Tableau 2.5 : Les opérateurs de comparaison

Si plusieurs conditions doivent être testées, celles-ci doivent être combinées avec des opérateurs
logiques. VB accepte les opérateurs logiques suivants: AND, OR, NOT et XOR. La signification de
chacun d’eux est présentée dans le tableau qui suit:
Opérateur Signification Exemple Résultat
AND Connexion ET. Il faut que ( 1 = 1) AND (2 < 4) True
les conditions soient ( 1 > 2) AND (2 = 4) False
vraies pour que le résultat
soit vrai
OR Connexion OU. Il faut que ( 1 = 2) OR (3 < 2) False
l’une des deux ( 1 > 2) OR (2 > 1)
True
conditions soit vraie pour
que le résultat soit vrai
NOT Connexion NON. La valeur EstCeVrai True
logique est inversée. NOT EstCeVrai
False

XOR Connexion OU exclusif. ( 1 = 1) XOR (2 = 2) False

Une seule des deux ( 2 > 1) XOR (3 < 1) True
conditions doit être vraie
pour que le résultat soit
vrai

Mme. BOUGHAMMOURA Héla 17

ISET Mahdia Programmation évènementielle

Tableau 2.4 : Les opérateurs logiques

5.1.3. IIf (Condition, ValeurSiVrai, ValeurSiFaux)

Syntaxe :
IIf (Condition, ValeurSiVrai, ValeurSiFaux)

Exemple :
Dim Note As Single

Dim Réponse As String

Note = InputBox (" Tapez votre note ")

Réponse = IIf (Note >= 10, " Admis ", " Ajourné ")

MsgBox (Réponse)

5.2. Select case … Case … Case … Case Else … End Select

L’instruction Select Case est une instruction conditionnelle alternative, c’est-à-dire qu’une
expression peut être testée par rapport à plusieurs valeurs possibles.

Syntaxe :

Select Case expression

Case Liste_Valeurs_1

Instruction11

Instruction12

Case Liste_Valeurs_2

Instruction21

Case Else

InstructionElse1

InstructionElse2

End Select

Mme. BOUGHAMMOURA Héla 18

ISET Mahdia Programmation évènementielle

Les instructions se trouvant après Case Liste_Valeurs_i seront exécutées si ‘expression = à l’un des
éléments de Liste_Valeurs_i, i = 1, 2, 3, …. Sinon, les instructions se trouvant après Else Case seront
exécutées. Liste_Valeurs_i peut être :

 une suite de valeurs : 1, 3, 5, 7, 9

 une fourchette de valeur : 0 To 9
 une plage de valeur : Is >= 10 (Is est un mot réservé)

Exemple 1

Select Case CodeASCIICaractère

Case 65, 69, 73, 79, 85

MsgBox(" C’est une voyelle ")

Case 66 To 90

MsgBox(" C’est une consonne ")

Case Else

MsgBox(" Ce n’est pas une lettre ")

End Select

Notez que Liste_Valeurs_i peut être une combinaison de listes de valeurs comme dans le cas des
exemples suivants :
Case 1 To 4, 7 To 9, 11, 13, Is > NombreMAx

Case "Lundi", "Mercredi", "Dimanche", VariableJour

6. Instructions répétitives

Les instructions répétitives sont utilisées pour boucler sur une suite d’instructions.
6.1. For … To … Next

Si le nombre de boucles est connu à l’avance, on utilise l'instruction For … To … Next.

Syntaxe

For Compteur = Début To Fin [Step Incrément]

Instructions

[ ... Exit For] ‘ pour une interruption préalable de la boucle

[Instructions]

Next [Compteur] ‘ le mot Compteur est facultatif

Mme. BOUGHAMMOURA Héla 19

ISET Mahdia Programmation évènementielle

Exemple :

Dim i As Integer

Dim Chaîne As String

Dim TabInitial(1 To 12) As Single

For i = 1 To 12

Chaîne = InputBox("Température N° " & Compteur)

TabInitial(i) = Chaîne

Next i ‘le i n’est pas obligatoire

6.2. Do While … Loop / Do … Loop While …

6.2.1. Test antérieur

Syntaxe

Do While Condition
Instructions
[... Exit Do]
[Instructions]
Loop

La condition est ici testée au début, c'est-à-dire à l’entrée de la boucle. Avec While (tant que), la
boucle est répétée tant que la condition est vraie. Si la condition n’est pas vraie au départ, les
instructions de la boucle ne sont pas exécutées.
Exemple

Do While MotProposé <> MotDePasse

MotProposé = InputBox("Donnez votre mot de passe")
Loop

Cela présuppose que MotProposé soit initialisé par une valeur autre que MotDePasse (par exemple,
la valeur par défaut "").

6.2.2. Test postérieur

Syntaxe

Do
Instructions
[... Exit Do]
[Instructions]
Loop While Condition
La condition est alors testée à la fin de la boucle. Avec While (tant que), la boucle est répétée tant
que la condition est vraie. Les instructions de la boucle sont donc exécutées au moins une fois.

Exemple

Mme. BOUGHAMMOURA Héla 20

ISET Mahdia Programmation évènementielle

Do
MotProposé = InputBox("Donnez votre mot de passe")
Loop While MotProposé <> MotDePasse

6.3. Do Until … Loop / Do … Loop Until …

6.3.1. Test antérieur

Syntaxe :

Do Until Condition
Instructions
[... Exit Do]
[Instructions]
Loop

La condition est ici testée au début, c'est-à-dire à l’entrée de la boucle. Avec Until (jusqu'à), la
boucle est répétée jusqu'à ce que la condition soit vraie. Si la condition est vraie au départ, les
instructions de la boucle ne sont pas exécutées.
Exemple

Do Until MotProposé = MotDePasse

MotProposé = InputBox("Donnez votre mot de passe")

Loop

6.3.2. Test postérieur

Syntaxe :

Do
Instructions
[... Exit Do]
[Instructions]
Loop Until Condition

La condition est alors testée à la fin de la boucle. Les instructions de la boucle sont donc exécutées
au moins une fois. Avec Until (jusqu'à), la boucle est répétée jusqu'à ce que la condition soit vraie.
Exemple :

Do
MotProposé = InputBox("Donnez votre mot de passe")
Loop Until MotProposé = MotDePasse

Mme. BOUGHAMMOURA Héla 21

ISET Mahdia Programmation évènementielle

6.4. For … Each … Next

C’est une extension de la boucle For ... To … Next.

Syntaxe:

For Each Elément In Ensemble

Instructions
[ ... Exit For]
[Instructions]
Next [Elément]

Exemple :

Dim TabHasard(100) As Integer

Dim Cellule As Integer

Dim Réponse As String

Randomize ‘initialise le générateur de nombres au hasard

For Each Cellule In TabHasard

Cellule = Rnd * 100 + 1 ‘génère un nombre au hasard entre 1 et 100

Next

For Each Cellule In TabHasard

Réponse = Réponse & Cellule & " " ‘Concaténation de chaînes de caractères
Next

MsgBox (Réponse)

Mme. BOUGHAMMOURA Héla 22