Parameter Expansion Operators

## The four operators Bash can trim the front or back of a string without calling `basename`, `dirname`, `sed` or `cut`. There are exactly four forms: | Form | Trims from | Match length | |---|---|---| | `${var#pattern}` | the front | shortest | | `${var##pattern}` | the front | longest | | `${var%pattern}` | the back | shortest | | `${var%%pattern}` | the back | longest | A useful mnemonic: on a US keyboard `#` is to the left of `$` and `%` is to the right, matching the end of the string each one eats. Doubling the symbol means "be greedy". ## Walking the example With `f=/var/log/app/archive.tar.gz`: ```bash f=/var/log/app/archive.tar.gz echo "${f##*/}" # archive.tar.gz echo "${f#*/}" # var/log/app/archive.tar.gz echo "${f%/*}" # /var/log/app echo "${f%.*}" # /var/log/app/archive.tar echo "${f%%.*}" # /var/log/app/archive ``` - `${f##*/}` — pattern `*/`, longest match from the front is `/var/log/app/`, so what remains is the filename. This is the classic `basename` replacement. - `${f#*/}` — same pattern, shortest match is just the leading `/`, so you get the path minus its first slash. This is the contrast that shows single versus double clearly. - `${f%/*}` — pattern `/*`, shortest match from the back is `/archive.tar.gz`, leaving the directory. The `dirname` replacement. - `${f%.*}` — removes the shortest trailing `.something`, so only `.gz` goes. - `${f%%.*}` — removes the longest trailing `.something`, which starts at the **first** dot in the whole value. That last one carries the trap. `%%.*` is often described as "strip all extensions", but the pattern is applied to the entire value, path included. If any directory name contains a dot — `/opt/app-1.2/data.tar.gz` — then `${f%%.*}` returns `/opt/app-1` and you have silently destroyed the path. Strip the directory first (`base=${f##*/}`) and only then work on extensions. ## Patterns, not regular expressions The right-hand side is the same pattern language bash uses for `case` and for filename matching: `*` matches any string, `?` any single character, `[abc]` a character set. It is **not** a regex, so `.` is a literal dot and there is no `+`, no alternation without extended globs, and no capture groups. Anchoring is implicit: `#` forms are anchored to the start, `%` forms to the end. The pattern is itself subject to expansion, so a variable can supply it — and that is exactly why you quote carefully: ```bash ext=.gz echo "${f%"$ext"}" # quoted: treats the value as literal text ``` Quoting the pattern inside the expansion makes its characters literal rather than glob metacharacters, which matters when the pattern comes from data. ## Non-destructive by design None of these operators modify the variable. `${f%.gz}` produces a new string; `f` still holds the original. To keep the result you assign it: `trimmed=${f%.gz}`. Candidates who expect in-place mutation write loops that never terminate. ## Why prefer this over external tools Every `basename` or `sed` call in a loop is a fork and an exec. In a loop over ten thousand files that is measurable, and it also drags in portability questions about which `sed` you have. Parameter expansion is pure bash, has no argument-length or whitespace hazards, and works on values that are not filenames at all — trimming a `refs/heads/` prefix off a git ref, taking the host out of `host:port`, dropping a trailing slash with `${dir%/}`. The one behavioural difference worth knowing is edge cases: `basename /` prints `/`, while `${f##*/}` on `/` yields the empty string; and `dirname foo` prints `.`, while `${f%/*}` on a bare `foo` (no slash at all) leaves `foo` unchanged, because a pattern that does not match removes nothing. Guard for those when the input can be a bare name or a root path. ## Common uses at a glance ```bash base=${f##*/} # archive.tar.gz stem=${base%%.*} # archive (safe: directory already removed) ext=${base##*.} # gz noslash=${dir%/} # drop one trailing slash if present branch=${ref#refs/heads/} ```