Introduction

Regular Expressions, often called regex or RegExp, are a powerful way to work with text in JavaScript. They allow developers to define patterns for matching, searching, replacing, and validating strings. In this guide, you’ll learn the fundamentals of JavaScript regular expressions, including patterns, flags, special characters, and assertions.

1. What Is a JavaScript RegExp

A regular expression is a sequence of characters that forms a search pattern. In JavaScript, the RegExp object is used for defining and executing these patterns.

A RegExp can be written in two ways:

The /i flag makes the search case-insensitive. You can use regex to find patterns in text, validate input formats, or replace parts of a string.

2. RegExp Flags

Flags modify how a pattern behaves. Some of the most common flags include:

1. g – Global search. Finds all matches instead of stopping after the first.
2. i – Case-insensitive search.
3. m – Multiline mode. The start ^ and end $ match each line, not just the whole string.
4. s – Allows the dot . to match newline characters.
5. u – Enables full Unicode support.
6. y – Sticky search. Matches starting exactly from the lastIndex position.
7. d – Provides match indices (newer feature).

Flags can be combined, for example: /pattern/gi.

3. Character Classes and Brackets

Character classes define sets or ranges of characters to match.

1. [abc] – Matches any one of the characters a, b, or c.
2. [^abc] – Matches any character except a, b, or c.
3. [a-z] – Matches any lowercase letter from a to z.
4. [0-9] – Matches any digit.
5. [A-Za-z0-9_] – Matches any alphanumeric character or underscore.

These are useful for creating flexible patterns that allow variations in text.

4. Metacharacters

Metacharacters have special meanings in regex and are used to define complex patterns.

1. . – Matches any character except a newline.
2. d – Matches any digit (0–9).
3. w – Matches any word character (letters, digits, underscore).
4. s – Matches whitespace (spaces, tabs, line breaks).
5. D, W, S – Negated forms of the above.
6. b – Word boundary.
7. B – Non-word boundary.
8. ^ – Matches the start of a string or line.
9. $ – Matches the end of a string or line.
10. | – Acts as OR (alternative between patterns).

Quantifiers are used to specify how many times a pattern should occur:

1. x* – Zero or more times.
2. x+ – One or more times.
3. x? – Zero or one time.
4. x{n} – Exactly n times.
5. x{n,} – At least n times.
6. x{n,m} – Between n and m times.

5. Assertions and Boundaries

Assertions do not consume characters but specify conditions for matching.

1. ^pattern – Matches only if the pattern is at the beginning of the string.
2. pattern$ – Matches only if the pattern is at the end of the string.
3. b – Matches a word boundary (start or end of a word).
4. B – Matches a position that is not a word boundary.

Lookaheads and lookbehinds allow you to check context without including it in the match:

1. x(?=y) – Matches x only if it is followed by y.
2. x(?!y) – Matches x only if it is not followed by y.
3. (?<=y)x – Matches x only if it is preceded by y.
4. (?<!y)x – Matches x only if it is not preceded by y.

Example:

6. RegExp Methods and Usage

Once you define a regular expression, you can use several methods to work with strings.

1. test() – Tests for a match and returns true or false.
2. exec() – Returns detailed information about the first match or null.
3. match() – Returns an array of matches.
4. replace() – Replaces matched text with another string.
5. search() – Returns the position of the first match.
6. split() – Splits a string into an array based on the pattern.

Example:

The RegExp object also has useful properties such as:

1. source – Returns the text of the pattern.
2. flags – Returns the flags used in the expression.
3. global, ignoreCase, multiline – Booleans for respective flags.
4. lastIndex – Index to start the next match when using the global flag.

Conclusion

JavaScript regular expressions are essential for searching, validating, and manipulating text efficiently. By mastering patterns, flags, character classes, metacharacters, and assertions, you gain the ability to process text with high precision.

Regular expressions might look complex at first, but with practice, they become an indispensable part of every developer’s toolkit.