Groups, Backreferences, and Lookaround

## Two jobs behind one piece of syntax A pair of parentheses in a JavaScript regular expression does two independent things. It **groups**: the enclosed sub-pattern becomes a single unit, so a quantifier or an alternation bar applies to all of it rather than to the last character. `/ab+/` repeats only `b`; `/(?:ab)+/` repeats the pair. Alternation is the other classic case — `/^(?:cat|dog)$/` anchors both branches, while `/^cat|dog$/` does not. It **captures**: the text the unit matched is recorded and handed back with the match result. That is the half `(?:` switches off. ## What capturing actually produces `RegExp.prototype.exec` returns an array-like match object. Element `0` is the entire matched substring; elements `1`, `2`, `3`, … are the substrings matched by the capturing groups. Group numbers are assigned by the position of the **opening** parenthesis, counted left to right through the whole pattern, nesting included — so in `/((a)(b))/` group 1 is the outer group, group 2 is `a`, group 3 is `b`. ```js const withCapture = /(Mr|Ms)\.\s(\w+)/; const a = withCapture.exec('Mr. Smith'); console.log(a[1], a[2]); // 'Mr' 'Smith' const noCapture = /(?:Mr|Ms)\.\s(\w+)/; const b = noCapture.exec('Mr. Smith'); console.log(b[1], b[2]); // 'Smith' undefined ``` The second pattern still needs the parentheses — without them `Mr|Ms\.\s(\w+)` would mean "`Mr`, or `Ms` followed by a dot" — but it does not need the captured value, so `(?:` keeps the honorific out of the result and slides the surname down to `m[1]`. ## Why numbering fragility is the real argument The cost of a stray capture is not memory, it is coupling. Consumer code reads positions: `m[1]`, `m[2]`. Add one capturing group near the front of a pattern six months later and every position after it shifts by one, silently. Nothing throws; the code just starts reading the wrong field. Patterns that capture only what a caller consumes are far more resistant to that edit. This is also why named groups exist: `(?<surname>\w+)` gives the value a stable identity that survives renumbering entirely. ## A quantified group keeps only the last iteration A subtlety worth having ready: repeating a capturing group does not accumulate the repetitions. The group's stored capture is overwritten on each iteration, so only the final one survives. ```js console.log(/(\w)+/.exec('abc')[1]); // 'c' — last iteration wins console.log(/(\w+)/.exec('abc')[1]); // 'abc' — quantifier inside the group ``` If you want the whole run, put the quantifier **inside** the group. If you want each item separately, you need repeated matching, not a repeated group. ## Nesting and the empty-match case Groups nest freely, and an inner group is numbered after the outer one that contains it. A group that is present in the pattern but never participates in the successful match — for example the untaken branch of an alternation, or an optional group that matched nothing — yields `undefined` in the result array, not an empty string. That distinction matters when you feed captured values straight into string concatenation. ## Performance, honestly stated Non-capturing groups are sometimes sold as an optimisation. In modern engines the difference is negligible for ordinary patterns; capturing means the engine must save and restore a position pair on backtracking, which is real but tiny. Choose `(?:` for clarity and edit-safety and treat any speed benefit as a rounding error. The genuinely expensive regex problems come from backtracking behaviour, not from how many groups you declared. ## Choosing between the three forms A practical rule: use `(?:` by default when you are only grouping; use a plain capturing group when a caller reads the value positionally and the pattern is small; use a named group `(?<name>…)` as soon as the pattern has more than one or two meaningful captures, or when the pattern is likely to be edited by someone who did not write it. The three forms cost the same to type, and the choice is a readability decision that shows up in every line of code that consumes the match.