La rupture de séquence
Bien que l’usage des branchements de type "Aller à" (Goto) soit à bannir, voici l’illustration de l’emploi de ces instructions.
Private Sub Branchement()
MessageBox.Show("Message 1")
GoTo Etiq1 ' Branch. incond. à Etiq1
Etiq2:
MessageBox.Show("Message 4")
GoTo Etiq5 ' Retour après Goto Etiq2
Etiq1:
MessageBox.Show("Message 2")
GoTo Etiq3 ' Branch. incond. à Etiq3
Etiq4:
MessageBox.Show("Message 5") Exit Sub ' Fin de procédure
Etiq3:
MessageBox.Show("Message 3")
GoTo Etiq2 ' Branch. incond. à Etiq2
Etiq5:
GoTo Etiq4 ' Retour après Goto Etiq3
End Sub
Spaghetti ?
Si l’usage d’alternatives bien construites et d’itérations judicieusement organisées permet de créer du code sans rupture de séquence, il est toutefois pratique, par facilité, de briser certains déroulements de traitements notamment par l’emploi des instructions :
Exit Do Exit For Exit Function Exit Sub
Les étiquettes (Etiq1, Etiq2, …) doivent être placées en première colonne du code (pas de retrait, pas d'indentation, pas d'espace).
L’alternative
Condition Condition
Action(s)
Le contrôle d’une alternative se réalise toujours par l’évaluation d’une condition. Plusieurs alternatives peuvent être assemblées en cascades ou imbriquées pour réaliser des choix complexes.
If Condition_réalisée Then Action
If Condition_réalisée Then Action1 Else Action2
Meilleure écriture : If Condition_réalisée Then Action(s)_contrôlée(s) End If If Condition_réalisée Then Action(s)_contrôlée(s) Else Autre(s)_action(s)_contrôlée(s) End If Action(s) contrôlée(s) contrôlée(s) Action(s) contrôlée(s) 1 2
If Total > 50 Then Console.WriteLine("Trop cher")
If Total > 50 Then Console.Write("Trop cher ") Else Console.Write("Prix OK ")
Meilleure écriture : If Total > 50 Then Console.WriteLine("Trop cher") End If If Total > 50 Then Console.Write("Trop cher ") Else Console.Write("Prix OK ") End If
Les alternatives, comme toutes les structures de contrôles, peuvent être imbriquées. Cela signifie qu’une ou plusieurs actions contrôlées peuvent elles-mêmes être des alternatives. Les alternatives peuvent également être assemblées en cascades. L’usage de plusieurs alternatives permet l’évaluation de plusieurs conditions.
If Total > 50 Then ' Il doit y avoir autant de End If que de If
If Remise = 0.50 then Total = Total * 0.50 Console.WriteLine("Prix OK") else Console.WriteLine("Trop cher") End If Else Console.WriteLine("Prix OK") End If
If NombreCote = 3 Then ' Il doit y avoir autant de End If que de If
Console.WriteLine("Triangle") Else If NombreCote = 4 Then Console.WriteLine("Quadrilatère") Else If Heure = 16 Then Console.WriteLine("Post meridian") End If End If End If
Pour ce dernier exemple, la forme suivante est meilleure car plus lisible et ne nécessitant qu’un seul End If :
If NombreCote = 3 Then ' Un seul End If car un seul If
Console.WriteLine("Triangle") ElseIf NombreCote = 4 Then
Console.WriteLine("Quadrilatère") ElseIf Heure = 16 Then
Console.WriteLine("Post meridian") End If
If Choix = 1 Then ' Toutes les conditions évaluent les différentes
Console.WriteLine("Saisie") ' valeurs possibles d’une même variable
ElseIf Choix = 2 Then
Console.WriteLine("Calcul ") ElseIf Choix = 3 Then
Console.WriteLine("Affichage") ElseIf Choix = 0 Then
Console.WriteLine("Fin") Else
Console.WriteLine("Mauvais choix") End If
La sélection
La sélection est une forme élaborée de l’alternative qui remplace avantageusement toute cascade d’alternatives, chacune vérifiant sa condition sur une seule et même variable commune.
Select Case Heure Case 8 To 12 Console.WriteLine("Matin") Case 13 To 18 Console.WriteLine("Après-midi") Case 19 To 22 Console.WriteLine("Soir") Case 22 To 24 , 0 To 7 Console.WriteLine("Nuit") Case Else Console.WriteLine("Heure invalide !") End select Condition 1 sur variable v Action(s)
Ce schéma au tracé simplifié exprime très bien la sélection sur les valeurs de v.
Select Case Choix Case 1 Console.WriteLine("Saisie") Case 2 Console.WriteLine("Calcul ") Case 3 Console.WriteLine("Affichage") Case 0 Console.WriteLine("Fin") Case Else Console.WriteLine("Mauvais choix") End Select
Outre d’admettre des valeurs discrètes comme dans l’exemple ci-dessus, la sélection en VB autorise aussi l’indication de plages de valeurs.
contrôlée(s) Action(s) contrôlée(s) 1 2 Condition 2 sur variable v Condition … sur variable v Condition n Action(s) contrôlée(s) … sur variable v Action(s) contrôlée(s) n Action(s) sur imprévus Action(s) contrôlée(s) Action(s) contrôlée(s) 1 2 Action(s) contrôlée(s) … Action(s) contrôlée(s) n Action(s) sur imprévus Selon valeur de v 1 2 … n autres
Les itérations
Les codes contrôlés par une itération sont exécutés plusieurs fois, soit jusqu’à ce qu’une condition prédéterminée d’arrêt soit réalisée, soit un nombre prédéterminé de fois. Il s'agit des boucles logiques dans le premier cas, et des boucles arithmétiques dans le second.
Les boucles logiques
Les boucles logiques sont représentées par les instructions "Tant que" et "Jusqu’à", l’une et l’autre se programmant avec l’évaluation de la condition Avant ou Après le code contrôlé.
Evaluation de la condition avant le code contrôlé : Evaluation de la condition après le code contrôlé : Le code contrôlé ne sera peut-être jamais exécuté. Le code contrôlé sera exécuté au moins une fois.
Condition Action(s) répétée(s) Action(s) répétée(s) Condition
Il faut, dans un cas comme dans l’autre, que le code contrôlé contienne une instruction modifiant une ou plusieurs variables participant à la condition de sorte à permettre la sortie de la boucle après un certain nombre d’itérations.
N = 0
While N < 5 ' "Tant que" avec évaluation Avant (Forme 1)
N = N + 1
Console.WriteLine(N) ' Affichage des valeurs de 1 à 5
End While
Do While N < 10 ' "Tant que" avec évaluation Avant (Forme 2)
N = N + 1
Console.WriteLine(N) ' Affichage des valeurs de 6 à 10
Loop
Do ' "Tant que" avec évaluation Après
N = N + 1
Console.WriteLine(N) ' Affichage des valeurs de 11 à 15
Loop While N < 15
Do Until N = 20 ' "Jusqu’à" avec évaluation Avant
N = N + 1
Console.WriteLine(N) ' Affichage des valeurs de 16 à 20
Loop
Do ' "Jusqu’à" avec évaluation Après
N = N + 1
Console.WriteLine(N) ' Affichage des valeurs de 21 à 25
Loop Until N = 25
Il existe une structure de boucle logique qui permet au programmeur de placer l’évaluation de la condition n’importe où dans le code contrôlé. La sortie de la boucle se programme alors avec un ordre ExitDo.
Do ' Avec évaluation dans le code contrôlé
N = N + 1
If N > 30 Then Exit Do ' Evaluation et sortie si nécessaire
Console.WriteLine(N) ' Affichage des valeurs de 26 à 30
La boucle arithmétique
La boucle arithmétique peut toujours être remplacée par une boucle logique dont la condition évalue la valeur d’une variable incrémentée à chaque itération (comme dans l’exemple précédent).
Toutefois, l’instruction appropriée a le mérite d’intégrer la variable, dite variable de boucle, son incrémentation et son évaluation par rapport à une limite donnée.
V = VDeb ==> VFin, Pas
Action(s) répétée(s)
For Variable_de_boucle = Valeur_Debut To Valeur_Fin Step Pas
Action(s)_ répétée(s)
Next Variable_de_boucle
Les trois boucles suivantes sont identiques :
For N = 1 To 25 Step 1
Console.WriteLine(N) ' Affichage des valeurs de 1 à 25
Next N
For N = 1 To 25 ' La valeur par défaut du pas est 1
Console.WriteLine(N) ' Affichage des valeurs de 1 à 25
Next N
For N = 1 To 25
Console.WriteLine(N) ' Affichage des valeurs de 1 à 25
Next ' Le rappel de la variable de boucle à cet endroit ' est facultatif, mais il améliore la lisibilité ' du code
Le pas peut prendre n’importe quel type de valeur (entière, négative, fractionnaire) pour autant que la variable de boucle soit du type approprié. S’il est fourni par une variable, celle-ci n’est évaluée qu’une fois et sa modification à l’intérieur de la boucle n’affecte pas le nombre d’itérations calculé au début.
For R As Single = 2 To -1 Step -.5
Console.WriteLine(R) ' Affichage les valeurs 2, 1.5, 1, 0.5, 0, -0.5, -1
Next
Pour rappel, un bloc de code ne bénéficie pas de l’effet de masque par rapport aux variables déclarées dans sa procédure ou fonction. La variable de boucle ne peut donc pas être déclarée localement si elle est déjà déclarée dans sa procédure ou fonction (hors d’un bloc de code). La déclaration de la variable de boucle lors de la définition de celle-ci en fait une variable locale au bloc de code de la boucle.
Private Sub MaSub() Dim x As Integer Dim k As Integer
x = 0
While x < 5
' Dim k As Integer ' Erreur : k est déjà déclarée dans MaSub
Dim y As Integer ' C’est mieux comme ça et y est locale à
x = x + 1 ' la boucle While
y = y + 1
Console.WriteLine(x * y) End While
' For x As Integer = 1 To 5 ' Erreur : x est déjà déclarée dans MaSub
For x = 1 To 5 ' C’est mieux comme ça
Dim y As Integer ' y est locale à la boucle For
y = y + 1
Console.WriteLine(x * y) Next x
Une boucle ni logique, ni arithmétique
La boucle "Pour chaque" ne requiert pas la définition d’une condition d’arrêt, ni la spécification d’un compteur. Elle permet l’accès à chacune des données contenues dans un tableau ou une collection.
Module MonModule
Private Structure MaStruct Dim Nom As String Dim Age As Integer End Structure
Sub Main()
Dim TS(5) As MaStruct Dim MS As MaStruct Dim TI(5) As Integer
' …
For Each N As Integer In TI ' Pour chaque N, qui est un entier contenu dans TI
Console.WriteLine(N) ' Affiche la valeur de N
Next
For Each MS In TS ' Pour chaque MS, qui est une MaStruct contenue dans TS
Console.WriteLine(MS.Nom & " " & MS.Age) Next
End Sub
End Module
Un autre exemple :
Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs)
Handles MyBase.Load For Each TB As Object In Me.Controls ' Pour chaque TB, qui est un objet contenu
TB.Clear() ' lui-même (Me), s’il est de type TextBox,
If TB.GetType.Name = "TextBox" Then ' dans la collection des Controls de Form1
End If ' alors le vider de tout contenu
Next
' …