JavaScript RegExp \b Metacharacter

What You’ll Learn

The \b metacharacter marks a word boundary—a zero-width position between a word character and a non-word character. Wrap a term with \b on both sides to match whole words like cat without hitting catalog or scat.

Introduction

Searching for cat with a plain pattern matches cat, catalog, and scat. That is often too broad when you want an exact word.

Word boundaries solve this. The \b anchor sits at the edge of a word—where letters, digits, or underscores meet spaces, punctuation, or string ends. It does not consume characters; it only checks the position.

Understanding the \b Word Boundary

In JavaScript, a word character is [A-Za-z0-9_]. A word boundary exists when:

• The current character is a word char and the previous is not (or start of string).
• The current character is not a word char and the previous is a word char (or end of string).

/\bcat\b/.test("I saw a cat");   // true
/\bcat\b/.test("catalog");        // false
/\bcat\b/.test("scat");           // false

/cat/.test("catalog");            // true (partial match)

How to Use \b in JavaScript

Place \b before and after the word you want to isolate. Combine with flags and other regex tools as needed:

const wholeWord = /\bcat\b/;
wholeWord.test("The cat sat");           // true

const found = "big cat catalog".match(/\bcat\b/g);
console.log(found); // ["cat"]

"my cat and catalog".replace(/\bcat\b/g, "dog");
// "my dog and catalog"

Use test() for presence checks, match() to extract whole words, and replace() to swap only isolated tokens.

📝 Syntax

\b              // word boundary (start or end of word)
\bcat\b         // whole word "cat"
\b(word1|word2)\b  // whole-word alternation
\B              // NOT a word boundary

Common patterns

• /\bcat\b/ — match cat as a standalone word.
• /\b\d+\b/g — match whole numbers (not digits inside words).
• /\b(yes|no)\b/i — match yes or no as whole words, any case.
• /\Bcat\B/ — match cat only when surrounded by word chars (inside a token).

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples show whole-word detection, extraction, replacement, validation, and combined patterns.

const wholeCat = /\bcat\b/;

console.log(wholeCat.test("I saw a cat"));  // true
console.log(wholeCat.test("catalog"));      // false
console.log(wholeCat.test("scat"));         // false

true
false
false

const text = "The big cat watched the catalog.";

const matches = text.match(/\bcat\b/g);
console.log(matches); // ["cat"]

const partial = text.match(/cat/g);
console.log(partial); // ["cat", "cat"] (catalog too)

["cat"]
["cat", "cat"]

const sentence = "My cat loves the catalog.";

const safe = sentence.replace(/\bcat\b/g, "dog");
console.log(safe); // "My dog loves the catalog."

const unsafe = sentence.replace(/cat/g, "dog");
console.log(unsafe); // "My dog loves the dogalog."

My dog loves the catalog.
My dog loves the dogalog.

function isWholeWord(text, word) {
  const pattern = new RegExp("\\b" + word + "\\b", "i");
  return pattern.test(text);
}

console.log(isWholeWord("admin", "admin"));       // true
console.log(isWholeWord("administrator", "admin")); // false
console.log(isWholeWord("The ADMIN role", "admin")); // true

true
false
true

const answer = /\b(yes|no)\b/i;
const text = "Yes! Yesterday was nice. Say no now.";

const found = text.match(answer);
console.log(found); // ["Yes", "no"]

console.log(answer.test("yesman"));  // false
console.log(answer.test("oh yes"));  // true

["Yes", "no"]
false
true

🚀 Common Use Cases

• Search highlighting — highlight exact words in documents without false positives.
• Find-and-replace — swap one word without damaging words that contain it.
• Keyword filters — block whole banned words, not innocent substrings.
• Token parsing — extract standalone numbers or identifiers from prose.
• Command detection — match help or quit as full commands.
• Log analysis — find ERROR or WARN as whole tokens in log lines.

Important Considerations

• Zero-width — \b matches a position, not a character; it does not match spaces directly.
• Underscore is a word char — my_var is one word; \bvar\b will not match inside it.
• Hyphens split words — in well-known, boundaries appear at the hyphens.
• Not full-string anchor — \bword\b finds a word inside a sentence; use ^word$ for exact full input.
• Unicode limits — default \b uses ASCII word rules; international letters may need \p{} with the u flag in modern JS.

📝 Notes

• \b is a zero-width assertion—it does not add characters to the match result.
• \w equals [A-Za-z0-9_] in JavaScript default mode.
• \B matches where \b would fail (inside a word).
• Review (x|y) alternation and ignoreCase for combined patterns.
• Next up: \r carriage return metacharacter.
• For Unicode word boundaries, explore \p{L} with the u flag on modern engines.

💡 Best Practices