Regular expressions

Regular expressions are a important concept in formal language theory. They are a way to describe a possibly infinite set of character strings (called a language). A regular expression, at its core, needs the following features:

• A set of characters that can be used in the language, called the alphabet.
• Concatenation: ab means "the character a followed by the character b".
• Union: a|b means "either a or b".
• Kleene star: a* means "zero or more a characters".

Assuming a finite alphabet (such as the 26 letters of the English alphabet, or the entire Unicode character set), all regular languages can be generated by the features above. Of course, many patterns are very tedious to express this way (such as "10 digits" or "a character that's not a space"), so JavaScript regular expressions include many shorthands, introduced below.

A regular expression is typically created as a literal by enclosing a pattern in forward slashes (/):

const regex1 = /ab+c/g;

Regular expressions can also be created with the RegExp() constructor:

const regex2 = new RegExp("ab+c", "g");

They have no runtime differences, although they may have implications on performance, static analyzability, and authoring ergonomic issues with escaping characters. For more information, see the RegExp reference.

Flags are special parameters that can change the way a regular expression is interpreted or the way it interacts with the input text. Each flag corresponds to one accessor property on the RegExp object.

The sections below list all available regex syntaxes, grouped by their syntactic nature.

Assertions are constructs that test whether the string meets a certain condition at the specified position, but not consume characters. Assertions cannot be quantified.

Input boundary assertion: ^, $

Asserts that the current position is the start or end of input, or start or end of a line if the m flag is set.

Lookahead assertion: (?=...), (?!...)

Asserts that the current position is followed or not followed by a certain pattern.

Lookbehind assertion: (?<=...), (?<!...)

Asserts that the current position is preceded or not preceded by a certain pattern.

Word boundary assertion: \b, \B

Asserts that the current position is a word boundary.

Atoms are the most basic units of a regular expression. Each atom consumes one or more characters in the string, and either fails the match or allows the pattern to continue matching with the next atom.

Backreference: \1, \2

Matches a previously matched subpattern captured with a capturing group.

Capturing group: (...)

Matches a subpattern and remembers information about the match.

Character class: [...], [^...]

Matches any character in or not in a set of characters.

Character class escape: \d, \D, \w, \W, \s, \S

Matches any character in or not in a predefined set of characters.

Character escape: \n, \u{...}

Matches a character that may not be able to be conveniently represented in its literal form.

Literal character: a, b

Matches a specific character.

Named backreference: \k<name>

Matches a previously matched subpattern captured with a named capturing group.

Named capturing group: (?<name>...)

Matches a subpattern and remembers information about the match. The group can later be identified by a custom name instead of by its index in the pattern.

Non-capturing group: (?:...)

Matches a subpattern without remembering information about the match.

Unicode character class escape: \p{...}, \P{...}

Matches any character in or not in a set of Unicode characters identified by a Unicode property.

Wildcard: .

Matches any character except line terminators, unless the s flag is set.

These features do not specify any pattern themselves, but are used to compose patterns.

Disjunction: |

Matches any of a set of alternatives separated by the | character.

Quantifier: *, +, ?, {n}, {n,}, {n,m}

Matches an atom a certain number of times.

• Regular expressions guide
• RegExp