[['''`[http://www.tcl.tk/man/tcl/TclCmd/break.htm%|%break]`'''], a [Tcl



** See Also **

   [continue]:   
   
   [return]:   

   [for]:   
   
   [foreach]:   
   
   [while]:   



** Synopsis **

'''break'''


 
** Description **
** Description **

This command is typically invoked inside the body of a looping command such as
[[`[for]`] or [[`[foreach]`] or [[`[while]`]. It returns a TCL_BREAK code,
which causes a break exception to occur. The exception causes the current
script to be aborted out to the innermost containing loop command, which then
aborts its execution and returns normally. Break exceptions are also handled in
a few other situations, such as the '''[catch]''' command, Tk event bindings,
and the outermost scripts of procedure bodies.




   [http://www.tcl.tk/man/tcl/TclCmd/break.htm%|%official reference]:   



** Examples **

Print a line for each of the integers from 0 to 5:

======
for {set x 0} {$x<10} {incr x} {
    if {$x > 5} {
        break
    }
    puts "x is $x"
}
======

This is the same as:



One surprising use of break is to make sure a `[foreach]` loop runs exactly
One surprising use of break is to make sure a [[`[foreach]`] loop runs exactly
body):

======
foreach {a b} [list $b $a] break ;# (1)
======

[RS] 2006-04-20: This code for swapping two variables can however be had
simpler:

======
foreach a $b b $a break          ;# (2)
======

[Lars H]: No, that sets a to the first element of b and b to the first element
of a, which isn't in general the same thing as swapping the values.

[RS]: True. I was thinking in terms of scalars only... For values parsable as
lists, approach (1) is better.

[justinalanbass]: This has nothing to do with break; the body can just as

[escargo] 2004-07-13:   I recently noted that in [Icon Programming
Language%|%Icon], the ''break'' expression takes an optional expression just
like the '''return''' expression does.  This allows a bit more information to
come out of a break.  (It's also probably not what Tcl considers an exception.)

[AMG]: [Perl]'s break expression takes an argument which gives the number of
levels to break.  This avoids one common need for [goto]: breaking out of
nested loops.  Tcl has another way to do this, though:

======
try {
    foreach x {a b c} {
        foreach y {d c f} {
            puts [list $x $y]
            if {$x eq $y} {
                return -level 0 -code 5
            }
        }
    }
} on 5 {} {}
======

Some sugar:

======
proc loop {script} {tailcall try $script on 5 {} {}}
proc stop {} {return -code 5}
loop {
    foreach x {a b c} {
        foreach y {d c f} {
            puts [list $x $y]
            if {$x eq $y} {
                stop
            }
        }
    }
}
======


<<categories>> Tcl syntax | Arts and Crafts of Tcl-Tk Programming | Command | Control Structure