Regex Questions That Actually Get Asked

There are four worth knowing, and they differ in what they return. The test method returns a boolean. The match method returns an array of matches, or the first match with capture groups when the pattern has no global flag. The matchAll method returns an iterator over every match, which is the modern replacement for the global match method. The replace and replaceAll methods substitute matched text.

const text = "order-1234, order-5678";

console.log(text.match(/\d+/g));        // ["1234", "5678"]
console.log(text.match(/\d{4}/));       // ["1234", "5678"] - first match only
console.log(text.replace(/\d+/g, "#"));  // "order-####, order-####"
console.log(text.split(/,\s*/));        // ["order-1234", "order-5678"]
console.log(/^order/.test(text));       // true
console.log(/\d{5}/.test(text));       // false

The difference between match with and without the global flag catches people out. Without the flag, match returns an array where the first element is the whole match and the rest are the capture groups. With the flag, it returns an array of the full matches only, with no group information. If you want the groups from every match, use matchAll, which always gives you the full match plus the groups for each one.

The split method is also more useful with a pattern than people realise. Splitting on a regular expression matching any run of whitespace is a better way to normalise a sentence than splitting on a single space, because it also handles tabs and repeated spaces without producing empty strings.

One last thing about the replace method. With a string pattern it replaces only the first match, while with a regular expression it replaces only the first match too unless you add the global flag. The replaceAll method always replaces everything, and it also accepts a regular expression, in which case the global flag is not needed.

Both match as much as they can or as little as they can. A greedy quantifier takes the longest possible match, and a lazy quantifier takes the shortest possible one that still lets the rest of the pattern succeed. The lazy version is written with a question mark after the quantifier.

The classic example is matching inside a pair of tags. With a greedy pattern, the match runs from the first opening tag to the last closing tag, swallowing everything in between. With the lazy version, it stops at the first closing tag. That difference is the entire reason you choose one over the other.

The same applies to the other quantifiers. A greedy star matches as many characters as possible, a lazy star matches as few as possible, and the same split exists between the plus and the question mark forms.

The practical guidance is that you almost always want the lazy version when you are matching a delimited region, because you usually want the nearest closing delimiter. Greedy is what you want when you are deliberately capturing the widest span, such as matching everything between the first and last marker in a log file.

There is a performance angle as well. A greedy quantifier on a failing pattern can backtrack through a huge number of possibilities before giving up, and a classic example of catastrophic backtracking is a greedy or lazy pattern applied to a long run of the same character followed by a character that does not match. Anchoring the pattern and keeping it simple avoids that.

Named capture groups give you a name instead of a numbered index, which makes a regular expression far easier to read and to maintain. A backreference lets a pattern match text that has already appeared earlier in the same string.

const log = "2026-03-01 user=ada action=login";

// Named capture groups.
const datePattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = log.match(datePattern);

console.log(match.groups.year);    // "2026"
console.log(match.groups.month);   // "03"
console.log(match.groups.day);     // "01"

// Backreferences.
const doubled = /(\w)\1/;
console.log(doubled.test("aab"));   // true
console.log(doubled.test("abc"));   // false

// Reference a named group in a replacement.
console.log(log.replace(datePattern, "$<day>/$<month>/$<year>"));
// "01/03/2026 user=ada action=login"

Named groups are declared with a question mark followed by a name in angle brackets, inside the capturing parentheses. They are read from the groups property of the match result, and you can also refer to them in a replacement string using the dollar sign and the angle bracket syntax. That is a large improvement over remembering that group two is the month and group three is the day.

A backreference is a backslash followed by a group number, or a group name. The pattern in the example looks for any word character immediately followed by an identical one, which is a neat way to detect a doubled letter.

Named groups also help with the replace method, where a numbered backreference is written as a dollar sign and a number. One gotcha to know is that when a pattern contains named groups, the numbered references are disabled, so mixing the two styles in one pattern is an error.