In bash, what does `if` actually evaluate — for example in `if grep -q ERROR app.log; then ...` — and what does the `!` do in `if ! grep -q ERROR app.log`?

## `if` takes a command, not a condition The grammar of the statement is: ```bash if list; then list; [elif list; then list;]... [else list;] fi ``` Every slot is a **command list** — one or more commands. Bash executes the list after `if`, takes the exit status of the *last* command in that list, and branches: `0` runs the `then` list; anything non-zero moves on to `elif`, then `else`, then falls out of the statement. There is no boolean type in the language, no expression parser, and no truthiness rule for strings. A conditional in bash is literally "run this, then look at the number it returned". Internalising that sentence explains almost every surprise beginners hit with shell conditionals. ## Consequences worth stating in an interview **Any command can be a condition.** These are all ordinary, idiomatic bash: ```bash if grep -q ERROR app.log; then echo "errors present"; fi if ping -c1 -W1 db.internal >/dev/null 2>&1; then echo up; fi if mkdir /var/lock/mine 2>/dev/null; then echo "got the lock"; fi ``` The third is instructive: `mkdir` is being used purely for its status, and its output is discarded. Commands that print nothing and exist to report a yes/no answer — the `-q` family of flags — exist precisely because the shell branches on status. **The bracket forms are commands as well.** `[ ... ]` is an ordinary command whose final argument is `]`, and `[[ ... ]]` is a shell keyword; the differences between them are a topic of their own. What matters here is that `if` does not know or care which one you used — it applies the same "run it, read the status" rule to both, which is why they slot into the same position as `grep`. **Multiple commands in the condition are legal.** `if cd /srv/app && ./health.sh; then` runs both and branches on the status of the whole list. Only the final status decides the branch, so keep the condition list short and readable. **Testing `$?` explicitly is a smell.** Because the value of `$?` is replaced by every completed command, `cmd; echo "ran"; if [ $? -eq 0 ]` silently tests `echo`. Putting the command inside the `if` removes the whole failure mode. ## What `!` does `!` is the shell's negation operator for a pipeline or list: it runs the thing, then flips the status. `0` becomes `1`, and *any* non-zero becomes `0` — note that the specific failure code is lost, so `!` is a boolean inverter, not a code translator. ```bash if ! grep -q ERROR app.log; then echo "log is clean" fi ``` This reads better than an empty `then` branch with the real work in `else`, and it composes with anything: `if ! command -v jq >/dev/null; then echo "jq is required" >&2; exit 1; fi` is the standard dependency-check idiom. Note that `!` must be a separate word — `!command` is not negation, and inside a double-quoted string `!` may be interpreted by history expansion in an interactive shell, though scripts are unaffected. ## The status of the `if` statement itself The compound statement produces its own exit status: that of the last command executed in whichever branch ran. If no branch runs — the condition failed and there is no `else` — the `if` statement's status is `0`. This surprises people who expect a failed condition to make the `if` "fail"; it does not, and that is deliberate, because a conditional that took the non-match path has not itself gone wrong. One related interaction is worth naming and no more: a command used as an `if` condition is exempt from the abort-on-error behaviour of `set -e`, which is why strict-mode scripts can still test commands that are allowed to fail. The detail of that exemption belongs to strict mode and error handling. ## Style notes Prefer `if ! cmd; then` over an inverted comparison against `$?`. Prefer running the actual command over asking a second command about it — `if [ -d "$dir" ]` when you truly want a file test, but `if cd "$dir"` when you were going to change into it anyway and care whether that worked. And keep the condition free of side effects that a reader would not expect, because the condition list really does execute. ## What to say in an interview "`if` runs a command and branches on its exit status — 0 takes the then branch. There is no boolean expression type; the bracket forms are themselves commands. `!` inverts the status, so `if ! cmd` runs the then branch when the command fails."