In bash, how do ${path/foo/bar} and ${path//foo/bar} differ, and what kind of pattern is allowed on the left-hand side?

## The two forms ```bash p=a.b.c echo "${p/./-}" # a-b.c first match only echo "${p//./-}" # a-b-c every match ``` One slash after the parameter name means "replace the first match"; two mean "replace them all". If you have used `sed s/x/y/` versus `s/x/y/g`, the doubled slash is the same idea, and it is the single most commonly asked detail of this expansion. ## Anchored and deleting variants Bash adds two anchors and a deletion form: ```bash url=http://example.com/http-cache echo "${url/#http:/https:}" # https://example.com/http-cache — start only echo "${url/%cache/store}" # http://example.com/http-store — end only echo "${url//-}" # http://example.com/httpcache — delete all matches ``` `${var/#pat/rep}` requires the match to begin at the first character; `${var/%pat/rep}` requires it to end at the last. Without an anchor the pattern floats anywhere in the value. `${var/pat}` and `${var//pat}` — replacement omitted — delete rather than replace, which is a tidy way to strip characters. ## The pattern is a glob This is the fact candidates get wrong. The left-hand side uses the same pattern language as `case` and filename matching, not POSIX ERE and not PCRE. Consequences: - `.` is an ordinary character. `${p//./-}` really does mean "every literal dot", which is why the first example works. - `*` matches any run of characters and is greedy, so `${s/a*b/X}` can swallow far more than you intended. - There are no capture groups and no backreferences: you cannot refer to "the part the pattern matched" the way `\1` does in `sed`. If you need that, you need `sed`, `awk` or bash's `=~` operator with `BASH_REMATCH`, which lives with the conditional-expression material. - Extended patterns such as `@(a|b)` are available only when `shopt -s extglob` is enabled. ## Quoting, and where the pattern comes from Because the pattern is a glob, characters arriving from data can behave as metacharacters. Quoting the pattern inside the expansion turns it back into literal text: ```bash needle='a*b' echo "${s//"$needle"/X}" # matches the three literal characters a * b echo "${s//$needle/X}" # a, anything, b — glob semantics ``` Always wrap the whole expansion in double quotes as well, or the result is subject to word splitting and pathname expansion like any other unquoted expansion. One version note on the replacement side: bash 5.2 added the `patsub_replacement` shell option, enabled by default, under which an unquoted `&` in the replacement text stands for the whole matched portion; write `\&` for a literal ampersand. On bash 5.1 and earlier the `&` is always literal. If your script may run on both, quote the replacement or escape the ampersand so it behaves the same either way. ## What it is good for, and when to stop Substitution shines on short, structural edits of a single value where forking is wasteful or awkward: ```bash safe_name=${branch//\//-} # feature/x -> feature-x for a docker tag key=${var_name//-/_} # normalise a config key csv=${list// /,} # space-separated to comma-separated ``` It stops being the right tool the moment you need alternation, capture groups, case-insensitive matching, or multi-line input. Parameter expansion operates on one shell value; it is not a stream editor. Reaching for `${var//.../...}` to "parse" a log line or an HTML fragment is a smell — that work belongs to `awk` or a real language. ## Non-destructive, like the rest `${p//./-}` yields a new string. `p` still contains `a.b.c` afterwards. Assign if you want to keep it: `p=${p//./-}`. And because the whole thing is a single expansion, it composes: `${1//x/y}` works on a positional parameter, and the result can be fed straight into a command argument without an intermediate variable.