100% Free Forever
AI-Powered Learning
Industry Expert Content
Certificates & Badges
Learn At Your Own Pace
Programming

Conditionals in Tcl

Learn how Tcl evaluates branching logic with if/elseif/else, the expr command, comparison operators, and the switch command for multi-way branching.

Control Flow & ProceduresBeginner8 min readJul 10, 2026
Analogies

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.

tcl
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 if command executes its body only when the braced expr condition evaluates true, and its opening brace must stay on the same line as if/elseif/else.
  • elseif chains are evaluated top to bottom; only the first branch whose condition is true runs, and the rest are skipped entirely.
  • Use ==/!= for numeric comparisons and eq/ne for 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 in operator tests list membership, e.g. $x in {"a" "b" "c"}, as a compact alternative to chained || comparisons.
  • switch supports -exact (default), -glob, and -regexp matching modes, plus a default arm and - for fallthrough.

Practice what you learned

Was this page helpful?

Topics covered

#Programming#TclTkStudyNotes#ConditionalsInTcl#Conditionals#Tcl#Elseif#Else#StudyNotes#SkillVeris#ExamPrep