Regular Expressions Cheatsheet

A concise cheatsheet for using Regular Expressions in JavaScript

• Caveats
• API
  • regexp.test(string)
  • string.match(regexp)
  • string.matchAll(regexp)
  • string.replace(regexp, newSubString)
  • string.replace(regexp, callback)
• Syntax
  • Normal characters
  • Whitespace characters
  • Character set
  • Characters that require escaping
  • Quantifiers
  • Boundaries
  • Matching
  • Grouping and capturing
  • Flags
• References and tools

Caveats

• Follows my mental model.
• Intentionally non-comprehensive. Only includes syntax and parts of the API that I actually use.
• Certain concepts are imprecisely defined. (For example, some definitions do not account for characters that are very rarely encountered in input strings.)

API

regexp.test(string)

There should be no capturing groups and no g flag in regexp.

No matches

/y/.test('xx') //=> false

Match

/x/.test('xx') //=> true

(Pitfall) Match, with g flag

regexp.lastIndex may change with each call to regexp.test(string).

const regexp = /x/g
regexp.lastIndex  //=> 0
regexp.test('xx') //=> true
regexp.lastIndex  //=> 1
regexp.test('xx') //=> true
regexp.lastIndex  //=> 2
regexp.test('xx') //=> false
regexp.lastIndex  //=> 0

string.match(regexp)

There should be no capturing groups if there’s also a g flag in regexp.

No matches

'xx'.match(/y/)  //=> null
'xx'.match(/y/g) //=> null

Match

const matches = 'xx'.match(/x/)
matches[0]     //=> 'x'
matches.index  //=> 0
matches.length //=> 1

const matches = 'xx'.match(/x/g)
matches[0]     //=> 'x'
matches[1]     //=> 'x'
matches.index  //=> undefined
matches.length //=> 2

Match, with capturing group, without g flag

const matches = 'xyxy'.match(/x(y)/)
matches[0]     //=> 'xy'
matches[1]     //=> 'y'
matches.index  //=> 0
matches.length //=> 2

(Pitfall) Match, with capturing group, with g flag

Capturing groups in regexp are ignored; returns the matches only.

const matches = 'xyxy'.match(/x(y)/g)
matches[0]     //=> 'xy'
matches[1]     //=> 'xy'
matches.index  //=> undefined
matches.length //=> 2

string.matchAll(regexp)

There should always be a g flag in regexp.

No matches

const iterator = 'xx'.matchAll(/y/g)
const result = []
for (const match of iterator) {
  result.push(match[0])
}
result //=> []

Match

const iterator = 'xx'.matchAll(/x/g)
const result = []
for (const match of iterator) {
  result.push(match[0])
}
result //=> ['x', 'x']

Match, with capturing group

const iterator = 'xyxy'.matchAll(/x(y)/g)
const result = []
for (const match of iterator) {
  result.push([match[0], match[1]])
}
result //=> [['xy', 'y'], ['xy', 'y']]

string.replace(regexp, newSubString)

There should be no capturing groups in regexp.

No matches

'xx'.replace(/y/, 'z')  //=> 'xx'
'xx'.replace(/y/g, 'z') //=> 'xx'

Match

'xx'.replace(/x/, 'z')  //=> 'zx'
'xx'.replace(/x/g, 'z') //=> 'zz'

string.replace(regexp, callback)

No matches

function callback (match) {
  return match.toUpperCase()
}
'xx'.replace(/y/, callback)  //=> 'xx'
'xx'.replace(/y/g, callback) //=> 'xx'

Match

function callback (match) {
  return match.toUpperCase()
}
'xx'.replace(/x/, callback)  //=> 'Xx'
'xx'.replace(/x/g, callback) //=> 'XX'

Match, with capturing group

function callback (_, y) {
  return y.toUpperCase()
}
'xyxy'.replace(/x(y)/, callback)  //=> 'Yxy'
'xyxy'.replace(/x(y)/g, callback) //=> 'YY'

Syntax

Normal characters

Whitespace characters

Character set

• Think of a character set as an OR operation on the single characters that are enclosed between the square brackets.
• Use ^ after the opening [ to “negate” the character set.
• Within a character set, . means a literal period.

Characters that require escaping

Outside a character set

Inside a character set

• A ^ must be escaped only if it occurs immediately after the opening [ of the character set.
• A - must be escaped only if it occurs between two alphabets or two digits.

Quantifiers

• The quantifier goes after the expression to be quantified.

Boundaries

• How word boundary matching works:
  • At the beginning of the string if the first character is \w.
  • Between two adjacent characters within the string, if the first character is \w and the second character is \W.
  • At the end of the string if the last character is \w.

Matching

Grouping and capturing

• Capturing groups are only relevant in the following methods:
  • string.match(regexp)
  • string.matchAll(regexp)
  • string.replace(regexp, callback)
• \N is a backreference to the Nth capturing group. Capturing groups are numbered starting from 1.

Flags

• If the g flag is used, regexp.lastIndex may change with each call to regexp.test(string).
• If the m flag is used, ^ and $ will match the start and end of each line.

References and tools

• MDN
• RegExplained

License

MIT