about_Break
Applies To: Windows PowerShell 2.0
TOPIC
about_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