Chapitre - 2-Les Éléments de Base de

Chapitre 2 : Les éléments de base de VB.
Net
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.
1
Volume horaire
4 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
2
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
3
Chapitre 2 :Les éléments de base de VB.Net
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.
Plage Utilisation principale

Type de variable Mémoire occupée
Pour les conditions

Boolean 2 octets
Byte 1 octet Pour les fichiers
Char 2 octets Pour les caractères
Date
8 octets Pour les dates
Decimal 16 octets Pour les nombres décimaux
4
Integer
4 octets 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
5
+, - 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)
6
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.
7
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( )
8
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
9
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.
10
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
11
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)
12
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}}
13
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 )
14
Exemple :
Dim number, myArray( ) As Integer
’ Allouer 6 éléments
ReDim myArray(5)
For number = 0 to 5
’ Initialiser tableau
myArray(number) = 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
End If.
réservé Else qui sont
exécutées. L’instruction If se termine (obligatoirement) avec les mots réservés
15
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
16
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
lesconditions 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
17
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
18
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
19
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
20
Do
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
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
Loop Until MotProposé = MotDePasse
21
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)
22

Chapitre - 2-Les Éléments de Base de

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre - 2-Les Éléments de Base de

Transféré par

Droits d'auteur :

Formats disponibles

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

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

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

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

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

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

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

1. Variable et opérations arithmétiques

1.1. Notion de Variable

Dim <NomVariable> As <Type>

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

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

'Exemples de déclarations de variables

Dim Ma_Variable As String

Dim Nombre As Integer

Dim Compteur As Integer

'Instancier des variables

Dim Msn As New Msn_Protocol ' Msn_Protocol est une class

Dim Test As New Class

Dim birthday As Date

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

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

Dim testCondition As Boolean = True

Plage Utilisation principale

Pour les conditions

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

/ 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

*,/ Multiplication, Division décimale 4

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

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

1.4. Convertir des variables

Fonction de conversion Convertir vers le type