It is a popular idiom to use the varlist assignments to split up a list. The body in such cases would just be break to stop foreach running into a second round: To stride through a list, picking up every n'th item, a dummy variable like $-

foreach {first second third} $list break ;# RS

You might as well swap variables with that:

foreach {a b} [list $b $a] break

(It might be tempting to abbreviate the above to foreach a $b b $a break, but don't do that; it really sets b to the result of [lindex $a 0] and vice versa, which in general is something quite different, and even when it isn't it will result in shimmering.)

AMG: [lassign] can do both these tasks.

lassign $list first second third
lassign [list $b $a] a b

Unlike [foreach], it returns any unused elements from its first argument. This makes it useful for detecting extra arguments or popping elements off a stack. Also unlike [foreach], it won't create variables assigned to empty string when its first argument doesn't have enough elements. This makes it useful for detecting insufficient arguments.

Get every second element of a list with the following ("-" being a fancy variable name that indicates it will not be used):

foreach {- i} $list { foreach {- i} $list {...}

To save an array to a file:

Foreach is also a convenient way to work with Tcl's associative arrays. For instance, you can save an array to a file as a Tcl script by using:

foreach {key value} [array get myArray] {
foreach { key value } [array get myArray] {
}

Of course, you could have written: If you want the keys alphabetized, then

foreach { key } [lsort -dictionary [array names myArray]] {
    puts $myFile [list set myArray($key) $myArray($key)]
}

puts $myFile [list array set myArray [array get myArray]]

but when editing such a file, the lack of line endings might give your text but that style creates scripts which cause trouble in many text editors. To save an array to a file, ordering it alphabetically by key:

Applying 'foreach' to the result of the 'bbox' command in a canvas is often a convenient way to create canvas layouts. The following script gives the idea.

foreach {key} [lsort -dictionary [array names myArray]] {
set i [.c create text 200 50 -text "One" -anchor n]
foreach item { Two Three Four } {
    foreach { - - - y } [.c bbox $i] break
    set nexty [expr { $y + 50 }]
    .c create line 200 $y 200 $nexty -arrow last
    set i [.c create text 200 $nexty -text $item -anchor n]
}

KPV: A similar example illustrates finding the dimensions of a canvas to A similar example is when I wanted to find the dimensions of a canvas but I wanted to shrink the size to provide a margin around the layout. KPV

# Get canvas dimensions shrunk by some
foreach who {x0 y0 x1 y1} val [.c cget -scrollregion] d {30 30 -30 -30} {
    set $who [expr {$val + $d}]
}

One-time loop: You can use foreach also for a loop that runs exactly once, and you're not interested in the iterator, but get the side effect that you can "jump out" of the body with break or continue (seen in a c.l.t post by Bruce Hartweg):

foreach _ _ {

    # some processing
    if {$somecondition} break
    # some other processing
    if {$someothercondition} break
    # still more processing

}

This is an alternative to nested `[if]` structures.
Helps you avoid nested [if] structures. [RS] is not sure whether to recommend this style.. but proof again that you can do more with Tcl than you'd imagine...;-) Well, hell, then add some sugar:
[RS] is not sure whether to recommend this style.. but proof again that you can
interp alias {} breakable {} foreach _ _
breakable { ;# or 'fragile'?
    # some processing
    if {$somecondition} break
    # some other processing
    if {$someothercondition} break
    # still more processing
}

Or, to make your intention clearer:

interp alias {} make {} foreach
make or break {
    ...
}

AMG: This is like the do {...} while (0); idiom in C, which is AMG: This is like the do {...} while (0); idiom in C, which is useful not only in macros but also for creating a "structured goto" using break. Perhaps unfortunately, continue can't be used to go back to the top, since it first checks the loop condition; otherwise this idiom would effectively create two line labels at the same time. ;^) Very occasionally I wish for a "redo" statement that restarts the current iteration of the loop, bypassing both the loop condition and for's increment clause.

SS wonders why foreach doesn't return the result of the last executed command. It can be useful for programmers using Tcl in a functional style. The same also apply to for. CL likes the idea.

rmax: Another useful return value (maybe even closer to functional rmax - Another useful return value (maybe even closer to functional programming) could be the unprocessed part of the list if a break occured in the loop body.

foreach {a b c} $args break
set args [lrange $args 3 end]

This could be done easier and would be less error prone if foreach returned the This could be done easier and would be less error prone if foreach returned the tail of the list:

set args [foreach {a b c} $args break]

Of course, this feature can only work in a useful way if foreach was called Of course this feature can only work in a useful way if foreach was called with just one list. RS: This is what lassign (from 8.5, or TclX) does: RS: This is what lassign (from 8.5, or TclX) does:

set args [lassign $args a b c]

SS: Yep rmax, my past idea evolved almost exactly into a new idea similar SS Yep rmax, my past idea evolved almost exactly in what you said.

Actually I'm not sure about many different options:

OPTION 1

foreach always returns the return value of the last command executed, but can be called without the 'script' argument, and in such a case the variables are assigned, and foreach returns the rest of the list, so:

OPTION 1:

foreach always returns the return value of the last command executed, but can be called without the 'script' argument, and in such a case the variables are assigned, and foreach returns the rest of the list, so:

set args [foreach {a b c} $args]

does what your example do.

OPTION 2

foreach always returns the rest of the list (with rest I mean the not processed part). The last argument can be omitted and defaults to break.

OPTION 2:

foreach always returns the rest of the list (with rest I mean the ''not processed part'').  The last argument can be omitted and defaults to break.

set args [foreach {a b c} $args]

is still valid.

OPTION 3

foreach works exactly like today, but works as OPTION 1 when called without the script argument. That's fully backward compatible, but less orthogonal and less powerful.

OPTION 3:

foreach works exactly like today, but works as OPTION 1 when called without the script argument. That's fully backward compatible, but less orthogonal and less powerful.

See also:

• for
• while
• foreach little friends
• for ... in