RUBRIQUE
    about_Break

DESCRIPTION COURTE
    Décrit une instruction permettant de quitter immédiatement les 
    instructions Foreach, For, While, Do ou Switch.


DESCRIPTION LONGUE
    Lorsqu'une instruction Break apparaît dans une boucle (Foreach, 
    For, Switch ou While, par exemple), elle force Windows PowerShell 
    à quitter immédiatement la boucle. Dans une construction Switch 
    ne décrivant pas de boucle, l'instruction Break force Windows 
    PowerShell à quitter le bloc de code Switch.
 
 
    Une instruction Break peut inclure une étiquette permettant de 
    quitter des boucles incorporées. Une étiquette peut spécifier 
    tout mot clé de boucle (Foreach, For ou While, par exemple) 
    présent dans un script. Lorsque vous utilisez une étiquette, 
    l'instruction Break quitte la boucle spécifiée. Elle quitte cette 
    boucle, quelle que soit celle dans laquelle elle se trouve.


    L'exemple suivant montre comment utiliser une instruction Break 
    pour quitter une instruction For :


        for($i=1; $i -le 10; $i++)
        {
            Write-Host $i
            break
        }


    Dans cet exemple, l'instruction Break quitte la boucle For lorsque la 
    variable $i est égale à 1. Même si l'instruction For prend la valeur True 
    jusqu'à ce que la variable $i soit supérieure à 10, Windows PowerShell 
    atteint l'instruction Break lors de la première exécution de la boucle For. 

    L'instruction Break est plus souvent utilisée dans une boucle où une 
    condition interne doit être remplie. Examinez l'exemple d'instruction 
    Foreach suivant :


        $i=0
        $varB = 10,20,30,40
        foreach ($val in $varB)
        {  
            $i++
            if ($val -eq 30)
            {
                break
            }  
        }
        Write-Host "30 a été trouvé à la position de tableau $i"


    Dans cet exemple, l'instruction Foreach parcourt le tableau 
    $varB. À chaque exécution du bloc de code, la variable $i est 
    incrémentée d'une unité. L'instruction If prend la valeur False 
    lors des deux premières exécutions de la boucle. À la troisième 
    exécution de la boucle, la variable $i est égale à 3 et la 
    variable $val est égale à 30. À ce stade, l'instruction Break 
    s'exécute et la boucle Foreach prend fin.


    La sortie des autres instructions de boucle s'effectue de la même 
    façon que la sortie de la boucle Foreach. Dans l'exemple suivant, 
    l'instruction Break quitte une instruction While lorsqu'une exception 
    DivideByZeroException est interceptée au moyen de l'instruction Trap.


        $i = 3
        while ($true)
        {
            trap [DivideByZeroException] 
            {
                Write-Host "division par zéro interceptée" break
            }
            1 / $i--
        }


    Une instruction Break peut inclure une étiquette. Si vous 
    utilisez le mot clé Break avec une étiquette, Windows PowerShell 
    quitte la boucle étiquetée, et non pas la boucle actuelle. La 
    syntaxe d'une étiquette se présente comme suit (l'exemple suivant 
    montre une étiquette dans une boucle While) :


        :monÉtiquette while (<condition>) { <liste d'instructions>}


    L'étiquette correspond à un signe deux-points, suivi d'un nom que vous 
    attribuez. Elle doit correspondre au premier jeton d'une instruction 
    et être suivie du mot clé de bouclage, tel que While.
 

    Dans Windows PowerShell, seuls les mots clés de boucle, tels que 
    Foreach, For et While, peuvent comporter une étiquette.


    L'instruction Break transfère l'exécution hors de la boucle 
    étiquetée. Dans les boucles incorporées, vous n'obtenez ainsi pas 
    le même résultat que si vous utilisez le mot clé Break seul. L'exemple 
    schématique suivant utilise une instruction While avec une 
    instruction For :
 

        :monÉtiquette while (<condition 1>) 
        {
            for ($item in $items) 
            { 
                if (<condition 2>) { break monÉtiquette } 
                $item = $x  # Instruction située dans la boucle For }
        }
        $a = $c # Instruction située après la boucle While étiquetée


    Si la condition 2 prend la valeur True, l'exécution du script se 
    poursuit directement avec l'instruction située après la boucle 
    étiquetée. Dans l'exemple, l'exécution reprend avec l'instruction 
    "$a = $c". 


    Vous pouvez imbriquer de nombreuses boucles étiquetées, comme 
    illustré dans l'exemple schématique suivant.


        :rouge while (<condition1>)
        {
            :jaune while (<condition2>)
            {
                while (<condition3>)
                {
                    if ($a) {break}
                    if ($b) {break rouge}
                    if ($c) {break jaune}
                }
                # Après la boucle la plus profonde
            }
                # Après la boucle "jaune"
        }
                # Après la boucle "rouge"


    Si la variable $b prend la valeur True, l'exécution du script 
    reprend après la boucle étiquetée " rouge ". Si la variable $c 
    prend la valeur True, l'exécution du contrôle du script reprend 
    après la boucle étiquetée " jaune ".


    Si la variable $a prend la valeur True, l'exécution reprend après 
    la boucle la plus profonde. Aucune étiquette n'est requise.


    Windows PowerShell ne limite pas la façon dont les étiquettes peuvent 
    reprendre l'exécution. L'étiquette peut même transmettre le contrôle 
    au-delà des limites des scripts et des appels de fonction.


    Le mot clé Break est utilisé pour quitter la construction Switch. Par 
    exemple, l'instruction Switch suivante utilise des instructions Break pour 
    tester la condition la plus spécifique :


        $var = "mot2"
        switch -regex ($var) 
        {
            "mot2" 
            {
                Write-Host "Exact" $_ 
                break
            } 

            "mot.*" 
            { 
                Write-Host "Correspondance sur le préfixe" $_ break
            }

            "m.*"
            {
                Write-Host "Correspondance au moins sur la première 
                lettre" $_ break 
            }
            
            default
            {
                Write-Host "Aucune correspondance" $_
                break
            }
        }


    Dans cet exemple, la variable $var est créée et initialisée sur 
    la valeur de chaîne " mot2 ". L'instruction Switch utilise la 
    classe Regex pour faire correspondre la valeur de la variable 
    d'abord avec le terme " mot2 ". (La classe Regex est une classe 
    Microsoft .NET Framework d'expressions régulières.) Étant donné que 
    la valeur de la variable et le premier test de l'instruction Switch 
    correspondent, le premier bloc de code de l'instruction Switch s'exécute.


    La sortie de l'instruction Switch se produit lorsque Windows 
    PowerShell atteint la première instruction Break. Si les quatre 
    instructions Break sont supprimées de l'exemple, les quatre conditions 
    sont remplies. Cet exemple utilise l'instruction Break pour afficher 
    les résultats lorsque la condition la plus spécifique est remplie. 


VOIR AUSSI  
    about_Comparison_Operators
    about_For
    about_Foreach 
    about_Switch
    about_While




Table des matières