Guide

Guide : Utiliser la Boucle While en VB.NET

La boucle While en VB.NET est utilisée pour répéter un bloc de code tant qu’une condition spécifiée reste vraie. Elle est idéale lorsque le nombre d’itérations n’est pas connu à l’avance et dépend d’une condition dynamique.

1. Syntaxe de la boucle While

While condition
    ' Instructions à exécuter
End While

Points clés :

La boucle continue de s’exécuter tant que la condition est vraie.
Si la condition est fausse dès le début, la boucle ne s’exécutera jamais.

2. Exemple de base

Compter de 1 à 5 avec While

Dim compteur As Integer = 1

While compteur <= 5
    Console.WriteLine("Valeur de compteur : " & compteur)
    compteur += 1 ' Incrémentation
End While

Sortie :

Valeur de compteur : 1
Valeur de compteur : 2
Valeur de compteur : 3
Valeur de compteur : 4
Valeur de compteur : 5

3. Comparaison avec une Boucle For

Contrairement à une boucle For, la boucle While est plus flexible pour des cas où le nombre d’itérations dépend de conditions dynamiques.

Exemple :

Dim x As Integer = 1
While x < 100
    x *= 2
    Console.WriteLine("x vaut maintenant : " & x)
End While

Sortie :

x vaut maintenant : 2
x vaut maintenant : 4
x vaut maintenant : 8
x vaut maintenant : 16
x vaut maintenant : 32
x vaut maintenant : 64
x vaut maintenant : 128

4. Condition dynamique avec Input

Vous pouvez utiliser la boucle While pour demander des entrées utilisateur jusqu’à ce qu’une condition soit remplie.

Exemple : Demander un mot de passe

Dim motDePasse As String = ""

While motDePasse <> "1234"
    Console.Write("Entrez le mot de passe : ")
    motDePasse = Console.ReadLine()
    If motDePasse <> "1234" Then
        Console.WriteLine("Mot de passe incorrect, réessayez.")
    End If
End While

Console.WriteLine("Accès autorisé.")

Sortie :

Entrez le mot de passe : test
Mot de passe incorrect, réessayez.
Entrez le mot de passe : 1234
Accès autorisé.

5. Interrompre une Boucle avec `Exit While`

Le mot-clé Exit While permet de quitter une boucle même si la condition reste vraie.

Exemple : Arrêter la boucle à une condition interne

Dim x As Integer = 1

While True ' Boucle infinie
    Console.WriteLine("x vaut : " & x)
    If x = 5 Then
        Exit While ' Quitte la boucle si x = 5
    End If
    x += 1
End While

Console.WriteLine("Boucle terminée.")

Sortie :

x vaut : 1
x vaut : 2
x vaut : 3
x vaut : 4
x vaut : 5
Boucle terminée.

6. Passer à l’itération suivante avec `Continue While`

Le mot-clé Continue While permet d’ignorer le reste des instructions et de passer directement à l’itération suivante.

Exemple : Ignorer les nombres pairs

Dim x As Integer = 0

While x <= 10
    x += 1
    If x Mod 2 = 0 Then
        Continue While ' Ignore les nombres pairs
    End If
    Console.WriteLine("Nombre impair : " & x)
End While

Sortie :

Nombre impair : 1
Nombre impair : 3
Nombre impair : 5
Nombre impair : 7
Nombre impair : 9
Nombre impair : 11

7. Combinaison de While avec une Autre Condition

Vous pouvez utiliser plusieurs conditions logiques avec la boucle While.

Exemple : Condition multiple avec AND

Dim x As Integer = 1
Dim y As Integer = 10

While x < 10 And y > 5
    Console.WriteLine($"x : {x}, y : {y}")
    x += 1
    y -= 1
End While

Sortie :

x : 1, y : 10
x : 2, y : 9
x : 3, y : 8
x : 4, y : 7
x : 5, y : 6
x : 6, y : 5

8. Boucle Infinie

Une boucle While peut devenir une boucle infinie si la condition est toujours vraie. Cela peut être intentionnel (comme un serveur en attente de requêtes) ou une erreur.

Exemple : Boucle infinie intentionnelle

While True
    Console.WriteLine("Appuyez sur Q pour quitter.")
    Dim input As String = Console.ReadLine()
    If input.ToUpper() = "Q" Then
        Exit While
    End If
End While

Console.WriteLine("Boucle terminée.")

9. Exemple Complet : Utiliser While avec un Tableau

Vous pouvez utiliser une boucle While pour parcourir un tableau.

Exemple :

Dim nombres() As Integer = {10, 20, 30, 40, 50}
Dim index As Integer = 0

While index < nombres.Length
    Console.WriteLine($"Index : {index}, Valeur : {nombres(index)}")
    index += 1
End While

Sortie :

Index : 0, Valeur : 10
Index : 1, Valeur : 20
Index : 2, Valeur : 30
Index : 3, Valeur : 40
Index : 4, Valeur : 50

10. Différence entre While et Do While

While

Vérifie la condition avant d’exécuter le code.
Si la condition est fausse dès le début, la boucle ne s’exécute jamais.

Dim x As Integer = 10
While x < 5
    Console.WriteLine("Ne s'exécutera pas")
End While

Do While

Exécute le code au moins une fois avant de vérifier la condition.

Dim x As Integer = 10
Do
    Console.WriteLine("S'exécute au moins une fois")
Loop While x < 5

Résumé des Commandes Utiles

Commande	Description
`Exit While`	Quitte immédiatement la boucle.
`Continue While`	Passe directement à l’itération suivante.
`While True`	Crée une boucle infinie (interrompue par `Exit While`).

La boucle While en VB.NET est un outil flexible pour exécuter un bloc de code tant qu’une condition reste vraie. Elle est idéale pour les scénarios où les itérations dépendent de données dynamiques ou d’une entrée utilisateur.

Exemple avec Do While en VB.NET

La boucle Do While est utilisée pour exécuter un bloc de code tant qu’une condition donnée reste vraie. Elle est différente de la boucle While, car elle garantit que le bloc de code s’exécute au moins une fois, même si la condition est fausse dès le début.

Syntaxe de Do While

Standard :

Do While condition
    ' Instructions à exécuter
Loop

Condition après le bloc (au moins une exécution garantie) :

Do
    ' Instructions à exécuter
Loop While condition

Exemple : Demander un mot de passe avec Do While

Scénario

Nous allons demander à l’utilisateur de saisir un mot de passe jusqu’à ce qu’il entre la bonne valeur.

Code :

Module Module1
    Sub Main()
        Dim motDePasse As String
        Dim motDePasseCorrect As String = "1234"

        Do
            Console.Write("Entrez le mot de passe : ")
            motDePasse = Console.ReadLine()

            If motDePasse <> motDePasseCorrect Then
                Console.WriteLine("Mot de passe incorrect. Réessayez.")
            End If
        Loop While motDePasse <> motDePasseCorrect

        Console.WriteLine("Mot de passe correct ! Accès autorisé.")
    End Sub
End Module

Sortie :

Entrez le mot de passe : test
Mot de passe incorrect. Réessayez.
Entrez le mot de passe : 4321
Mot de passe incorrect. Réessayez.
Entrez le mot de passe : 1234
Mot de passe correct ! Accès autorisé.

Exemple : Compter jusqu’à 10 avec Do While

Scénario

Nous allons compter de 1 à 10 en affichant chaque valeur à l’écran.

Code :

Module Module1
    Sub Main()
        Dim compteur As Integer = 1

        Do While compteur <= 10
            Console.WriteLine("Compteur : " & compteur)
            compteur += 1 ' Incrémentation
        Loop

        Console.WriteLine("Boucle terminée.")
    End Sub
End Module

Sortie :

Compteur : 1
Compteur : 2
Compteur : 3
Compteur : 4
Compteur : 5
Compteur : 6
Compteur : 7
Compteur : 8
Compteur : 9
Compteur : 10
Boucle terminée.

Exemple : Calculer une somme jusqu’à une limite

Scénario

Nous allons demander à l’utilisateur de saisir des nombres. La boucle continuera tant que la somme des nombres est inférieure à 100.

Code :

Module Module1
    Sub Main()
        Dim somme As Integer = 0

        Do
            Console.Write("Entrez un nombre : ")
            Dim nombre As Integer = Integer.Parse(Console.ReadLine())

            somme += nombre
            Console.WriteLine("Somme actuelle : " & somme)
        Loop While somme < 100

        Console.WriteLine("La somme a atteint ou dépassé 100. Fin de la boucle.")
    End Sub
End Module

Sortie (exemple d’interaction utilisateur) :

Entrez un nombre : 25
Somme actuelle : 25
Entrez un nombre : 50
Somme actuelle : 75
Entrez un nombre : 30
Somme actuelle : 105
La somme a atteint ou dépassé 100. Fin de la boucle.

Exemple : Boucle infinie avec interruption (Exit Do)

Scénario

Une boucle infinie continue de demander des entrées utilisateur jusqu’à ce que l’utilisateur entre « exit ».

Code :

Module Module1
    Sub Main()
        Dim saisie As String

        Do
            Console.Write("Entrez un texte (tapez 'exit' pour quitter) : ")
            saisie = Console.ReadLine()

            If saisie.ToLower() = "exit" Then
                Exit Do ' Quitte la boucle si "exit" est entré
            End If

            Console.WriteLine("Vous avez saisi : " & saisie)
        Loop

        Console.WriteLine("Programme terminé.")
    End Sub
End Module

Sortie :

Entrez un texte (tapez 'exit' pour quitter) : Bonjour
Vous avez saisi : Bonjour
Entrez un texte (tapez 'exit' pour quitter) : Test
Vous avez saisi : Test
Entrez un texte (tapez 'exit' pour quitter) : exit
Programme terminé.

Exemple : Boucle avec contrôle en bas (Do…Loop While)

Scénario

Nous affichons un message au moins une fois, puis continuons à afficher le message tant qu’une condition reste vraie.

Code :

Module Module1
    Sub Main()
        Dim x As Integer = 10

        Do
            Console.WriteLine("Valeur de x : " & x)
            x -= 2
        Loop While x > 0

        Console.WriteLine("Boucle terminée.")
    End Sub
End Module

Sortie :

Valeur de x : 10
Valeur de x : 8
Valeur de x : 6
Valeur de x : 4
Valeur de x : 2
Boucle terminée.

Différence entre `Do While` et `Do...Loop While`

Type	Description
`Do While condition`	Vérifie la condition avant d’exécuter le code.
`Do...Loop While condition`	Exécute le code au moins une fois, puis vérifie la condition pour continuer.

Exemple comparatif :

`Do While` :

Dim x As Integer = 10

Do While x < 5
    Console.WriteLine("Ne s'exécutera pas")
Loop

Sortie : Rien, car la condition est fausse dès le début.

`Do...Loop While` :

Dim x As Integer = 10

Do
    Console.WriteLine("S'exécute au moins une fois")
Loop While x < 5

Sortie :

S'exécute au moins une fois

La boucle Do While en VB.NET est très utile lorsque vous avez besoin de répéter une tâche tant qu’une condition est vraie. Elle est particulièrement efficace pour des scénarios nécessitant des itérations dynamiques ou des validations basées sur des entrées utilisateur. Grâce à la variante Do…Loop While, vous pouvez garantir qu’un bloc de code s’exécute au moins une fois.