JavaScript RegExp Non-Word Boundary (\B)

What Is \B?

\B is a non-word-boundary assertion. It matches a zero-width position where \b does not match — usually between two word characters (inside a token) or between two non-word characters.

\b  → word boundary (word ↔ non-word, or string edge)
\B  → NOT a word boundary (inverse of \b)

zero-width — matches a position, not a character

/\Bcat\B/.test("scatter")  → true   (cat inside a word)
/\Bcat\B/.test("a cat")    → false  (cat is a whole word)
/\bcat\b/.test("a cat")    → true

How to Use \B

Treat \B as a position check — place it where you need “still inside the same kind of characters.”

1. Decide whether you want a whole word (\b) or something embedded (\B).
2. Put \B before and/or after the text that must sit inside a larger token.
3. Remember it consumes no characters — only the surrounding pattern advances.
4. Combine with lookaheads for jobs like camelCase splits: \B(?=[A-Z]).

Pseudocode

at position p in the string:

left  = char before p (or "edge")
right = char after p  (or "edge")

isBoundary =
  (left is word) XOR (right is word)
  // edges count as non-word

if pattern has \b:
  accept only when isBoundary is true
if pattern has \B:
  accept only when isBoundary is false

// neither \b nor \B consumes a character

Cheat Sheet

Keep these facts handy when matching inside tokens.

Live Preview

Compare \B and \b on short sample strings.

text = "scatter"
/\Bcat\B/.test(text)
→ true

/* "cat" sits between letters — no word boundary */

JavaScript Examples

Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.

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 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";
console.log(id.split(/\B(?=[A-Z])/));
// ["get", "User", "Account", "Id"]

const label = "parseJSON";
console.log(label.split(/\B(?=[A-Z])/));
// ["parse", "J", "S", "O", "N"]  // acronyms split letter-by-letter

["get", "User", "Account", "Id"]
["parse", "J", "S", "O", "N"]

Performance Notes

Boundary assertions are cheap position checks. Prefer \b for whole words and \B when you intentionally want matches inside tokens.

Key Takeaways