Wortgrenzen-Assertion: \\b, \\B — Keyword · JavaScript-Referenz

Signatur

/\b/ · /\B/

Beschreibung

Eine Wortgrenzen-Assertion ist ein Muster ohne eigene Breite. Sie verbraucht also keine Zeichen, sondern prüft nur eine Bedingung an der aktuellen Position im String. \b trifft zu, wenn genau eines der beiden angrenzenden Zeichen ein Wortzeichen ist. Wortzeichen sind die Zeichen, auf die auch \w passt: [A-Za-z0-9_]. Auch Anfang und Ende des Strings zählen als Nicht-Wortzeichen. \B ist das Gegenteil: Es trifft zu, wenn beide Nachbarn Wortzeichen sind oder beide keine sind.

Typische Einsatzfälle sind die Suche nach ganzen Wörtern (/\bcat\b/ findet „cat“, aber nicht das „cat“ in „concatenate“), das Finden von Bezeichnern im Quelltext und das Einfügen von Zeichen innerhalb von Wörtern oder Zahlen mit \B, zum Beispiel Tausendertrennzeichen.

Wichtig: Die Definition von „Wort“ ist rein ASCII-basiert. Umlaute, ß, akzentuierte Buchstaben oder kyrillische Zeichen gelten nicht als Wortzeichen. Das gilt auch mit dem Flag u. Für deutsche oder mehrsprachige Texte eignen sich Lookarounds mit Unicode-Eigenschaften besser, etwa (?<![\p{L}\p{N}_]) und (?![\p{L}\p{N}_]).

Rückgabewert

Typ

Assertion (nullbreit)

Beschreibung

Die Assertion liefert keinen Wert und verbraucht keine Zeichen. Sie lässt den Treffer an der aktuellen Position nur zu oder verhindert ihn. Ein Treffer, der nur aus \b besteht, ist ein leerer String.

Beispiele

Nur ganze Wörter ersetzen

const text = "cat concatenate cat. Bobcat";

// Ohne \b würde auch „concatenate“ und „Bobcat“ verändert
const result = text.replace(/\bcat\b/g, "Katze");
console.log(result);

Katze concatenate Katze. Bobcat

Tausendertrennzeichen mit \B einfügen

const formatThousands = (n) =>
  String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ".");

console.log(formatThousands(1234567));
console.log(formatThousands(999));

1.234.567 999

Fallstrick: Umlaute sind keine Wortzeichen

const wort = "Grüße aus München";

// ASCII-basierte Wortgrenzen zerlegen Wörter mit Umlauten
console.log(wort.match(/\b\w+\b/g));

// Unicode-taugliche Alternative mit Lookarounds
const unicodeWords = /(?<![\p{L}\p{N}_])[\p{L}\p{N}_]+(?![\p{L}\p{N}_])/gu;
console.log(wort.match(unicodeWords));

[ 'Gr', 'e', 'aus', 'M', 'nchen' ] [ 'Grüße', 'aus', 'München' ]

Dynamischer Wortfilter mit new RegExp

const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

const containsWord = (text, word) =>
  new RegExp(`\\b${escapeRegExp(word)}\\b`, "i").test(text);

console.log(containsWord("Error: file not found", "error"));
console.log(containsWord("Errors happened", "error"));

true false

// Wichtig · Fallstricke

Escaping im String: Mit new RegExp("\b") entsteht ein Backspace-Zeichen (U+0008), keine Wortgrenze. Im String-Literal muss es "\\b" heißen.
In Zeichenklassen bedeutet [\b] das Backspace-Zeichen, keine Wortgrenze. [\B] ist mit dem Flag u oder v ein Syntaxfehler.
Nur ASCII: ä, ö, ü, ß, é usw. gelten nicht als Wortzeichen. So passt /\bMüller\b/ auch auf „Müllerin“ nicht wie erwartet: Das Muster greift trotzdem, weil zwischen M und ü selbst eine Grenze liegt. Verwende Lookarounds mit \p{L} und dem Flag u.
Kombination i + u: Durch die Unicode-Groß-/Kleinschreibungs-Faltung gelten dann auch ſ (U+017F) und das Kelvin-Zeichen K (U+212A) als Wortzeichen. Das beeinflusst \w, \b und \B.
Leerer String: /\b/.test("") ergibt false, /\B/.test("") ergibt true.
Wortgrenzen hängen nur von den direkten Nachbarzeichen ab. Satzzeichen wie - oder ' erzeugen Grenzen, darum findet /\bstate\b/ das Wort auch in „read-only-state“.

Siehe auch

Lookbehind-Assertion: (?<=...), (?<!...) String.prototype.replace() RegExp Puffergrenzen-Aussage: \\A, \\z, \\Z Eingabebegrenzungs-Assertion: ^, $