Programmation .Net - Indépendance financière

Comment utiliser les boucles en Visual Basic

Les boucles est un sujet souvent difficile à comprendre par les nouveaux programmeurs. Je crois sincèrement que ça puisse avoir un lien avec le fait que le débogage est appris seulement plus tard dans le cheminement. Mais nous avons déjà vu cette matière alors ça devrait être plus facile!

Donc pour notre partie définition habituelle, qu’est-ce qu’une boucle (loop)? Il y a certains moment durant lesquels il est très utile de pouvoir exécuter un bout de code en particulier plusieurs fois. C’est exactement ce à quoi sert une boucle en programmation. Il sagit d’un bloc spécial de code qui sera exécuté tant que, jusqu’à ce que ou pour qu’une ou plusieurs conditions soit atteinte.

Il existe plusieurs types de boucles, toutefois les plus communes sont le For, le While et le Foreach. Nous sommes assez chanceux puisque Visual Basic contient toutes ces boucles donc nous allons pouvoir exploiter leur plein potentiel!

For (le classique)

Le For est, selon moi, l’une des plus anciennes boucles et aussi l’une des plus versatiles. Elle peut remplacer les autres dans bien des situations et il est facile de penser à un cas simple d’utilisation, par exemple parcourir un tableau ou une liste élément par élément.

Voici le gabari de la boucle For.

For (Position de l'index) To (Nombre maximum) Step (Vitesse de comptage)
    'Code à executer pour le nombre de fois spécifié
Next

Ça peut sembler un peu compliqué, toutefois voici un exemple réel pour tenter de mieux illustrer le fonctionnement. Je vous suggère de mettre un breakpoint avant la boucle pour bien comprendre et ensuite appuyer sur Start et F10 pour poursuivre l’exécution en mode débogage.

Option Strict On
Option Explicit On

Module Program
    Sub Main()
        'Déclaration et initialisation
        Dim TableOfStudents = New String() {"Alexandre", "Daniel", "Maxime"}
        Dim TableOfMarks = New Integer() {80, 85, 90}
        Dim OutputString As String = String.Empty

        'Boucle For
        For Index As Integer = 0 To 2 Step 1
            OutputString = String.Format("Student: {0} has a mark of: {1}", TableOfStudents.GetValue(Index), TableOfMarks.GetValue(Index))
            Console.WriteLine(OutputString)
        Next

        Console.ReadKey()
    End Sub
End Module

Il y a quelque chose de différent même dans les premières lignes, en effet, j’ai fait la déclaration et l’initialisation des variables en même temps. Disons que c’est un peu plus rapide. Est-ce que c’est une meilleure idée? Je dirais simplement que peut importe si vous choisissez d’effectuer votre déclaration et votre initialisation en même temps ou non, restez cohérent tout au long de votre projet, ça pourra vous éviter de vous mélanger pour rien éventuellement. Il est important de toujours être capable de raisonner vos actions. Pourquoi est-ce que j’écris telle ou telle ligne, variable, boucle etc de telle ou telle façon est une question à se poser régulièrement.

Portez maintenant votre attention à la boucle For. La ligne Index As Integer = 0 effectue justement la déclaration et l’initialisation en même temps comme nous venons de le voir. On déclare donc une nouvelle variable Index, dans laquelle sera mis la valeur 0 au début du processus de la boucle. Pourquoi 0? Parce que nous souhaitons parcourir les deux tableaux, TableOfStudents et TableOfMarks qui contiennent les étudiants et leur note respectivement, en même temps. De plus, les tableaux en programmation commencent à l’indice 0.

Mais qu’est-ce qu’un tableau exactement? Un tableau est une variable spéciale qui contient plusieurs éléments d’un même type dans une seule variable mémoire. Voici ce à quoi ça peut avoir l’air visuellement.

[“Alexandre”, “Daniel”, “Maxime”]
[80, 85, 90]

À l’adresse en mémoire du tableau :

Illustration of a table in memory

Les éléments du tableau ci-dessus sont séparés par des virgules, “Alexandre” est l’élément à la position 0 et est de type String puisque TableOfStudents est de type chaine de caractères (String) aussi. “Daniel” est l’élément à la position 1, et ainsi de suite. Vous pouvez mettre autant d’éléments que vous voulez au début ou encore déclarer un tableau de longueur fixe. Toutefois en principe, les tableaux de ce types ne peuvent pas modifier leur longueur, c’est donc dire que si votre tableau a une longueur de 5, vous ne pourrez pas mettre 6 éléments à l’intérieur. Il aura aussi les indices 0, 1, 2, 3 et 4 pour un total de 5 espaces.

Nous regarderons les tableaux plus en détails dans un autre tutoriel. Pour en revenir à nos boucles, la variable Index commencera donc à 0 To (jusqu’à) 2 avec des Step (bons) de 1. Voici les valeurs de Index à chaque itération de la boucle. N’oubliez pas que la condition pour sortir de cette boucle est qu’Index soit 2 (To 2).

La ligne For Index As Integer = 0 To 2 Step 1 se lira donc : Pour la variable Index de type Integer initialisée à 0, aller jusqu’à 2 par bons de 1.

0 – première exécution
1 – deuxième exécution
2 – troisième exécution
3? la condition est remplie donc on sort de la boucle! La valeur d’Index 3 ne sera donc jamais atteinte.

Rappelez-vous que durant chacune des exécutions, la valeur de l’Index est modifiée par l’ajout du Step (ici 1). Donc si vous êtes à la seconde exécution de la boucle, Index sera 1.

Finalement, le bloc d’exécution est atteint à chaque fois que la boucle fait une itération, dans le cas présent, nous affichons une chaine de caractère comprenant l’étudiant et sa note. Créez un nouveau projet et essayer le code ci-dessus, vous pouvez aussi mettre des breakpoints pour voir vraiment comment l’ordinateur traîtera ce code (Step Over, F10).

Vous devriez avoir ce résultat à la suite de l’exécution.

Loop result

Évoila! Visual Basic affiche donc l’étudiant et sa note correspondante qui est à la même position dans l’autre tableau. On parcours donc les deux tableaux en même temps!

While!

Le While peut être très utile lorsque l’on ne connais pas le moment précis de la sortie de la boucle, par exemple lors de la lecture d’un fichier texte dans lequel le nombre de lignes demeure inconnu jusqu’à arriver à la fin de ce dernier.

Gabari du While :

While Condition
   'Bloc d'exécution
End While

Comme vous pouvez le constater, il est légèrement plus facile de démistifier cette boucle par rapport à la boucle For. Tant que la condition est vraie, effectuer ce qui est dans le bloc d’exécution. De plus, il est possible de changer le While avec le Not. Celui-ci sera ajouté devant la condition et l’inversera. Certaines personnes trouvent cela un peu plus facile à lire, c’est mon cas. Nous dirons alors, Tant que la condition n’est pas respectée, boucler. On donne alors la condition de sortie plutôt que celle d’entrée, en voici un exemple.

Option Strict On
Option Explicit On

Module Program
    Sub Main()
        'Déclaration et initialisation
        Dim OutputString As String = String.Empty
        Dim Counter As Integer = 5

        'Boucle While
        While Not Counter = 0
            Counter -= 1

            OutputString = String.Format("Counter value is: {0}", Counter)
            Console.WriteLine(OutputString)
        End While

        Console.ReadKey()
    End Sub
End Module

Dans ce code, je déclare et initialise une variable Counter à 5, ensuite vient la boucle While dans laquelle la condition de continuité (car ici il y a un Not) est tant que Counter n’est pas égal à 0, exécuter ce qu’il y a à l’intérieur du bloc. Remarquez qu’il est nécessaire de décrémenter Counter (Counter -= 1) nous même, en opposition à la boucle For qui le fait pour nous. On sort ensuite le résultat du String.Format dans la console.

Appuyez sur Start (F5) et vous devriez avoir le résultat ci-dessous.

While loop output

La question est : pourquoi le résultat affiche que Counter est 4 alors que nous l’avons bien assigné à 5 au début? La raison est que nous effectuons la décrémentation avant l’affichage. Essayez de mettre par exemple Counter -= 1 après Console.WriteLine(OutputString). Vous verrez alors que l’affichage commencera à 5 et se terminera maintenant à 1. L’ordre des opérations est très importante!

Je ne suis pas certain de comprendre ce que fait Counter -= 1 exactemment? Counter -= 1 est similaire à écrire Counter = Counter – 1. On prend Counter, et on lui assigne la valeur de Counter – 1.

Vous pouvez aussi chainer plusieurs conditions avec des And et des Or comme nous avons fait avec le If. Essayez d’enlever le Not dans la condition précédente et de créer l’équivalent de ce que la boucle fait présentement. Voici une solution!

    Sub Main()
        'Declaration and initialization
        Dim OutputString As String = String.Empty
        Dim Counter As Integer = 5

        While Counter > 0
            Counter -= 1

            OutputString = String.Format("Counter value is: {0}", Counter)
            Console.WriteLine(OutputString)
        End While

        Console.ReadKey()
    End Sub

For Each (Le plus facile sans aucun doute!)

Personnellement, je trouve que cette boucle est la plus facile et la plus intuitive de toutes car il n’y a pas de gestion d’indice à faire.

Le ForEach se mentionne comme suit : Pour chaque élément de type spécifique dans un Array/Collection ou autre, exécuter ce bloc de code. Voici le gabari du ForEach.

For Each (Variable) As (Type) In (Array/Collection etc)
    'Code to execute
Next

Vous devez toujours garder en tête que le type de l’élément dans la boucle doit être le même que celui du Array/Collection que vous voulez parcourir.

À chaque tour de boucle, Visual Basic mettra l’élément courant du Array dans cet élément. Vous pourrez alors accéder à l’élément courant directement à partir de cette variable. Voyons un exemple pour clarifier le tout.

Si ma liste contient “Alexandre”, “Daniel”, “Maxime”

Durant le premier tour, l’élément sera assigné à Alexandre,
Durant le second tour, l’élément sera assigné à Daniel et ainsi de suite.

Voici un exemple réel.

Option Strict On
Option Explicit On

Module Program
    Sub Main()
        'Déclaration and initialisation
        Dim TableOfStudents = New String() {"Alexandre", "Daniel", "Maxime"}
        Dim OutputString As String = String.Empty

        'Boucle ForEach
        For Each CurrentStudent As String In TableOfStudents
            Console.WriteLine(CurrentStudent)
        Next

        Console.ReadKey()
    End Sub
End Module

Encore une fois, je vous suggère de mettre un point d’arrêt (breakpoint) pour mieux visualiser ce qui se passe réellement lors de l’exécution. N’oubliez pas que vous pouvez mettre votre souris sur la variable CurrentStudent pour voir sa valeur.

Dans ce code, on parcours simplement le tableau TableOfStudents et affichons chaque valeur dans la console. L’image ci-dessous représente ce que vous devriez avoir en sortie.

ForEach loop output

Autres outils intéressant des boucles!

Parfois il sera nécessaire de terminer prématurément l’exécution d’une boucle ou encore de passer un bout de cette boucle. Nous utiliserons Exit et Continue respectivement pour effectuer ces tâches. Exit arrête complétement l’exécution de la boucle alors que Continue retourne à la vérification de la condition (au début de la boucle) en passant tout le reste du contenu.

Option Strict On
Option Explicit On

Module Program
    Sub Main()
        'Déclaration and initialisation
        Dim TableOfStudents = New String() {"Alexandre", "Daniel", "Maxime"}
        Dim OutputString As String = String.Empty

        'Boucle ForEach
        For Each CurrentStudent As String In TableOfStudents
            If CurrentStudent = "Daniel" Then
                Exit For
            End If

            Console.WriteLine(CurrentStudent)
        Next

        Console.ReadKey()
    End Sub
End Module

Vous devez indiquer à Visual Basic à quel élément (boucle, fonction, etc) appartient ce Exit. Ici nous irons seulement pour la boucle. nous mettrons donc Exit For. Si la boucle était un While, nous aurions mis Exit While et la même consigne s’applique pour Continue.

Dans le code ci-dessus, si la valeur de CurrentStudent est Daniel, alors on sortira de la boucle. Cette sortie devrait donner le résultat ci-dessous.

For Each exit

Nous allons parler des boucles dans le prochain exercice! Précisément car le sujet est très important à comprendre parfaitement puisqu’il ne s’applique pas seulement à un langage mais bien à la plupart des langages de programmation.

Si vous avez des questions n’hésitez pas à les mettre dans les commentaires. Vous pouvez aussi jeter un coup d’oeil à la chaine Youtube pour des explications plus intéractives.

Next article Les boucles en Visual Basic - Exercice et solution
Previous article Les Functions et les Subs en Visual Basic

Related posts

0 Comments

No Comments Yet!

You can be first to comment this post!

Leave a Comment

Your data will be safe! Your e-mail address will not be published. Also other data will not be shared with third person. Required fields marked as *