In a bash script you write `case "$1" in start|stop) A ;; *.log) B ;; *) C ;; esac`. How does bash compare the word to each pattern, and what happens when more than one pattern could match?

## What a case statement actually does `case` is a compound command that takes one word, expands it, and then walks its clauses in the order you wrote them, comparing the expanded word against each clause's pattern. The first pattern that matches wins: bash runs that clause's command list and, with the ordinary `;;` terminator, jumps straight past `esac`. No other pattern is tested and no other clause runs. Almost everything candidates get wrong about `case` follows from missing that one sentence. The shape is: ```bash case "$1" in start|restart) echo "bringing the service up" ;; stop) echo "bringing it down" ;; *.log) echo "that looks like a log file" ;; *) echo "unrecognised: $1" ;; esac ``` Each clause is `pattern[|pattern...]) command-list ;;`. The `|` inside a clause is alternation that belongs to the `case` grammar — it is not a pipeline and it starts no subshell. A leading `(` is also legal (`(start|restart)`), and people use it so that a `case` nested inside `$( )` stays readable to editors that count parentheses. ## Globs, not regular expressions The patterns use shell pattern-matching syntax — the same grammar as filename globbing — not regular expressions. `*` matches any string including the empty one, `?` matches exactly one character, and a bracket expression such as `[0-9]` matches one character from the set. Everything else is literal. So in a `case` pattern: - `.` is a literal dot, not "any character"; - `a*` means "an `a` followed by anything", not "zero or more `a`"; - `^` and `$` are ordinary characters with no anchoring meaning; - `+` and `{2,3}` are literal text. A candidate who reads `[0-9]*` as a regex will tell you it matches a repeated digit; it actually matches any word that *begins* with a digit. If you have enabled `shopt -s extglob`, the extended pattern forms are available in `case` patterns too, but the pattern grammar itself is a topic of its own — for `case` the point is simply that it is a pattern, never a regex. ## The match is anchored at both ends Unlike `grep`, which reports a hit anywhere in the line, a `case` pattern must consume the whole word. `case restart in start) ...` does not match; `case restart in *start*) ...` does. This bites people who port a `grep`-style condition into a dispatcher and quietly lose a branch. ## Order is the control flow Because the first match wins, the order in which you list clauses *is* the program logic. Put the specific patterns above the general ones: a `report.log` clause below a `*.log` clause is dead code, because `*.log` will always be reached first. The conventional last clause is `*)`, which matches anything and therefore acts as the default branch. Writing `*)` first turns every remaining clause into dead code, and bash issues no warning at all — it is a perfectly legal `case`, it just never gets past the first pattern. ## Case-insensitive matching Two idiomatic ways to accept `Y` as well as `y`: ```bash shopt -s nocasematch case $answer in yes|y) echo "confirmed" ;; esac shopt -u nocasematch ``` `nocasematch` is a bash `shopt` that affects `case` (and `[[`) matching, so enable it narrowly and turn it back off. The alternative is to normalise the word before matching — `case ${answer,,} in yes|y)` — using the lowercasing expansion available from bash 4.0 onward. ## Why reach for case at all A chain of string comparisons that all test the *same* word is exactly what `case` is for. One word, many patterns, a visible default, and glob matching built in — no repeated variable name, no repeated test command, and a shape that a reviewer can scan in one pass. That is why the subcommand dispatchers in real init scripts, entrypoints and CLI wrappers are nearly always a `case`.