JavaScript RegExp

Regular Expressions

A Regular Expression is a sequence of characters that forms a search pattern.

Regex is a common shorthand for a regular expression.

JavaScript RegExp is an Object for handling Regular Expressions.

RegExp are be used for:

• Text searching
• Text replacing
• Text validation

Example

let text = "Visit EA Academy";

let n = text.search(/EA Academy/i);

Example explained:

/EA Academy/i is a regular expression.

EA Academy is a pattern (to be used in a search).

i is a modifier (modifies the search to be case-insensitive).

Regular Expression Syntax

/pattern/modifier flags

Using String Methods

Regular expressions are often used with the string methods:

Using String match()

Example

let text = "Visit EA Academy";

let n = text.match(/EA Academy/);

Using String replace()

Example

let text = "Visit Microsoft!";

let result = text.replace(/Microsoft/i, "EA Academy");

Using String search()

Example

let text = "Visit EA Academy";

let n = text.search(/EA Academy/);

RexExp Alternation (OR)

In a regular expression an alternation is denoted with a vertical line character |.

An alternation matches any of the alternatives separated with |.

Example

let text = "Black, white, red, green, blue, yellow.";

let result = text.match(/red|green|blue/g);

JavaScript Regex Flags

Example

/pattern/flags

Regular expression flags are parameters that can modify how a pattern is used, such as making it case-insensitive or global.

These are the most common:

The /g Flag (Global)

The /g flag matches all occurrences of the pattern, rather than just the first one.

Example

let text = "Is this all there is?";

const pattern = /is/g;

let result = text.match(pattern);

The /i Flag (Insensitive)

The /i flag makes a match case-insensitive: /abc/i matches "abc", "AbC", "ABC".

Example

let text = "Visit EA Academy";

const pattern = /EA Academy/i;

let result = text.match(pattern);

RexExp Metacharacters

Example

// Match words

const pattern = /\w/;

Metacharacters are characters with a special meaning.

They can be used to match digits, words, spaces, and more.

These are the most common:

RegExp \d (digits) Metacharacter

The \d metacharacter matches digits.

Example

let text = "Give 100%!";

const pattern = /\d/g;

let result = text.match(pattern);

RegExp \w (word) Metacharacter

The \w metacharacter matches word characters.

A word character is a character a-z, A-Z, 0-9, including _ (underscore).

Example

let text = "Give 100%!";

const pattern = /\w/g;

let result = text.match(pattern);

JavaScript RegExp Quantifiers

Quantifiers define the numbers of characters or expressions to match.

Example

const pattern = /lo+/;

The + means "one or more". The pattern matches:

• lo
• loo
• looo

These are the most common quantifiers:

The ? Quantifier

x? matches zero or one occurrences of x.

Example

let text = "1, 100 or 1000?";

const pattern = /10?/g;

let result = text.match(pattern);

Regular Expression Assertions

Example

// Match beginning of string

const pattern = /^EA Academy/;

// Match end of string

const pattern = /EA Academy$/;

Assertions matches Boundaries and Lookarounds:

String Boundaries and Word Boundaries.

Lookarounds: Lookaheads and Lookbehinds.

These are the most common:

| (?

RegExp ^ Metacharacter

The ^ metacharacter matches the beginning of a string.

Examples

const pattern = /^EA Academy/;

let text = "EA Academy Tutorial";

let result = pattern.test(text); // true

RegExp $ Metacharacter

The $ metacharacter matches the end of a string.

Example

const pattern = /EA Academy$/;

let text = "Hello EA Academy";

let result = pattern.test(text); // true

JavaScript RegExp Character Classes

Example

// Match Digits

const pattern = /[0-9]/;

Character Classes are characters enclosed in square brackets [].

A character class matches any character from a set within brackets.

These are the most common:

Example [0-9]

let text = "More than 1000 times";

const pattern = /[0-9]/g;

let result = text.match(pattern);