In a bash script, what do the test operators -e, -f, -d, -s and -r check about a path, and why can `[ -e "$p" ]` be true while `[ -f "$p" ]` is false for the same path?

## What you are actually calling `[` is not punctuation and it is not part of `if`. It is the `test` builtin wearing a different name, and it requires a closing `]` as its final argument. `[ -f "$p" ]` and `test -f "$p"` are the same call. Everything below is therefore an *argument* the shell hands to that command after it has finished expanding your variables, which is why quoting matters even in the simplest file check. A file test asks the operating system for the metadata of the path and answers yes (exit status 0) or no (exit status 1). A path that does not exist is not an error — it is simply a false answer. ## The operators you will use daily - `-e path` — true if the path exists, whatever kind of thing it is. - `-f path` — true only for a **regular file**: not a directory, not a device node, not a socket or FIFO. - `-d path` — true only for a directory. - `-s path` — true if the path exists **and its size is greater than zero**. - `-r path` — true if the path is readable by the effective user of the running process; `-w` and `-x` are the same idea for write and execute. Bash has more of them — `-L` (or `-h`) for a symlink, `-p` for a named pipe, `-S` for a socket, `-t` for "this file descriptor is a terminal" — but the five above cover almost every guard you will write. ## Exists versus is-a-file This is the crux of the question. `-e` answers a question about *existence*; `-f` answers a question about *type*. `/etc` exists, so `[ -e /etc ]` succeeds, but it is a directory, so `[ -f /etc ]` fails. The same split catches `/dev/null`, which exists and is readable but is a character device, not a regular file. The practical rule: use the operator that matches what you are about to do. About to read a config file? `-f`. About to `cd` into something or write inside it? `-d`. Use `-e` only when you genuinely mean "is there anything at all here", for example before refusing to clobber a path. ```bash [ -f "$config" ] || { echo "no config at $config" >&2; exit 1; } [ -d "$outdir" ] || mkdir -p "$outdir" ``` ## Symlinks are followed `-e`, `-f`, `-d`, `-s` and the permission tests all resolve symlinks and report on the **target**. A symlink whose target has been deleted is therefore false for `-e`, which surprises people who expect "the link file is right there". `-L` is the one that reports on the link itself, so the idiom for a broken link is: ```bash if [ -L "$p" ] && [ ! -e "$p" ]; then echo "dangling symlink: $p"; fi ``` ## Empty versus missing `-s` is the operator people forget, and it is the one that distinguishes the two failure modes of a job that produces output: the file is missing (nothing ran) versus the file is there but zero bytes (something ran and produced nothing). `[ -f "$out" ] && [ ! -s "$out" ]` is "the file exists and is empty". Note that `-s` on its own is not a file test: directories normally report a non-zero size, so pair it with `-f` when you mean an empty *file*. ## Permission tests are advisory `-r`, `-w` and `-x` answer for the effective user, at that instant. Two consequences. First, the answer is user-specific: a check that passes when you run the script by hand tells you nothing about the service account that runs it from cron. Second, it is a snapshot — between the test and the open, the file can be replaced, the mode can change, or the filesystem can be remounted read-only. For anything that matters, prefer attempting the operation and handling the failure over testing first: ```bash if ! exec 3>"$logfile"; then echo "cannot write $logfile" >&2; exit 1; fi ``` ## Quote the operand Every example above quotes `"$p"`, and that is not decoration. `[` receives its arguments after the shell has split them on whitespace, so `[ -f $p ]` with `p='my file.txt'` becomes a three-argument call that fails with a parse complaint rather than a useful answer. Inside a bash-only script `[[ -f $p ]]` is immune to that, but the habit of quoting costs nothing and works in both. ## Negation and combination `!` negates a test: `[ ! -d "$p" ]`. To combine, prefer two separate commands joined with `&&` — `[ -f "$p" ] && [ -r "$p" ]` — rather than the older `-a`/`-o` operators inside a single `[ ]`, which are ambiguous when operands can look like operators and are flagged by linters.