Understanding Conditionals in Tcl
Tcl's if command evaluates a boolean expression and executes a block of code enclosed in braces when the condition is true. Unlike many languages, Tcl treats if as an ordinary command: the condition and each body are just arguments, which is why the opening brace { of the body must appear on the same line as if -- otherwise Tcl's command parser sees an incomplete command and waits for more input. The condition itself is evaluated by the expr command internally, using C-like operators such as ==, !=, <, and >, as well as string comparison operators like eq and ne.
Cricket analogy: Like the third umpire checking a run-out, where the on-field decision is overturned only if the replay evidence is conclusive, Tcl's if {$condition} {...} only runs its body when the braced expression evaluates true, and the opening brace must sit right after if on the same line or the interpreter keeps waiting for the rest of the command.
The if/elseif/else Construct
Multiple related conditions chain together with elseif: Tcl checks each condition in the order it's written and executes the body of the first one that's true, then skips every remaining elseif and else clause entirely. A trailing else acts as a catch-all body that runs only if none of the preceding conditions matched. Because evaluation stops at the first true branch, the order in which you write your conditions matters -- a more specific condition placed after a broader one that would also match it will never be reached.
Cricket analogy: A bowler chooses their delivery by checking conditions in order: if the batsman is weak against yorkers bowl a yorker, elseif they're susceptible to short balls bowl a bouncer, else fall back to a stock delivery, exactly how Tcl checks elseif branches top to bottom until one matches.
Comparison and Logical Operators in expr
Tcl's expr engine keeps numeric and string comparisons as separate operator families: ==, !=, <, >, <=, and >= coerce their operands to numbers (and error if that's impossible), while eq and ne always compare the raw string representation regardless of whether it looks numeric. The logical operators && and || short-circuit, meaning the second operand is never evaluated once the overall result is already determined by the first, which matters if that second operand has side effects like a command call. Tcl also provides the in operator for compact list-membership tests, e.g. $status in {"open" "pending"}, avoiding a chain of || comparisons.
Cricket analogy: Comparing 'is the total exactly 250' uses a numeric check like a scoreboard reading, while comparing 'is the team name eq "India"' is a string check like matching a jersey label -- Tcl separates numeric == from string eq the same way a scorer separates runs from team names.
The switch Command
The switch command matches a value against a series of patterns and runs the body of the first arm that matches, similar to an if/elseif chain but often more readable for many discrete cases. Its matching mode is controlled by a flag: -exact (the default) requires character-for-character equality, -glob allows wildcard patterns with * and ?, and -regexp allows full regular expressions. A default arm catches anything unmatched, and writing a bare - as an arm's body tells Tcl to fall through and execute the next matching arm's body instead, letting several patterns share one action.
Cricket analogy: Umpire signals form a switch statement in the umpire's head: match exactly for a boundary signal, match a pattern-like gesture for a no-ball, match a raised finger for out, with a default (play on) if nothing matches, just like Tcl's switch falling through to default.
set score 87
if {$score >= 90} {
puts "Grade: A"
} elseif {$score >= 75} {
puts "Grade: B"
} elseif {$score >= 60} {
puts "Grade: C"
} else {
puts "Grade: F"
}
set team "India"
switch -exact -- $team {
"India" { puts "Home team" }
"Australia" -
"England" { puts "Traditional rival" }
default { puts "Other team" }
}Tcl parses if like any other command: it reads arguments until the command is syntactically complete. If you write the opening brace of the body on its own line below if {$cond}, the parser sees an unterminated argument and either hangs waiting for input or throws an error. Always keep { on the same line as if, elseif, and else.
Because expr tries to interpret operands numerically first, if {$x == "5"} works fine when $x holds the string "5", but if {$x == "abc"} throws a 'can't use non-numeric string as operand' error. When you specifically want string comparison, including for non-numeric-looking values, always use eq/ne instead of ==/!=.
- The
ifcommand executes its body only when the bracedexprcondition evaluates true, and its opening brace must stay on the same line asif/elseif/else. elseifchains are evaluated top to bottom; only the first branch whose condition is true runs, and the rest are skipped entirely.- Use
==/!=for numeric comparisons andeq/nefor string comparisons -- mixing them can throw errors or give wrong results. &&and||short-circuit, so Tcl skips evaluating the second operand once the result is already determined.- The
inoperator tests list membership, e.g.$x in {"a" "b" "c"}, as a compact alternative to chained||comparisons. switchsupports-exact(default),-glob, and-regexpmatching modes, plus adefaultarm and-for fallthrough.
Practice what you learned
1. In Tcl, why must the opening brace of an if body appear on the same line as if?
2. What is the difference between == and eq in a Tcl expr?
3. Given switch -glob -- $cmd {"list*" {puts "list command"} default {puts "other"}}, what happens if $cmd is "listlength"?
4. What does a bare - as the body of a switch arm do?
Was this page helpful?
You May Also Like
Loops in Tcl
Master Tcl's while, for, and foreach loops, along with break and continue for controlling repeated execution.
Procedures in Tcl
Learn how to define reusable commands with proc, including default arguments, variable-arity args, return values, scope, and recursion.
String Manipulation in Tcl
Explore Tcl's string command ensemble for measuring, searching, matching, formatting, and building strings.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics