Regex Word Boundaries: \b, \B and \w Explained

\b is the zero-width assertion that matches the position between a word character and a non-word character: the start of "cat" in "the cat" or the end of "cat" in "cat food", but not anywhere inside "scatter". \B is its negation, a position where there is no word boundary. Both are zero-width: they consume no characters, they only assert position.

What is a word boundary (\b) in regex?

A word boundary is the zero-width position between a word character (\w: a letter, digit, or underscore) and a non-word character (\W: anything else), or at a string edge adjacent to a word character. The \b metacharacter matches that position. It is a position, not a character: \b does not match a literal b, and it consumes nothing, so it never "uses up" any of the input.

In one line: \b says "a word starts or ends right here". The classic use is "match a whole word, not the substring inside another word": \bcat\b matches "cat" in "the cat sat" but not "cat" in "scatter" or "category". \B is the negation, every position that is not a word boundary.

That covers the short answer. The rest of this page is the full reference: the exact positions that match, per-engine support (JavaScript, Python, Java, PCRE, .NET, POSIX, Go, Rust), Unicode caveats, the lookaround alternative when you need finer control, and worked examples in Python and JavaScript. The same idea extends to log parsing (token-precise matches), refactor tools (rename only whole identifiers), and search-and-replace (don't mangle "Java" into "Python" inside "JavaScript").

Jump to:

• \b is a boundary, not the letter b
• Word characters: what counts as \w
• Where \b matches: the four positions
• Negated word boundary: \B
• Engine compatibility
• Unicode word boundaries
• Lookaround alternative for finer control
• Common use cases with examples
• Common mistakes
• FAQ

\b is a boundary, not the letter b

This trips up a lot of people searching for "b in regex" or "regex b", so it is worth being explicit. The escape \b (backslash-b) is a word boundary, a zero-width position. It is not the literal character b. To match an actual lowercase b you just write b with no backslash. So:

• b matches the letter b.
• \b matches a position (a word boundary), and matches no character at all.
• \bb\b matches a standalone single-letter word "b" (the boundary, then the letter, then the boundary).

There is one more wrinkle that catches people out: inside a character class, \b changes meaning. In most engines [\b] is the backspace control character (U+0008), not a word boundary. A word boundary is meaningless inside a [...] class, so the engine reuses the escape for backspace there, the same way it does in string literals. If you meant "word boundary", keep \b outside the brackets.

import re
re.findall(r"\bb\b", "a b c bb")   # ['b']  - the standalone "b", not the "bb"
re.search(r"[\b]", "a\bc")         # match  - [\b] is backspace inside a class

What does \w mean in regex?

\w matches a single word character: a letter, a digit, or an underscore. In JavaScript and Go it is essentially [a-zA-Z0-9_]; Python string patterns and several other engines include Unicode characters by default. See the engine table below. Add a quantifier to match a run of them, so \w+ matches one or more word characters in a row (\w+ on "snake_case 42" matches snake_case and then 42), and \w* matches zero or more. Its negation, \W, matches anything that is not a word character.

For the ASCII definition, the word characters are:

The underscore is a word character: \bsnake\b does not match inside snake_case, but it does match inside snake-case. The longer pattern \bsnake-case\b also matches the complete snake-case string; its outer boundary assertions do not forbid punctuation inside the match.

Anything not in \w is in \W: spaces, tabs, punctuation, hyphens, and every non-ASCII letter or symbol depending on the engine and its Unicode mode.

Whole-word matching: spaces, hyphens, and underscores

For JavaScript /\bcat\b/ and Python re.search(r"\bcat\b", text):

Do not add the JavaScript g flag to a regex you repeatedly call with .test() unless you deliberately manage its state.

Where \b matches: the four positions

A word boundary exists at any position where one side is a word character and the other side is not (including string start/end). The four cases:

What \b does NOT match: positions where both sides are word characters (\bcat\b against "scatter" finds no match) or both sides are non-word characters ("!@#" has no word boundaries).

Negated word boundary: \B

\B matches every position that \b does NOT, namely positions where both sides are word characters, or both sides are non-word characters. It's the assertion for "match this substring only when it is inside a word":

The classic use: highlight every occurrence of a sequence as a substring but skip the standalone form. \Bing\b matches ing at the end of a word but not the standalone word "ing".

Engine compatibility

Word boundary support varies by engine, especially around Unicode. The differences matter when you're writing patterns that need to work in more than one runtime.

For the broader cross-engine reference, see the Regex Cheat Sheet.

Unicode word boundaries

In JavaScript, adding u does not turn \b into a Unicode word segmenter. These results follow from the mostly ASCII definition of \w:

/\bna\b/.test("naïve");        // true: ï is not a JS word character
/\bna\b/u.test("naïve");       // true: u does not change that
/\bcafé\b/u.test("café break"); // false: é and the space are both non-word
/\bnaïve\b/u.test("naïve");    // true: the outer n/e edges are word edges

To treat letters, combining marks, numbers, and underscore as a token, use an explicit rule in modern JavaScript:

const cafe = /(?<![\p{L}\p{M}\p{N}_])café(?![\p{L}\p{M}\p{N}_])/u;
cafe.test("café break");  // true
cafe.test("caféteria");   // false

This defines one token policy; it is not language-aware segmentation. For text without space-delimited words, consider Intl.Segmenter. MDN documents JavaScript's boundary definition.

Python 3 string patterns use Unicode word characters by default:

import re
bool(re.search(r"\bcafé\b", "café break"))        # True
bool(re.search(r"\bcafé\b", "café break", re.A))  # False

re.A switches to ASCII rules; byte patterns have different defaults. See the Python re reference. In PCRE2/PHP, UTF encoding and Unicode character properties are separate options; PCRE2 documents (*UCP). Perl's \b{wb} is not portable PCRE2 syntax.

Lookaround alternative for finer control

\b is a yes/no assertion. When you need to assert which kind of character comes before or after, for example "preceded by whitespace specifically, not punctuation", use lookarounds instead:

The last case is particularly useful when working with identifiers: \b treats _ as a word character (so \bid\b won't match the id inside user_id). If you specifically want to find id as a standalone token even when adjacent to underscore, use the explicit lookaround.

Python's built-in re requires fixed-width lookbehind. JavaScript supports lookbehind in modern runtimes; Go's regexp and Rust's regex crate do not support it. Check your engine before copying a lookaround alternative.

Word boundaries in Python and JavaScript

These two dominate, so here is the canonical whole-word match in each. The pattern is the same; what differs is how you express it and how Unicode behaves.

In Python, use a raw string (r"...") so the backslash reaches the regex engine instead of being eaten as a string escape. r"\bword\b" is the idiomatic form:

import re

re.findall(r"\bword\b", "word wordsmith password word.")  # ['word', 'word']
re.sub(r"\bcat\b", "dog", "cat scatter cat")              # 'dog scatter dog'
bool(re.search(r"\bcat\b", "the cat sat"))                # True

Python 3 is Unicode-aware by default for str patterns, so r"\bnaïve\b" matches naïve with no extra flag. Pass re.A (re.ASCII) if you specifically want ASCII-only boundaries.

In JavaScript, write the literal with a single backslash (/\bword\b/), or double it when building from a string with new RegExp("\\bword\\b"):

"word wordsmith password word.".match(/\bword\b/g);  // ['word', 'word']
"cat scatter cat".replace(/\bcat\b/g, "dog");        // 'dog scatter dog'
/\bcat\b/.test("the cat sat");                        // true

JavaScript keeps mostly ASCII word-character semantics even with u or v. For non-ASCII token edges, use an explicit Unicode property class or a segmenter. More on that in Unicode word boundaries above.

Common use cases with examples

1. Whole-word find and replace

The most common use of \b. Rename a variable in code without mangling longer identifiers:

# GNU sed (not portable to every sed): rename 'count' to 'total' but skip 'counter', 'counterpart'
sed -E 's/\bcount\b/total/g' file.txt

# Python: same
import re
new = re.sub(r"\bcount\b", "total", source)

2. Highlight search terms

const term = "react";
const re = new RegExp(`\\b${term}\\b`, "giu");
return text.replace(re, m => `<mark>${m}</mark>`);

The \b anchors prevent highlighting "react" inside "reaction" or "reactor".

3. Extract whole numbers from text

re.findall(r"\b\d+\b", "room 42 on floor 3 has 1024 widgets")
# ['42', '3', '1024']

4. Match log tokens precisely

# Match LEVEL tokens in a log file: INFO, WARN, ERROR
re.findall(r"\b(?:INFO|WARN|ERROR)\b", log_line)

Without \b, the pattern would also match ERROR inside ERROR_COUNT.

5. Validate identifier-like strings

// Match identifiers that are at least 3 chars, alphanumeric + underscore
const isIdentifier = (s) => /^\w{3,}$/.test(s);

For input-validation patterns specifically, the Regex Anchors article covers ^ and $ which often pair with \b for full-string assertions.

Common mistakes

Mistake 1: assuming \b separates hyphens. \b treats - as a non-word character, so \bword\b matches word in word-art. If you don't want that, use the explicit lookaround (?<![A-Za-z0-9_-])word(?![A-Za-z0-9_-]).

Mistake 2: assuming u fixes JavaScript word boundaries. It enables Unicode syntax and code-point handling, but does not make every Unicode letter a \w character. Test the edges of the particular token, not just its interior.

Mistake 3: assuming GNU extensions are POSIX. Standard BRE/ERE does not define \b. On GNU or BSD grep, grep -w 'word' file.txt is convenient. For a portable explicit rule, use grep -E '(^|[^[:alnum:]_])word([^[:alnum:]_]|$)' file.txt; this selects lines and consumes the separators as part of the match.

Mistake 4: thinking \B is "the opposite end" of \b. \B is "no boundary HERE", not "boundary on the other side". \Bbook\B matches book only when both edges are inside a word, which is rare for the whole word book (it would need to be inside something like bookbookkeeper).

Mistake 5: confusing \b with ^ and $. ^ and $ anchor to the start and end of the line (or string with the appropriate flag); \b anchors to the start or end of a word. Both are zero-width but operate at different scales. See the Regex Anchors guide for the line/string anchors.

Mistake 6: copying a Python Unicode pattern to Go. Go accepts \b but defines it in ASCII terms. Match Unicode token candidates and inspect their neighbours in code; a lookaround does not compile in Go's built-in regexp package.

What to do next

For more advanced word-matching patterns:

• Regex Lookaheads and Lookbehinds: an alternative to \b when you need finer control over what comes before or after.
• Regex Anchors: ^ and $ for line and string boundaries, the natural complement to \b.
• Regex Capturing Groups and Backreferences: when you need to reuse a matched word elsewhere in the pattern.

For specific real-world patterns that build on word boundaries:

• Match Email Address: \b is essential for picking emails out of prose.
• Match URLs: same idea, anchored to whole-token extraction.
• Match Domain Name: domain extraction from logs and mixed text.
• Match Numbers: \b\d+\b is the canonical whole-number pattern.
• Match HTML Tags: token-level matching against markup.

For the one-page reference with every regex shortcut on one page, see the Regex Cheat Sheet.

FAQ

See also

• Regex Anchors: ^ and $ are the full-string equivalents; word boundaries are the per-token version
• Regex Lookaheads and Lookbehinds: a replacement for \b when you need custom boundary characters
• Validate Password Strength with Regex: a counterexample, anchored validation that uses ^/$ rather than \b
• Regex Capturing Groups and Backreferences: \b(\w+)\b is the standard whole-word capture pattern
• Regex Cheat Sheet: the wider syntax and engine compatibility reference

Recommended books

Word boundaries are one of the most misunderstood zero-width assertions. If you want the concepts properly grounded:

• Learning Regular Expressions (Ben Forta). The gentlest on-ramp: short, current, and example-driven. A good first book if you are still finding your feet.
• Regular Expressions Cookbook (Jan Goyvaerts and Steven Levithan, 2nd edition). Problem-then-solution recipes across eight languages (JavaScript, Python, PHP, Java, .NET, Ruby, Perl, VB). The one to keep next to the keyboard.
• Mastering Regular Expressions (Jeffrey Friedl, 3rd edition). The definitive deep-dive on how regex engines actually work: backtracking, NFA versus DFA, and the optimisation that makes a pattern fast or catastrophic. Dense, and unmatched once you are past the basics.