About Help

Choose a topic from the list on the left or search for a specific topic. Choose a topic from the list or search for a specific topic.
Cmdlets  Providers
 

about_Break

Break

 

SHORT DESCRIPTION

    Describes a statement you can use to immediately exit Foreach, For, While, 
    Do, or Switch statements. 
 
 

LONG DESCRIPTION

    When a Break statement appears in a loop, such as a Foreach, For, Switch,   
    or While loop, the Break statement causes Windows PowerShell to immediately 
    exit the loop. In a Switch construct that does not loop, Break causes  
    Windows PowerShell to exit the Switch code block. 
  
  
    A Break statement can include a label that lets you exit embedded loops.  
    A label can specify any loop keyword, such as Foreach, For, or While, in a  
    script. When you use a label, Break exits the specified loop. Break exits  
    the specified loop, regardless of which loop the Break statement is in. 
 
 
    The following example shows how to use a Break statement to exit a For  
    statement: 
 
 
        for($i=1; $i -le 10; $i++) 
        { 
            Write-Host $i 
            break 
        } 
 
 
    In this example, the Break statement exits the For loop when the $i  
    variable equals 1. Even though the For statement evaluates to True  
    until $i is greater than 10, Windows PowerShell reaches the break statement 
    the first time the For loop is run.  
 
    It is more common to use the Break statement in a loop where  
    an inner condition must be met. Consider the following Foreach  
    statement example: 
 
 
        $i=0 
        $varB = 10,20,30,40 
        foreach ($val in $varB) 
        {     
            $i++ 
            if ($val -eq 30) 
            { 
                break 
            }     
        } 
        Write-Host "30 was found in array position $i" 
 
 
    In this example, the Foreach statement iterates the $varB array. Each  
    time the code block is run, the $i variable is incremented by 1. The  
    If statement evaluates to False the first two times the  
    loop is run. The third time the loop is run, $i equals 3, and the $val  
    variable equals 30. At this point, the Break statement runs, and the  
    Foreach loop exits. 
 
 
    You break out of the other looping statements in the same way you  
    break out of the Foreach loop. In the following example, the Break  
    statement exits a While statement when a DivideByZeroException exception 
    is trapped using the Trap statement. 
 
 
        $i = 3 
        while ($true) 
        { 
            trap [DivideByZeroException]  
            { 
                Write-Host "divide by zero trapped"  
                break 
            } 
            1 / $i-- 
        } 
 
 
    A Break statement can include a label. If you use the Break keyword with 
    a label, Windows PowerShell exits the labeled loop instead of exiting the 
    current loop. The syntax for a label is as follows (this example shows a 
    label in a While loop): 
 
 
        :myLabel while (<condition>) { <statement list>} 
 
 
    The label is a colon followed by a name that you assign. The label must be  
    the first token in a statement, and it must be followed by the looping  
    keyword, such as While. 
  
 
    In Windows PowerShell, only loop keywords, such as Foreach, For, and While  
    can have a label. 
 
 
    Break moves execution out of the labeled loop. In embedded loops, this has  
    a different result than the Break keyword has when it is used by itself.  
    This schematic example has a While statement with a For statement: 
  
 
        :myLabel while (<condition 1>)  
        { 
            for ($item in $items)  
            {  
                if (<condition 2>) { break myLabel }  
                $item = $x   # A statement inside the For-loop 
            } 
        } 
        $a = $c  # A statement after the labeled While-loop 
 
 
    If condition 2 evaluates to True, the execution of the script skips down 
    to the statement after the labeled loop. In the example, execution starts 
    again with the statement "$a = $c".  
 
 
    You can nest many labeled loops, as shown in the following schematic  
    example. 
 
 
        :red while (<condition1>) 
        { 
            :yellow while (<condition2>) 
            { 
                while (<condition3>) 
                { 
                    if ($a) {break} 
                    if ($b) {break red} 
                    if ($c) {break yellow} 
                } 
                # After innermost loop 
            } 
                # After "yellow" loop 
        } 
                # After "red" loop 
 
 
    If the $b variable evaluates to True, execution of the script resumes  
    after the loop that is labeled "red". If the $c variable evaluates to  
    True, execution of the script control resumes after the loop that is  
    labeled "yellow". 
 
 
    If the $a variable evaluates to True, execution resumes after the innermost 
    loop. No label is needed. 
 
 
    Windows PowerShell does not limit how far labels can resume execution. The  
    label can even pass control across script and function call boundaries. 
 
 
    The Break keyword is used to leave the Switch construct. For example,  
    the following Switch statement uses Break statements to test for the  
    most specific condition: 
 
 
        $var = "word2" 
        switch -regex ($var)  
        { 
            "word2"  
            { 
                Write-Host "Exact" $_  
                break 
            }  
 
            "word.*"  
            {  
                Write-Host "Match on the prefix" $_  
                break 
            } 
 
            "w.*" 
            { 
                Write-Host "Match on at least the first letter" $_ 
                break  
            } 
             
            default 
            { 
                Write-Host "No match" $_ 
                break 
            } 
        } 
 
 
    In this example, the $var variable is created and initialized to a string 
    value of "word2". The Switch statement uses the Regex class to match the  
    variable value first with the term "word2". (The Regex class is a regular 
    expression Microsoft .NET Framework class.) Because the variable value and 
    the first test in the Switch statement match, the first code block in the 
    Switch statement runs. 
 
 
    When Windows PowerShell reaches the first Break statement, the Switch  
    statement exits. If the four Break statements are removed from the example, 
    all four conditions are met. This example uses the break statement to  
    display results when the most specific condition is met.  
 
 

SEE ALSO

about_Comparison_Operators
about_Continue
about_For
about_Foreach
about_Switch
about_Throw
about_Trap
about_Try_Catch_Finally
about_While