JavaScript String match() Method

What You’ll Learn

String.prototype.match() retrieves the result of matching a string against a regular expression (same API as MDN String.prototype.match()). Learn global vs non-global results, capturing groups, named groups, null when missing, string-to-RegExp coercion, when to prefer test() / matchAll(), five examples, and try-it labs.

Introduction

When you need pattern matching — emails, chapter numbers, capital letters, or pieces of a sentence — regular expressions are the tool, and match() is the string method that runs them.

The result depends on the global (g) flag. With g, you get every full match as a simple array. Without g, you get the first match plus capturing groups, index, and input — similar to RegExp.prototype.exec().

This page is part of JavaScript String Methods. Related topics include includes() and indexOf().

Understanding the match() Method

Under the hood, str.match(regexp) mostly calls the argument’s Symbol.match method (for a normal regex, that is RegExp.prototype[Symbol.match]).

• Pass a RegExp (or anything with Symbol.match).
• Non-regex values are turned into new RegExp(value).
• With g — all full matches; capturing groups are omitted.
• Without g — first match + groups + index / input.
• Miss — returns null.

📝 Syntax

General form of String.prototype.match:

str.match(regexp)

Parameters

• regexp — a RegExp, or any object with a Symbol.match method. Other values become new RegExp(regexp). Calling match() with no argument is like matching /(?:)/ and returns [""].

Return value

An Array (shape depends on g), or null:

Common patterns

"The quick brown fox".match(/[A-Z]/g);  // ["T"]

const found = "see Chapter 3".match(/see (chapter \d+)/i);
found[0];     // "see Chapter 3"
found[1];     // "Chapter 3"
found.index;  // start index of the full match

// Yes/no only → prefer test:
/fox/.test("fox jumps");  // true

// All matches + groups → prefer matchAll:
[..."a1b2".matchAll(/(\d)/g)];

Examples Gallery

Examples follow MDN String.match() patterns. Use View Output or Try It Yourself for each case.

const paragraph = "The quick brown fox jumps over the lazy dog. It barked.";
const regex = /[A-Z]/g;
const found = paragraph.match(regex);

console.log(found);
// ["T", "I"]

T,I

const str = "For more information, see Chapter 3.4.5.1";
const re = /see (chapter \d+(\.\d)*)/i;
const found = str.match(re);

found[0];     // "see Chapter 3.4.5.1"  (full match)
found[1];     // "Chapter 3.4.5.1"      (group 1)
found[2];     // ".1"                   (group 2)
found.index;  // 22

see Chapter 3.4.5.1
Chapter 3.4.5.1
.1
22

const str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const regexp = /[a-e]/gi;
const matches = str.match(regexp);

console.log(matches);
// ["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"]

A,B,C,D,E,a,b,c,d,e

const paragraph = "The quick brown fox jumps over the lazy dog. It barked.";
const capturingRegex = /(?<animal>fox|cat) jumps over/;
const found = paragraph.match(capturingRegex);

console.log(found.groups);
// { animal: "fox" }

{"animal":"fox"}

"Nothing will come of nothing.".match();  // [""]

"hello".match(/xyz/);   // null

"123".match("1.3");     // ["123"]  (. means any character!)
"123".match("1\\.3");   // null     (escaped literal dot)
"123".match(/1\.3/);    // null

[""]
null
["123"]
null
null

🚀 Common Use Cases

• Extract patterns — emails, IDs, chapter numbers, codes.
• List all matches — use the g flag for a simple string array.
• Read capturing groups — omit g (or use matchAll for every match).
• Named parts — (?<name>...) + found.groups.
• Yes/no only — prefer regex.test(str).
• Not for plain substring search — use includes() / indexOf() when you do not need a pattern.

📝 Notes

• No match returns null — not [].
• With g, capturing groups are omitted from the result.
• For all matches and groups, use matchAll() (requires g).
• String arguments become regexes — escape special characters when you need literals.
• Calling match() with no argument returns [""].
• Prefer test() when you only need a boolean.

💡 Best Practices