In a JavaScript regular expression, what is the difference between (Mr|Ms) and (?:Mr|Ms), and when would you choose the non-capturing form?
answer
- parentheses do two jobs at once
- grouping versus recording the text
- group numbers come from opening parens
- (?: keeps the result array clean
basics
~20 sBoth parenthesis forms group a sub-pattern so quantifiers and alternation apply to the whole unit. Plain parentheses also capture, adding the matched text to the result array; (?: ... ) groups without capturing, so it never occupies a group number.
solid answer
~40 sParentheses in a JavaScript regex do two jobs: they group a sub-pattern into one unit, and they capture the text that unit matched. `(?:` turns off only the capturing half. Capturing groups are numbered by the order of their opening parenthesis, left to right, and their matched text shows up as `m[1]`, `m[2]`, ... on the match object returned by `exec`. Use `(?:` whenever you only need grouping — for an alternation like `(?:Mr|Ms)` or to apply a quantifier to several tokens — because every unnecessary capture adds a slot you must skip over and, worse, renumbers every group after it the moment someone edits the pattern. Named groups are the third option when a captured value is genuinely meaningful.
code
javascript · 7 linesconst 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' undefinedgo deeper
Know that plain parentheses both group and capture while (?: ... ) only groups, and be able to point at which element of the match result each group fills.
Explain that numbering follows opening parentheses left to right, so inserting one capture renumbers every later group, and that a quantified group retains only its final iteration.
Make the maintenance argument out loud: positional captures couple consumer code to pattern edits, and you promote a value to a named group as soon as more than one capture is meaningful.
Own the convention for patterns that outlive their author — capture only what a caller consumes, prefer named groups in shared patterns, and know when a regex has grown into something that should be a small parser instead.
## 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.
- If a pattern contains no capturing groups at all, what does the match result look like?You still get element `0`, the full matched text, plus the usual `index` and `input` properties — there are simply no numbered elements after it. The `groups` property is `undefined` because `groups` is only created when the pattern declares at least one named group.
- How are groups numbered when they nest, and why does that trip people up?Numbering follows the order of the opening parenthesis, scanning left to right, so an outer group always gets a lower number than the groups inside it. In `/((a)(b))/` the outer group is 1, `a` is 2, `b` is 3. People expect completion order or innermost-first, and read the wrong slot.
- What does /(\d)+/ capture in group 1 when it matches "123", and how do you capture the whole run instead?Group 1 holds `'3'`. The group is entered three times and its capture is overwritten each iteration, so only the last one survives. Move the quantifier inside the group — `/(\d+)/` — to capture `'123'` as a single unit.
saying these in an interview costs you the question
- Thinks (?: changes what text the pattern matches
- Says non-capturing groups exist mainly for speed
- Believes group numbers follow closing parentheses or nesting depth
- Expects a repeated group to collect every iteration
- Assumes an unmatched group yields an empty string