Regular Expressions

A regular expression (regex) is a pattern used to match, search, and manipulate text. Instead of manually checking characters one by one, you describe a pattern once — "a digit followed by three letters," for example — and let the regex engine find every place that pattern occurs. Regexes are indispensable for validating input, extracting pieces of a string, and doing search-and-replace far more powerful than a plain string match.

There are two ways to create a regex: the literal syntax, /pattern/flags, and the RegExp constructor, new RegExp('pattern', 'flags'). The literal form is more common and slightly faster since it's compiled when the script loads, but the constructor form is necessary when you need to build a pattern dynamically from a string, such as one built from user input.

Flags change how a regex behaves and go after the closing slash. The three you'll use most: g (global) finds all matches instead of stopping at the first one, i (case-insensitive) ignores letter casing, and m (multiline) makes ^ and $ match the start/end of each line rather than only the start/end of the whole string.

Character classes match categories of characters: \d matches any digit, \w matches any word character (letters, digits, underscore), and \s matches any whitespace character. Quantifiers control how many times something can repeat: * means zero or more, + means one or more, ? means zero or one, and {n,m} means between n and m times. Anchors ^ and $ pin a match to the start or end of the string.

test() returns a simple boolean — did the pattern match anywhere in the string? exec() goes further: it returns an array with details about the match (the matched text, capture groups, and the index it was found at), or null if there was no match. With the g flag, calling exec() repeatedly on the same regex advances through successive matches each time.

Strings have several methods that accept a regex: match() returns matches (all of them, as an array of strings, when the g flag is used), matchAll() returns an iterator of full match objects including capture groups, replace() swaps the first match (or all matches with the g flag) for a replacement, replaceAll() requires the g flag and replaces every match, and split() divides a string wherever the pattern matches.

Parentheses inside a pattern create a capture group — a piece of the match you can pull out separately. Groups are numbered by their order of opening parenthesis, accessible on the result of exec() or match() by index. Named groups, written as (?<name>...), let you refer to a captured piece by name instead of a numeric index, which makes patterns with several groups much easier to read.

Fully validating an email address with a regex is notoriously hard (and arguably not worth doing precisely), but a loose check is a common real-world need — enough to catch obvious typos before sending a request to the server.