Concise zsh regular expression parameter expansion to replace the last match of a pattern

Question

Is there any concise zsh regular expression parameter expansion to replace the last match of a pattern?

I know very ugly way of doing it, but I'd prefer a cleaner, more concise syntax:

# param, pattern & replacement are placeholders below for real values
${(*S)param/%pattern(#b)(*)/replacement${match[1]}}

Which enables extended_glob, chooses shortest match, matches the pattern against the end of the value of $param, specifies the pattern, enables back references, saves the text from after the last match of the pattern in a back reference, and then replaces the match with my replacement, using the back reference to reinstate the text from after the match.

Answer 1

If by last occurrence, you mean the last after having scanned for them from left to right like ${param//pattern/replacement} does (which is not what your attempt does), you could do:

set -o extendedglob
param=foobarbazfoofoofoo pattern=foo replacement=replacement

: ${param//(#m)$~pattern}
param[MBEGIN,MEND]=$replacement

A function that replaces the n^th occurrence (possibly counted from the last when n is negative) could be written as:

replace() {
  set -o localoptions -o extendedglob
  local _param=$1 _n=$2 _pat=$3 _repl=$4 _found MATCH MBEGIN MEND
  local -a _b _e
  : ${(P)_param//(#m)$~_pat/${_b[++_found]=$MBEGIN}${_e[_found]=$MEND}}
  (( _n > 0 && _found >= _n )) ||
    (( _n < 0 && - _found <= _n )) &&
    eval $_param'[_b[_n],_e[_n]]=$_repl'
}

To be called for instance as:

replace param -1 $pattern $replacement

Answer 2

There's no explicit way to select the last match. But you can match * followed by your pattern: then your pattern will be the last match, since * matches the longest possible prefix that's followed by your pattern. Use the b globbing flag to gain access to the parts of the matched string in the replacement.

This requires extended_glob to be enabled. With zsh ≥5.9, you can activate it with the * parameter expansion flag.

For example, the following snippet matches a1b2c3d against the pattern (#b)(*)([0-9]). (#b) causes following parenthesized groups to record what they match in $match. (The positions are also available in $mbegin and $mend if you need them.) * matches the longest prefix, so [0-9] matches the last digit. The replacement keeps the prefix matched by *, replaces the digit by something else, and keeps the unmatched suffix, so the snippet outputs a1b2c-d.

setopt extended_glob
a=a1b2c3d
echo ${a/(#b)(*)([0-9])/$match[1]-}'

In zsh ≥5.9, you don't need to make sure that extended_glob is active.

a=a1b2c3d
echo ${(*)a/(#b)(*)([0-9])/$match[1]-}'