Cours Visual Basic :variables, opérateurs de base et boucles
VBA ou VB ou Visual Basic
Boîte à outils
La boîte à outils est une palette d'objets développeur, ou de contrôles, qui sont placées sur les formulaires ou pages web, puis le code est ajouté pour permettre à l'utilisateur d’interagir avec eux. Un exemple sont les contrôles TextBox, Button et ListBox, avec lesquels le développeur peut autoriser des acquisitions de l'utilisateur dans application, par exemple entrer un texte puis l'ajouter à une liste sur pression d'un bouton.
Explorateur de solutions
Cette section permet de voir et modifier les contenus du projet. Un projet Visual Studio Application
Windows Forms contient généralement un formulaire avec une page de code associée, avec potentiellement des composants et modules de code employés par l'application.
Fenêtre propriétés
La fenêtre propriétés montre les propriétés des contrôles (comme les TextBox) changeable lors du design. La plupart peuvent aussi être déclenchées par du code, mais basiquement elles changent l'affichage du contrôle dans l'application.
Explorateur d'objets
En pressant F2 ou en le choisissant dans le menu View menu, il est possible d'explorer tous les objets des bibliothèques (types, fonctions...).
Vue du code ou design
Cette vue permet d'afficher sur plusieurs onglets les formulaires tels que les verront les utilisateurs, et le code. C'est ici que l'on dispose les objets sélectionnés dans la boîte à outils.
Raccourcis clavier
Tout comme en Visual Basic :
F5 exécute le code. F8 le fait en pas à pas.
Remarque : en cliquant dans la marge il est possible de définir des "points d’arrêt", qui stopperont l'exécution du programme jusqu'à ce qu'on lui demande de la continuer.
Premier script
Application Windows Forms
Pour commencer à programmer en Visual Basic .NET, lancer l'interface choisie dans le premier chapitre et créer un nouveau projet de type Application Windows Forms.
Double-cliquer sur le formulaire vierge pour faire apparaitre son code dans un autre onglet, qui doit être une classe vierge :
Public Class Form1
Inherits System.Windows.Forms.Form
[Windows Form Designer generated code]
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Ha
End Sub End Class
Y ajouter la ligne suivante dans la fonction Form_Load (entre les lignes Private Sub et End Sub) :
MessageBox.Show("Hello World!")
En pressant F5 ou en cliquant dans le menu Debug sur Démarrer le programme, cela devrait afficher une boite contenant le message "Hello World!", qui si on clique dessus laisse place au formulaire vierge. On peut le fermer ensuite avec le bouton de croix en haut à droite.
Application console
Ajouter un projet via le menu File, puis New, et Project... puis sélectionner Application console. Ajouter dans la fonction Main() :
Console.WriteLine("Hello World!") Console.ReadLine()
Pour que l'exécution du programme ne déclenche plus le formulaire du paragraphe précédent, mais la console à la place, effectuer un clic droit sur la nouvelle ConsoleApplication1 dans l’Explorateur de solutions, puis Définir comme projet de démarrage.
Ensuite en pressant F5 la console se lance.
Les Variables :
Variables (1)
Déclaration de variables
En Visual Basic .NET, les variables sont déclarées avec la commande Dim (de l'anglais dimension). Voici la syntaxe :
Dim NomVariable As TypeVariable
NomVariable est le nom de la variable (le plus explicite possible).
TypeVariable est son type de données (ex : string, integer, double, boolean, etc.). Par exemple, pour déclarer un nombre entier :
Dim NomNombre As Integer
Par défaut, la casse des variables ne permet pas de les distinguer, ainsi nomnariable sera automatiquement convertie en NomVariable par l'IDE si elle est déclarée comme telle.
Par contre, pour que le programme ignore la casse dans les valeurs chaines de caractères, il faut définir Option Compare Text.
Option Compare Text ' En commentant cette ligne le résultat devient False
Module Module1
Sub Main()
Dim chaine1 As String = "a" Dim chaine2 As String = "A" MsgBox(chaine1 = chaine2)
End Sub
End Module
...
Utiliser les variables
Assignation
'Les valeurs sont assignées aux variables par le signe égal.
Suffixe pour les nombres littéraux
Les nombres intégralement littéraux comme 42 et 1000, sont de type Integer par défaut. Les chaines et caractères littéraux, comme "Hello World!" et "A", sont de type String.
Pour spécifier le type d'un littéral, on utilise donc les suffixes. Ces derniers sont accolés immédiatement après les littéraux (sans espace), comme ceci : <littéral><suffixe>.
Exemples
Les chaines de caractères doivent être entre guillemets pour ne pas être considérées comme des noms de variables :
strNomVariable = "Une chaine" chrNomVariable = "À"
Pour les variables dates, utiliser des croisillons autour de la valeur, au format #<jour>/<mois>/<année> <heure>:<minute>:<seconde> <AM|PM>#:
dtNomVariable = #14/07/1789 12:01:50 PM#
Pour tous les autres, ne pas entourer les valeurs :
bytNomVariable = 1 sbytNomVariable = -2 shrtNomVariable = 10S ushrtNomVariable = 10US intNomVariable = 100 uintNomVariable = 100UI lngNomVariable = 1000L ulngNomVariable = 1000UL sngNomVariable = 1.234F dblNomVariable = 1.567R decNomVariable = 1234567.89D boolNomVariable = True objNomObjet = New Object
Valeur initiale
Il est possible d'assigner une valeur à une variable pendant sa déclaration :
Dim NomVariable As String = "Valeur de la chaine"
Visual Basic assigne toujours la valeur de droite dans la variable à gauche du signe égal, sans modifier la première.
Constantes
Les constantes sont considérées comme des variables qui ne changent pas. Elles sont déclarées avec le mot clé Const, et leurs valeurs sont définies durant leur déclaration :
Const cnstNomConstante As String = "Longue chaine de caractères"
Exemple :
Const cnstPi As Single = 3.14159265F
Pour convertir des radians en degrés on peut créer la constante 180/Pi :
Const cnstRadDeg As Single = 57,29579143 ...
Degres = Radians / cnstRadDeg
Cette constante serait utile aux fonctions Sin, Cos, Tan, Arctan, etc.
Tableaux
Tableaux à une dimension : les listes
Le type du tableau est imposé à tous ses éléments (un tableau Integer ne pourra stocker que des entiers). Voici un tableau de taille six (d'indice 0 à 5) :
Dim NomTableau(5) As Integer
Cette déclaration engendre la création de cet objet :
Index Données 00 Nothing
01 Nothing
02 Nothing
03 Nothing
04 Nothing
05 Nothing
Que l'on peut parcourir ainsi : NomTableau(0), NomTableau(1),..., NomTableau(10).
Pour assigner des valeurs pendant la déclaration on crée une instance de la classe du type (ici Integer) :
Module Module1
Sub Main()
Dim NomTableau() As Integer = New Integer(4) { 1, 2, 3, 4, 5 }
' Affichage du tableau déclaré
For ligne = 0 To UBound(NomTableau)
Console.WriteLine(NomTableau(ligne))
Next
Console.ReadLine()
End Sub
End Module
Voici un autre exemple avec une instance de String dont les valeurs sont attribuées ensuite :
Dim NomTableau As System.Array
NomTableau = System.Array.CreateInstance(GetType(String), 4)
NomTableau(0) = "a"
NomTableau(1) = "b"
NomTableau(2) = "c"
NomTableau(3) = "d"
' Affichage du tableau déclaré
For ligne = 0 To NomTableau.Length Console.WriteLine(NomTableau(ligne)) Next
Console.ReadLine()
Pour afficher tous les éléments du tableau d'un coup on utilise un énumérateur :
Dim En As System.Collections.IEnumerator
Dim NomTableau As System.Array
NomTableau = System.Array.CreateInstance(GetType(String), 4)
NomTableau(0) = "a"
NomTableau(1) = "d"
NomTableau(2) = "b"
NomTableau(3) = "c"
' Affichage du tableau déclaré En = NomTableau.GetEnumerator Do While En.MoveNext
Console.WriteLine(En.Current()) Loop
Console.WriteLine("Presser entrée pour continuer...") Console.ReadLine()
Classer le tableau :
Dim NomTableau As System.Array
Dim En As System.Collections.IEnumerator
NomTableau = System.Array.CreateInstance(GetType(String), 4)
NomTableau(0) = "a" NomTableau(1) = "d" NomTableau(2) = "b" NomTableau(3) = "c" En = NomTableau.GetEnumerator
Console.WriteLine("Avant classement")
Do While En.MoveNext
Console.WriteLine(En.Current())
Loop
Array.Sort(NomTableau)
En = NomTableau.GetEnumerator
Console.WriteLine("Après classement")
Do While En.MoveNext
Console.WriteLine(En.Current())
Loop
Console.WriteLine("Presser entrée pour continuer...") Console.ReadLine()
Classer le tableau par ordre décroissant :
...
Tableaux à plusieurs dimensions
On peut déclarer des tableaux 2D, 3D, 4D etc.
' Tableau 2D aux coordonnées (X, Y) Dim NomTableau2D(2, 2) As Integer
Cela génère cet objet :
Index Data
0, 0 Nothing 0, 1 Nothing 0, 2 Nothing
1, 0 Nothing
1, 1 Nothing
1, 2 Nothing
2, 0 Nothing
2, 1 Nothing
2, 2 Nothing
Pour le parcourir on peut utiliser des boucles imbriquées, ou bien un énumérateur :
Le résultat sera :
Presser entrée pour continuer...
Méthodes de manipulation de tableaux
Split() : pour transformer une chaine de caractères en tableau, selon le séparateur placé en paramètre. Join() : convertit un tableau en chaine.
Filter() : filtre les entrées d'un tableau.
Exemple :
Module Module1
Sub Main()
Dim NomTableau() As String = Split("lorem ipsum dolor sit", " ") Console.WriteLine(NomTableau(1)) ' affiche "ipsum"
NomTableau(4) = "amet"
Dim ContenuTableau As String = String.Join(" ", NomTableau) Console.WriteLine(ContenuTableau)
Dim SousTableau = Filter(NomTableau, "o", True, CompareMethod.Text) Console.WriteLine(String.Join(" ", SousTableau)) ' affiche les mots contenant des "
Console.ReadLine() End Sub
End Module
…
Conditions
Conditions
Liste des conditions :
If...Else...EndIf
Soit les variables et les assertions suivantes :
Dim Entier1 as Integer = 4 Dim Entier2 as Integer = 7
MsgBox(Entier1 = 4) ' affiche True MsgBox(Entier1 = 5) ' False
MsgBox(Entier1 > 7) ' True
MsgBox(Entier1 < Entier2) ' True
If Entier1 = 4 Then MsgBox("Entier1 n'a pas changé")
S'il y a plusieurs instructions derrière le Then, il est obligatoire de leur allouer une ligne chacune, puis de terminer la condition par un End if :
If Entier1 = 4 Then
Entier1 = Entier1 + 3 ' Entier1 = 7
Entier2 = Entier2 + 1 ' Entier2 = 8
End if
Si des instructions doivent s'appliquer quand la condition n'est pas vérifiée, utiliser Else :
IF Entier1 = 4 Then
(exécute le code True) Else
(exécute le code False) End if
If Not Entier1 = 4 Then ' avec une clause "not"
(exécute le code True) ' si Entiers1 est différent de 4
Else
(exécute le code False) ' si Entiers1 = 4
End if
Attention à bien prioriser avec des parenthèses :
If Not Entier1 = 3 Or Entier2 = 7 Then MsgBox("Entier1 est différent de 3 et Entier2 = If Not (Entier1 = 3 Or Entier2 = 7) Then MsgBox("Entier1 est différent de 3 et Entier2
If...ElseIf...Else...EndIf
If/ElseIf permet de tester plusieurs conditions dans l'ordre séquentiel programmé. Exemple :
Dim x As Integer Dim y As Integer '...
If x = y Then
MsgBox("x = y") ElseIf x < y Then
MsgBox("x < y") Else
MsgBox("x > y") End If
Select Case
Ce procédé permet de raccourcir la syntaxe de longues chaines If/ElseIf/.../ElseIf/Else. Il décrit en effet les différentes valeurs d'une variable (nombres ou chaines de caractères) :
Dim CPU as Integer
Select Case CPU
Case 0
MsgBox "Aucun processeur"
Case 1
MsgBox "Un processeur"
Case 2
MsgBox "Deux processeurs"
Case 4
MsgBox "Quatre processeurs"
Case 3, 5 To 8
MsgBox "3, 5, 6, 7, ou 8 processeurs"
Case Else
MsgBox "> 8 processeurs"
End Select
Opérateurs booléens
Les opérateurs booléens en Visual Basic .NET peuvent être testés tels quels, sans fonction isTrue() que l'on peut trouver dans d'autres langages. Par exemple :
functionA() and functionB()
Dans cette instruction le circuit court fait en sorte que la seconde fonction ne s'exécute que si la première renvoie True.
L'ordre des conditions est donc important pour optimiser la vitesse du programme.
Outre les opérateurs compatibles avec les précédentes version de Visual Basic, il existe ceux-ci :
Not And Or Xor
Plus deux utilisant les circuits courts d'évaluation :
AndAlso OrElse
Boucles
Il existe plusieurs structures de boucles en VB.NET.
Boucle Do...Loop Until
Un Do...Loop Until est une boucle qui itère tant que sa condition de sortie est fausse, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.
Dim Entier1 As Integer = 4 Do
Entier1 = Entier1 + 1 Loop Until Entier1 > 3
…
MsgBox(Entier1) ' 5
Boucle Do...Loop While
Une boucle Do...Loop While tourne tant que sa condition d'itération est vraie, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.
Dim Entier1 As Integer = 4 Do
Entier1 = Entier1 + 1 Loop While Entier1 < 3
MsgBox(Entier1) ' 5
Boucle Do Until...Loop
Un Do Until...Loop est une boucle qui itère tant que sa condition de sortie est fausse (comme Do Until...Loop), cette dernière est testée à chaque début de boucle, donc le programme n'y passe pas forcément.
Dim Entier1 As Integer = 4 Do Until Entier1 > 3
Entier1 = Entier1 + 1
Loop
MsgBox(Entier1) ' 4
Boucle Do While...Loop
De la même manière, Do While...Loop tourne tant que sa condition d'itération est vraie (comme Do Until...Loop) et la teste en amont de chaque boucle.
Dim Entier1 As Integer = 4 Do While Entier1 < 3 Entier1 = Entier1 + 1 Loop
MsgBox(Entier1) ' 4
Boucle For
Une boucle For s'exécute un certain nombre de fois, relativement prédéfinie car la valeur du compteur peut changer en cours de rouge.
Dim Entier1 As Integer = 4 For a = 1 To 10
Entier1 = Entier1 + 1 Next
MsgBox(Entier1) ' 14
Cet exemple s'exécute 10 fois, a = 1, puis 2... puis 10.
Pour changer le sens du compteur :
For a = 10 To 1 Step -1 Entier1 = Entier1 + 1 Next
MsgBox(Entier1) ' 14
S'exécute aussi 10 fois, mais a = 10, puis 9... puis 1.
Remarque : à tout moment il est possible de sortir de la boucle sans attendre sa fin avec Exit for.
Boucle For Each
Une boucle For Each itère pour chaque entrée d'un tableau ou autre objet itérable, qui doit implémenter les interfaces IEnumerable ou IEnumerator. L'implémentation de IList par Array autorise un tableau à être utilisé comme un objet, car IList hérite de IEnumerable.
Dim Liste As Integer() = { 1, 2, 4 }
Dim Ligne As Integer
For Each Ligne In Liste
MsgBox(Ligne) ' affiche 1, puis 2, puis 4
Next
Assignation et comparaison
Assignation
L'opérateur "=" sert pour l'affectation et la comparaison. Pour définir une variable :
x = 7 ' x est à présent égal à sept
x = -1294
x = "exemple"
Comparaison
Pour comparer deux valeurs (constantes ou variables) :
If 4 = 9 Then
End ' sortie du programme
End If
If 1234 = 1234 Then
MsgBox("1234 est identique à 1234 !")
End If
MsgBox("Sept égal deux est " & (7 = 2) & ".") ' False
Programmation Visual Basic .NET/Version imprimable — Wikilivres …...
MsgBox("Sept égal sept est " & (7 = 7) & ".") ' True
Cas particulier : plusieurs signes égaux consécutifs :
Dim x As Boolean x = 2 = 7
Le second opérateur sera exécuté en premier, renvoyant False, puis l'assignation de x à False.
Autres opérateurs de comparaison
(x <> y) ' Différent (x < y) ' Inférieur (x > y) ' Supérieur (x <= y) ' Inférieur ou égal (x >= y) ' Supérieur ou égal
Arithmétique
Opérateurs arithmétiques
Visual Basic .NET fournit différent opérateurs arithmétiques :
Exemple (le séparateur décimal est le point contrairement en français où on utilise la virgule) :
Dim Commission As Single
Dim Ventes As Single
Ventes = 3142.51
Commission = 0.3 * Ventes ' Calcule 30 ô de commission.
MsgBox(Commission) ' 942,753
Remarque : ces symboles sont les mêmes que dans la calculatrice scientifique Windows.
Addition
x = 7 + 2 ' 9
x = 25 + -4 ' 21
Dim Chaine As String
Chaine = "Chaine1" + "Chaine2" ' Chaine1Chaine2
L'opérateur "+=" incrémente la variable d'une valeur donnée :
Dim x As Integer = 54
x += 89 ' 143
x += 7 ' 150
Il fonctionne aussi en concaténation :
Dim x As String = "Un renard"
x += " saute" ' Un renard saute
x += " la barrière" ' Un renard saute la barrière
Soustraction
"-" soustrait deux nombres :
Dim x As Integer
x = 7 - 2 ' 5
x = 25 - -4 ' 29
Multiplication
Le symbole est l'étoile :
Dim x As Integer
x = 7 * 2 ' 14
x = 25 * -4 ' -100
Division
Il existe plusieurs types de divisions. Division standard Opérateur "/" :
Dim x As Single ' Type acceptant les nombres décimaux
Chaines de caractères
Joindre des chaines de caractères
Concaténation
L'opérateur "&" joint deux chaines ensemble :
Dim Chaine1 As String = "123"
Dim Chaine2 As String = "456"
Dim Chaine3 As String
Chaine3 = Chaine1 & Chaine2 ' 123456.
L'opérateur "+" peut être utilisé à la place de "&", mais non recommandé pour éviter la confusion avec les additions.
Concat()
La méthode String.Concat() est une alternative à l'opérateur :
Cela fonctionne aussi avec les tableaux :
Dim TableauChaines As String() = {"1", "2", "3", "4", "5"} Resultat = String.Concat(TableauChaines) ' 12345
Méthodes sur les chaines de caractères
Lcase() : convertit en bas de casse. Ucase() : convertit en haut de casse.
Pour créer des sous-chaines, il existe toujours les fonctions VB6 :
Left() : partie de gauche. Right() : partie de droite. Mid() : partie du milieu. InStr() : emplacement d'une chaine sans une autre. Replace() : remplace une sous-chaine par une autre.
Sub Main()
Dim NomChaine As String = "lorem ipsum dolor sit amet" NomChaine = NomChaine.Replace("i", "o") Console.WriteLine(Mid(NomChaine, InStr(NomChaine, " "), 6)) Console.ReadLine() ' Affiche " opsum"
End Sub
Logique
Opérateurs logiques
Not
L'opérateur Not renvoie True quand la condition est False sinon False :
...
Gestion d'exception
Levées d'exception
Pour éviter que des erreurs bloquent l'exécution du programme il est possible de définir un comportement quand elles surviennent.
On Error GoTo
La méthode utilisée en VBA est toujours disponible. Celle-ci n'était pas structuré car fait appel à un Goto vers une étiquette :
Public Sub Main()
On Error GoTo Etiquette1
Dim Resultat As Integer = 2
Dim a = 1
Dim b = 0
Resultat = a / b ' Division par zéro
Etiquette1:
MessageBox.Show(Resultat) ' renvoie 2
End Sub
Pour éviter d'avoir à définir des étiquettes on peut tout simplement ignorer les erreurs un moment (puis les réactiver avec On Error GoTo 0 :
On Error Resume Next
Dim Resultat As Integer = 2
Dim a = 1
Dim b = 0
Resultat = a / b
On Error GoTo 0
MessageBox.Show(Resultat)
Try...Catch...Finally
Le gestionnaire d'erreur structuré s'appelle Try...Catch...Finally[1]. De nombreux types d'erreur y sont disponible par héritage de la classe Exception.
Public Sub Main()
Dim Resultat As Integer = 2 Dim a = 1 Dim b = 0 Try
Resultat = a / b
Catch ex As Exception
MsgBox(ex.ToString) Finally
MessageBox.Show(Resultat) End Try
End Sub
Remarque : pour relancer une exception dans un bloc Catch, utiliser le mot clé Throw sans argument. En effet il reset la propriété .StackTrace de l'objet exception en cas d'argument[2].
