switch

Synopsis  edit

switch ?options? string pattern body ?pattern body ...?

switch ?options? string {pattern body ?''pattern body ...?}

Documentation  edit

official reference

See Also  edit

ranged switch

a range-aware lookalike to switch

switch-regexp

switch with regexp variable capturing

Description  edit

switch -- $foo {...}  ;# robust for all values of foo

Examples  edit

wordparts

illustrates both -regexp and -matchvar options

Attempts to get Substition in the Single-Argument Syntax  edit

switch $::errorCode {
    $NOTFOUND {
        puts {page not found}
    }
    default {
        puts "Program encountered code $::errorCode"
        break
    }
}

switch $::errorCode [sl {
    #todo: offer a list of similar pages
    $NOTFOUND {
        puts {page not found}
    }
    default {
        puts "Program encountered code $::errorCode"
        break
    }
}]

switch $::errorCode "
    $NOTFOUND {
        puts "page not found "
    }
    default {
        puts "Program encountered code $::errorCode"
    }
"

# GOTCHA - You're dead no matter what you do
set TriggerBomb 0
set DefuseBomb 1
set WaitAMinuteWhileIThinkThisThrough 2
set Action $WaitAMinuteWhileIThinkThisThrough
interp alias {} SendToBomb {} puts
switch $Action "
    $TriggerBomb {
        set result [SendToBomb boom]
    }
    $DefuseBomb {
        set result [SendToBomb shutdown]
    }
"

set NOTFOUND value
set errorCode nonsense

switch -- $::errorCode \
    $NOTFOUND {
        puts {page not found}
    } \
    default {
        puts "Program encountered code $::errorCode"
    }

if {$::errorcode eq $NOTFOUND} {
    puts {page not found}
} else {
    puts "Program encountered code $::errorCode"
}

switch -- $::errorCode $NOTFOUND {
    puts {page not found}
} $value1 {
   puts blah
} default {
   puts "Program encountered code $::errorCode"
}

if 0 {
} elseif {$state eq $INIT_STATE} {
   puts init
} elseif {$state eq $CLEANING_STATE} {
   puts cleaning
} elseif {$state eq $DONE_STATE} {
   puts done
}

proc dispatch {thevar args} {
    set pass1 [uplevel subst $args]
    set pass2 "switch \$$thevar \{ $pass1 \}"
    uplevel $pass2
}

set INIT_STATE init
set CLEANING_STATE cleaning
set DONE_STATE done

set state $INIT_STATE

dispatch state {
    $INIT_STATE {
        puts init
        set nextstate $DONE_STATE
    }
    $CLEANING_STATE {
        puts cleaning
    }
    $DONE_STATE {
        puts done
    }
    default {
    }
}
puts "next state $nextstate"

set INIT_STATE init
set CLEANING_STATE cleaning
set DONE_STATE done

dict set body [list $INIT_STATE] {
    puts init
    set nextstate $DONE_STATE
}
dict set body [list $CLEANING_STATE] {
    puts cleaning
}
dict set body [list $DONE_STATE] {
    puts done
}
dict set body default {
}

set state $INIT_STATE

switch $state $body

puts "next state $nextstate"

-regexp and default  edit

set a x
switch -regexp -- $a {
    y {
        puts y
    }
    {} {
        puts z
    }
    
    default {
        puts $a
    }
}

z

Match Abbreviations  edit

switch -regexp -- $variable {
    -h(e(lp?)?)?             {...}
    -h|-he|-hel|-help|-ayuda {...}
    -\\? {...}                     ;$ Match -? flag
    {(?x) - | -h | -help} {do stuff} ;# extended RE syntax
}

switch -- $variable {
    -h - -he - -hel - -help {...}
}

switch -- $variable {
    -h    - 
    -he   - 
    -hel  - 
    -help {...}
}

-regexp and backrefs  edit

switch -regexp -- $somevar {
    {^(\S+)\s+(\S+)} {puts "You hit matches $1 and $2"}
    {^(\d+)\s+(\d+)} {puts "You hit number matches $1 and $2"}
}

if {[regexp {^(\S+)\s+(\S+)$} $somevar -> part1 part2]} {
     puts "You hit matches $part1 and $part2"
} elseif {[regexp {^(\d+)\s+(\d+)} -> part1 part2]} {
     puts "You hit number matches $part1 and $part2"
}

Delimiting the Options  edit

set arg {something entered by the user}
switch $arg {
    --first_thing {do something}
    --second_thing {do something else}
    default {do the last thing}
}

bad option "--first_thing": must be -exact, -glob, -regexp, or --

wrong # args: should be "switch ?switches? string pattern body ... ?default body?"

% lsearch -foo -bar
-1

% regexp -foo -bar
bad switch "-foo": must be -all, -about, -indices, -inline, -expanded, -line, -linestop, -lineanchor, -nocase, -start, or --

break  edit

invoked "break" outside of a loop
    while executing
"switch 

while 1 {
    switch $cond {
        case1 {
           if {$fault} {puts NG; break}
           puts OK
        }
        default {
           puts OK
        }
    }
    break
}

switch -glob -- foo \
    f* {puts match1} \
    *o* {puts match2} \
    default {puts nomatch}

switch -glob -- $string \
    f* {puts foo}
    b* {puts bar}
    *z* {# do nothing}
    default {puts {something else}}

switch $variable {
case1 {do this; break}
case2 {do that; break}
case3 {if today is Monday, do the other; break; if tomorrow is the 14th, do something else; break;}
default {if an error, say so and break; do the last thing, break;}

Using the Return Value of switch  edit

proc is x {set x}

foreach num {0 1 2 3 4 5 6 7 8 9} {
    set type [switch -- $num {
        1 - 9         {is odd}
        2 - 3 - 5 - 7 {is prime}
        0 - 4 - 6 - 8 {is even}
    }]
    puts "$num is $type"
}

0 is even
1 is odd
2 is prime
3 is prime
4 is even
5 is prime
6 is even
7 is prime
8 is even
9 is odd

History  edit

Advice wanted: "case" command and regexps

Compilation Notes  edit

Bug: -indexvar Indexes Off By One  edit

% set line {foo bar}
foo bar
% regexp -inline -indices foo $line
{0 2}
% switch -regexp -indexvar index -- $line foo {set index}
{0 3}

Comments in Switch Statements  edit

switch $x {
    1 {
        #comment goes here
        ...
    }
    2 {
        #comment goes here
        ...
    }
}

switch -exact -- $test {
    # Comment for first block
    Test1 {do stuff...}
    Test2 {do stuff...}
  
    # Comment for second block
    Test3 {do stuff...}
    Test4 {do stuff...}
  
    # Comment for default
    NONE -
    default {SomeCleanUpProc...}
}

   "extra switch pattern with no body, this may be due to a comment incorrectly placed outside of a switch body - see the "switch" documentation"

switch -exact -- $test {
    COMMENT {# Comment for first block}
    Test1 {do stuff...}
    Test2 {do stuff...}
  
    COMMENT {# Comment for second block}
    Test3 {do stuff...}
    Test4 {do stuff...}
  
    COMMENT {# Comment for default}
    NONE -
    default {clean up stuff...}
} 

Numeric Comparison  edit

set number 0x5
switch -- $number {
    5       {puts five!}
    default {puts unknown}
}

set number 0x5
switch -- [format %d $number] {
5       {puts five!}
default {puts unknown}
}

Performance of -regexp  edit

switch -exact -- $value {
    a - b - c match
}

switch -regexp -- $value {
    [abc] match
}

switch -regexp -- $value {
   ^[abc]$ {match}
}

proc exact value {
    switch -exact -- $value {
        a - b - c {return true}
        default {return false}
    }
}

proc re value {
    switch -regexp -- $value {
        [abc] {return true}
        default {return false}
    }
}

proc first value {
    return [expr {[string first $value abc] != -1}]
}

proc multi {type value} {
    for {set i 0} {$i < 100} {incr i} {
        $type $value
    }
}

foreach type {exact re first} {
    foreach value {a b c d} {
        puts "$type $value [errortime {multi $type $value} 10000 100]"
    }
}

exact a 66 +/- 0 microseconds per iteration
exact b 67 +/- 0 microseconds per iteration
exact c 67 +/- 0 microseconds per iteration
exact d 66 +/- 0 microseconds per iteration
regexp a 151 +/- 0 microseconds per iteration
regexp b 140 +/- 0 microseconds per iteration
regexp c 142 +/- 0 microseconds per iteration
regexp d 121 +/- 0 microseconds per iteration
first a 71 +/- 0 microseconds per iteration
first b 71 +/- 0 microseconds per iteration
first c 71 +/- 0 microseconds per iteration
first d 70 +/- 0 microseconds per iteration

An Implementation in Tcl  edit

proc switch_8.5 args} {
    ## this is an 8.4 version of the 8.5 switch (incomplete)
    if {[llength $args] < 2} {
        error "usage: switch ?options? string {pattern body ?pattern body ...?}"
    }
    set type exact
    while {[string match -* [lindex $args 0]]} {
        set option [lindex $args 0]
        set args [lrange $args 1 end]
        switch -- $option {
            -exact    {set type exact}
            -nocase   {set type nocase}
            -glob     {set type glob}
            -regexp   {set type regexp}
            -matchvar {set matchvar [lindex $args 0]; set args [lrange $args 1 end]}
            -indexvar {error "unimplemented"}
            -- break
            default {error "bad switch option=$option"}
        }
    }
    set string [lindex $args 0]
    if {[llength $args] == 2} {
        set body [lindex $args 1]
    } else { 
        set body [lrange $args 1 end]
    }
    switch -- $type {
        exact  {error unimplemented}
        nocase {error unimplemented}
        glob   {error unimplemented}
        regexp {
            foreach {rexp script} $body {
                if {$rexp eq {default}} {
                    uplevel 1 $script
                    break
                }
                if {[regexp -- $rexp $string match 1 2 3 4 5 6 7 8 9]} {
                    if {[info exists matchvar]} {
                        upvar $matchvar m
                        set m [list $match $1 $2 $3 $4 $5 $6 $7 $8 $9]
                        uplevel 1 $script
                        unset m
                    } else {
                        uplevel 1 $script
                    }
                    break
                }
            }
        }
        default {error "internal type=$type error"}
    }
}

A Dynamic switch  edit

an expandable switch statements

set switch {
   a*b     -
   b       {expr 1}
   a*      {expr 2}
   default {expr 3}
}

switch -glob aaab $switch

set switch [linsert $switch end-2 c {expr 4}]

switch -glob c $switch

set defs {
    a*b     -
    b       {expr 1}
    a*      {expr 2}
}

switch -glob -- $value {*}$defs default {
    expr 3
}

lappend defs c {expr 4}

A Misunderstanding  edit

set foo abc
switch abc a - b {expr 1} $foo {expr 2} default {expr 3}

switch abc {a - b} {expr 1} $foo {expr 2} default {expr 3}

Discussion  edit

#! /usr/tcl84/bin/tclsh

set ::expert no
set ::usage "USAGE: $argv0 arg1 arg2"
set ::val XYZ

foreach i $::argv {
    switch -exact -- $i in {
        ! {
            if {$::expert eq {no}} {
                set ::expert yes
            } else {
                puts $::usage
                exit 1
            }
        }
        1 {set $::val 1}
        default {
               puts {** Too many values specified **}
               puts {You will be prompted for the information **}
               set ::expert no
        }
    }
}

puts $::expert
puts $::val
$ ts.tcl 1 2 !
no
XYZ

no 
** Too many values specified **
You will be prompted for the information **
1

switch -exact -- $i in {
                    ^^

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References