JavaScript RegExp \B Metacharacter

What You’ll Learn

The \B metacharacter matches a non-word-boundary position—a zero-width spot where \b would not match. Use it to find substrings embedded inside longer tokens, digits sandwiched between letters, or camelCase split points.

Introduction

You already know that \b finds word edges. The uppercase form \B does the opposite: it matches positions that are not at a word boundary—typically the middle of a token where word characters sit on both sides.

Because \B is zero-width, it does not consume characters. It only checks whether the current position qualifies before the engine continues matching the rest of the pattern.

Understanding the \B Metacharacter

A word boundary (\b) sits where a word character ([A-Za-z0-9_]) meets a non-word character, or at the start/end of the string next to a word character. A non-word boundary (\B) matches everywhere else.

/\bcat\b/.test("a cat");     // true  (whole word)
/\bcat\b/.test("scatter");   // false (inside word)

/\Bcat\B/.test("scatter");   // true  (embedded)
/\Bcat\B/.test("a cat");     // false (has boundaries)

/\B/.test("ab");             // true  (between a and b)

Think of \B as “not at a word edge.” It is essential when you need the inverse of whole-word matching.

How to Use \B in JavaScript

Use \B when you need to match inside tokens rather than at their edges:

/\Bthe\B/.test("other");           // true
"scatter".match(/\Bcat\B/);       // ["cat"]
"item123sale".match(/\B\d+\B/);    // ["123"]
"myVariable".split(/\B(?=[A-Z])/);// ["my", "Variable"]

Pair \B with lookahead ((?=[A-Z])), character classes, and quantifiers for precise inside-token patterns.

📝 Syntax

\B              // one non-word-boundary position
\Bword\B        // word embedded inside a token
\B\d+\B         // digits between word characters
\B(?=[A-Z])      // before uppercase in camelCase
\b              // word boundary (inverse of \B)

Common patterns

• /\Bcat\B/ — match cat only when embedded inside a word.
• /\B\d+\B/g — extract digit runs sandwiched between letters.
• /\B(?=[A-Z])/g — split camelCase identifiers.
• /\Bthe\B/gi — find “the” inside words like “other” or “brother”.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples contrast \b and \B, find embedded substrings, extract inline digits, and split camelCase.

const embedded = /\Bcat\B/;

console.log(embedded.test("scatter"));   // true
console.log(embedded.test("bobcatx"));   // true
console.log(embedded.test("a cat"));      // false
console.log(embedded.test("catalog"));    // false

true
true
false
false

const text = "The other brother went there.";

const embedded = text.match(/\Bthe\B/gi);
console.log(embedded); // ["the", "the"] (other, brother)

const whole = text.match(/\bthe\b/gi);
console.log(whole);    // ["The"] (standalone only)

["the", "the"]
["The"]

const sku = "item123sale costs 456 total";

const inline = sku.match(/\B\d+\B/g);
console.log(inline); // ["123"]

const all = sku.match(/\d+/g);
console.log(all);    // ["123", "456"]

["123"]
["123", "456"]

const sentence = "My cat loves scatter and catalog.";

console.log(sentence.match(/\bcat\b/g));
// ["cat"] — whole word only

console.log(sentence.match(/\Bcat\B/g));
// ["cat"] — inside "scatter" only

console.log(sentence.match(/cat/g));
// ["cat", "cat", "cat"] — all occurrences

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

const id = "getUserAccountId";

const parts = id.split(/\B(?=[A-Z])/);
console.log(parts); // ["get", "User", "Account", "Id"]

const label = "myHTMLParser";
console.log(label.split(/\B(?=[A-Z])/));
// ["my", "HTMLParser"]

["get", "User", "Account", "Id"]
["my", "HTMLParser"]

🚀 Common Use Cases

• Embedded substring search — find text inside longer tokens with \B...\B.
• Inline ID extraction — pull digits embedded in SKUs with \B\d+\B.
• camelCase parsing — split identifiers at \B(?=[A-Z]).
• Inverse whole-word logic — exclude standalone matches when \b is too broad.
• Token analysis — detect positions inside compound words for NLP-style processing.
• Refactoring tools — rename variables without hitting partial matches at word edges.

Important Considerations

• Zero-width only — \B matches positions, not characters. It adds no length to the result.
• Inverse of \b — wherever \b succeeds, \B fails, and vice versa (at the same position).
• Underscore counts — underscore is a word character, so a_b has \B between the letters and underscore.
• Not a character class — do not confuse \B (non-boundary) with \W (non-word character).
• Start/end edges — string start/end next to a word char is a \b position, not \B.

📝 Notes

• \B is the uppercase inverse of \b.
• Do not confuse \B (non-boundary anchor) with \W (non-word character).
• Review \b word boundary for the complementary anchor.
• Next up: \0 null character metacharacter.
• Word characters are [A-Za-z0-9_] by default in JavaScript.
• For whole-word replacement, prefer \bword\b; for inside-word matches, use \Bword\B.

💡 Best Practices