Backreference: \1, \2

A backreference refers to the submatch of a previous capturing group and matches the same text as that group. For named capturing groups, you may prefer to use the named backreference syntax.



Note: N is not a literal character.



A positive integer referring to the number of a capturing group.


A backreference is a way to match the same text as previously matched by a capturing group. Capturing groups count from 1, so the first capturing group's result can be referenced with \1, the second with \2, and so on. \0 is a character escape for the NUL character.

In case-insensitive matching, the backreference may match text with different casing from the original text.

/(b)\1/i.test("bB"); // true

The backreference must refer to an existent capturing group. If the number it specifies is greater than the total number of capturing groups, a syntax error is thrown.

/(a)\2/u; // SyntaxError: Invalid regular expression: Invalid escape

In Unicode-unaware mode, invalid backreferences become a legacy octal escape sequence. This is a deprecated syntax for web compatibility, and you should not rely on it.

/(a)\2/.test("a\x02"); // true

If the referenced capturing group is unmatched (for example, because it belongs to an unmatched alternative in a disjunction), or the group hasn't matched yet (for example, because it lies to the right of the backreference), the backreference always succeeds (as if it matches the empty string).

/(?:a|(b))\1c/.test("ac"); // true
/\1(a)/.test("a"); // true


Pairing quotes

The following function matches the title='xxx' and title="xxx" patterns in a string. To ensure the quotes match, we use a backreference to refer to the first quote. Accessing the second capturing group ([2]) returns the string between the matching quote characters:

function parseTitle(metastring) {
  return metastring.match(/title=(["'])(.*?)\1/)[2];

parseTitle('title="foo"'); // 'foo'
parseTitle("title='foo' lang='en'"); // 'foo'
parseTitle('title="Named capturing groups\' advantages"'); // "Named capturing groups' advantages"

Matching duplicate words

The following function finds duplicate words in a string (which are usually typos). Note that it uses the \w character class escape, which only matches English letters but not any accented letters or other alphabets. If you want more generic matching, you may want to split the string by whitespace and iterate over the resulting array.

function findDuplicates(text) {
  return text.match(/\b(\w+)\s+\1\b/i)?.[1];

findDuplicates("foo foo bar"); // 'foo'
findDuplicates("foo bar foo"); // undefined
findDuplicates("Hello hello"); // 'Hello'
findDuplicates("Hello hellos"); // undefined


ECMAScript Language Specification
# prod-DecimalEscape

Browser compatibility

BCD tables only load in the browser

See also