Backreferences in JavaScript regular expressions

Published at
Updated at
Reading time
3 min

This post is part of my Today I learned series in which I share all my learnings regarding web development.

Today I was preparing a slide deck about new features in JavaScript regular expressions and came across the article "Named capture groups" written by Axel Rauschmayer. The section about backreferences caught my eye.

There might be the situation that you're dealing with a regular expression that includes repeated character sequences like the following one: /(abc)(abc)(abc)/. Instead of copying the character groups several times, pattern reuse is a better approach here. It turns out you can do that in JavaScript regular expressions.

#

Backreferences for capture groups

When you define your regular expressions, you can reuse and backreference previous groups via \1, \2, etc..

/(๐Ÿ•)(๐ŸŒฏ)\1\2/.exec('๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ');
// (3) ["๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ", "๐Ÿ•", "๐ŸŒฏ", index: 0, input: "๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ", ... ]
// Match: 
// - a pizza
// - a burrito
// - a pizza (backreferenced)
// - a burrito (backreferenced)

/(๐Ÿ•)(๐ŸŒฏ)\1\2/.exec('๐Ÿ•๐ŸŒฏ๐Ÿ•');
// null (because one burrito is missing)
#

Backreferences for named capture groups

You can do the same for named capture groups via \k<name>.

/(?<one>๐Ÿ•)(?<two>๐ŸŒฏ)\k<one>\k<two>/.exec('๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ');
// (3) ["๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ", "๐Ÿ•", "๐ŸŒฏ", index: 0, input: "๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ", groups: {โ€ฆ}]
// Match:
// - a pizza
// - a burrito
// - a pizza (backreferenced via the named capture group 'one')
// - a burrito (backreferenced via the named capture group 'two')

/(?<one>๐Ÿ•)(?<two>๐ŸŒฏ)\k<one>\k<two>/.exec('๐Ÿ•๐ŸŒฏ๐Ÿ•');
// null (because one burrito is missing)
#

References in string replacements

Arnd Issler pointed out, that you can not talk about backreferences in regular expression without mentioning the references when using String.prototype.replace. So, here we go. ๐Ÿ˜Š

#

Replacement references for capture groups

You can reference included capture groups using $1, $2, etc. in the replacement pattern.

MDN provides a good example to swap words using references.

const re = /(\w+)\s(\w+)/;
const str = 'Jane Smith';
const newstr = str.replace(re, '$2, $1');
console.log(newstr);  // Smith, Jane

To follow the earlier examples you can have a look at the following "pizza-burrito-snippet":

'๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ'.replace(
  /(๐Ÿ•)(๐ŸŒฏ)\1/,
  'first group: $1, second group: $2, rest:'
);
// "first group: ๐Ÿ•, second group: ๐ŸŒฏ, rest:๐ŸŒฏ๐Ÿ•๐ŸŒฏ"

As sequences such as $1 and $2 reference capture groups one might ask how to replace something with $1 without referencing an included capture group. In that case, you can use e.g. $$1.

'๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ'.replace(
  /(๐Ÿ•)(๐ŸŒฏ)\1/,
  '$$1 $$1 $$1 โ€“ '
);
// "$1 $1 $1 โ€“ ๐ŸŒฏ๐Ÿ•๐ŸŒฏ"
#

Replacement references for named capture groups

The same reference functionality works for named capture groups using $<name>:

'๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ'.replace(
  /(?<one>๐Ÿ•)(?<two>๐ŸŒฏ)\k<one>/,
  'first group: $<one>, second group: $<two>, rest:'
);
// "first group: ๐Ÿ•, second group: ๐ŸŒฏ, rest:๐ŸŒฏ๐Ÿ•๐ŸŒฏ"

If you want to replace something with $<name> if there is a named capture group present you can use $$<name>;

'๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ๐Ÿ•๐ŸŒฏ'.replace(
  /(?<one>๐Ÿ•)(?<two>๐ŸŒฏ)\k<one>/,
  '$$<one> $$<one> $$<one> โ€“ '
);
// "$<one> $<one> $<one> โ€“ ๐ŸŒฏ๐Ÿ•๐ŸŒฏ"

I love these things โ€“ if you do, too, you should definitely have a look at other replacement patterns of String.prototype.replace. This method provides more magic than you might think.

Speaking of browser support; you have to be careful. The support for named capture groups is still not great. Babel has you covered though. ๐ŸŽ‰

Ant that's it for today, see you next time. ๐Ÿ‘‹

See null comment.