Assertions
Zu den Assertions gehören Grenzen, die den Anfang und das Ende von Zeilen und Wörtern anzeigen, sowie andere Muster, die anzeigen, dass eine Übereinstimmung möglich ist (einschließlich Lookahead, Lookbehind und bedingte Ausdrücke).
Probieren Sie es aus
const text = "A quick fox";
const regexpLastWord = /\w+$/;
console.log(text.match(regexpLastWord));
// Expected output: Array ["fox"]
const regexpWords = /\b\w+\b/g;
console.log(text.match(regexpWords));
// Expected output: Array ["A", "quick", "fox"]
const regexpFoxQuality = /\w+(?= fox)/;
console.log(text.match(regexpFoxQuality));
// Expected output: Array ["quick"]
Typen
Assertions vom Typ Grenze
Zeichen | Bedeutung |
---|---|
^ |
Input-Grenze Anfangs-Assertion:
Passt am Anfang des Eingabewerts. Wenn das Hinweis: Dieses Zeichen hat eine andere Bedeutung, wenn es am Anfang einer Zeichenklasse erscheint. |
$ |
Input-Grenze End-Assertion:
Passt am Ende des Eingabewerts. Wenn das |
\b |
Wortgrenzen-Assertion: Passt an einer Wortgrenze. Dies ist die Position, an der ein Wortzeichen nicht von einem anderen Wortzeichen gefolgt oder vor einem solchen steht, wie z. B. zwischen einem Buchstaben und einem Leerzeichen. Beachten Sie, dass eine erkannte Wortgrenze nicht Teil der Übereinstimmung ist. Mit anderen Worten: Die Länge einer passenden Wortgrenze ist null. Beispiele:
Um ein Rückschrittzeichen ( |
\B |
Keine-Wortgrenze-Assertion:
Passt an einer Nicht-Wortgrenze. Dies ist eine Position, an der das vorherige und das nächste Zeichen vom gleichen Typ sind: Entweder müssen beide Wörter oder beide Nicht-Wörter sein, z. B. zwischen zwei Buchstaben oder zwischen zwei Leerzeichen. Der Anfang und das Ende eines Strings werden als Nicht-Wörter betrachtet. Genau wie die erkannte Wortgrenze ist die erkannte Nicht-Wortgrenze ebenfalls nicht Teil der Übereinstimmung. Zum Beispiel passt |
Andere Assertions
Hinweis:
Das Zeichen ?
kann auch als Quantifier verwendet werden.
Zeichen | Bedeutung |
---|---|
x(?=y) |
Lookahead-Assertion:
Passt "x" nur, wenn "x"
von "y" gefolgt wird. Zum Beispiel passt |
x(?!y) |
Negative Lookahead-Assertion:
Passt "x" nur, wenn "x" nicht von "y" gefolgt wird. Zum Beispiel passt |
(?<=y)x |
Lookbehind-Assertion:
Passt "x" nur, wenn "x" von "y" vorangestellt ist. Zum Beispiel passt |
(?<!y)x |
Negative Lookbehind-Assertion:
Passt "x" nur, wenn "x" nicht von "y" vorangestellt ist. Zum Beispiel passt |
Beispiele
Allgemeines Beispiel für Grenz-Typen
// Using Regex boundaries to fix buggy string.
buggyMultiline = `tey, ihe light-greon apple
tangs on ihe greon traa`;
// 1) Use ^ to fix the matching at the beginning of the string, and right after newline.
buggyMultiline = buggyMultiline.replace(/^t/gim, "h");
console.log(1, buggyMultiline); // fix 'tey' => 'hey' and 'tangs' => 'hangs' but do not touch 'traa'.
// 2) Use $ to fix matching at the end of the text.
buggyMultiline = buggyMultiline.replace(/aa$/gim, "ee.");
console.log(2, buggyMultiline); // fix 'traa' => 'tree.'.
// 3) Use \b to match characters right on border between a word and a space.
buggyMultiline = buggyMultiline.replace(/\bi/gim, "t");
console.log(3, buggyMultiline); // fix 'ihe' => 'the' but do not touch 'light'.
// 4) Use \B to match characters inside borders of an entity.
fixedMultiline = buggyMultiline.replace(/\Bo/gim, "e");
console.log(4, fixedMultiline); // fix 'greon' => 'green' but do not touch 'on'.
Den Anfang des Eingabewerts mit einem ^-Steuerzeichen abgleichen
Verwenden Sie ^
, um am Anfang des Eingabewerts abzugleichen. In diesem Beispiel können wir die Früchte finden, die mit 'A' beginnen, indem wir einen /^A/
Regex verwenden. Um die passenden Früchte auszuwählen, können wir die filter
-Methode mit einer arrow-Funktion verwenden.
const fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
// Select fruits started with 'A' by /^A/ Regex.
// Here '^' control symbol used only in one role: Matching beginning of an input.
const fruitsStartsWithA = fruits.filter((fruit) => /^A/.test(fruit));
console.log(fruitsStartsWithA); // [ 'Apple', 'Avocado' ]
Im zweiten Beispiel wird ^
sowohl verwendet, um am Anfang des Eingabewerts abzugleichen, als auch, um eine negierte oder komplementierte Zeichenklasse innerhalb von Zeichenklassen zu erstellen.
const fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
// Selecting fruits that do not start by 'A' with a /^[^A]/ regex.
// In this example, two meanings of '^' control symbol are represented:
// 1) Matching beginning of the input
// 2) A negated or complemented character class: [^A]
// That is, it matches anything that is not enclosed in the square brackets.
const fruitsStartsWithNotA = fruits.filter((fruit) => /^[^A]/.test(fruit));
console.log(fruitsStartsWithNotA); // [ 'Watermelon', 'Orange', 'Strawberry' ]
Weitere Beispiele finden Sie in der Referenz zu Input-Grenz-Assertion.
Eine Wortgrenze abgleichen
In diesem Beispiel gleichen wir Obstnamen ab, die ein Wort enthalten, das mit "en" oder "ed" endet.
const fruitsWithDescription = ["Red apple", "Orange orange", "Green Avocado"];
// Select descriptions that contains 'en' or 'ed' words endings:
const enEdSelection = fruitsWithDescription.filter((descr) =>
/(en|ed)\b/.test(descr),
);
console.log(enEdSelection); // [ 'Red apple', 'Green Avocado' ]
Weitere Beispiele finden Sie in der Referenz zu Wortgrenzen-Assertion.
Lookahead-Assertion
In diesem Beispiel gleichen wir das Wort "First" nur ab, wenn es von dem Wort "test" gefolgt wird, jedoch wird "test" nicht in die Übereinstimmungsergebnisse aufgenommen.
const regex = /First(?= test)/g;
console.log("First test".match(regex)); // [ 'First' ]
console.log("First peach".match(regex)); // null
console.log("This is a First test in a year.".match(regex)); // [ 'First' ]
console.log("This is a First peach in a month.".match(regex)); // null
Weitere Beispiele finden Sie in der Referenz zu Lookahead-Assertion.
Grundlegende Negative Lookahead-Assertion
Beispielsweise passt /\d+(?!\.)/
auf eine Zahl nur, wenn sie nicht von einem Dezimalpunkt gefolgt wird. /\d+(?!\.)/.exec('3.141')
passt auf "141", jedoch nicht auf "3".
console.log(/\d+(?!\.)/g.exec("3.141")); // [ '141', index: 2, input: '3.141' ]
Weitere Beispiele finden Sie in der Referenz zu Lookahead-Assertion.
Verschiedene Bedeutungen der Kombination '?!' in Assertions und Zeichenklassen
Die Kombination ?!
hat unterschiedliche Bedeutungen in Assertions wie /x(?!y)/
und Zeichenklassen wie [^?!]
.
const orangeNotLemon =
"Do you want to have an orange? Yes, I do not want to have a lemon!";
// Different meaning of '?!' combination usage in Assertions /x(?!y)/ and Ranges /[^?!]/
const selectNotLemonRegex = /[^?!]+have(?! a lemon)[^?!]+[?!]/gi;
console.log(orangeNotLemon.match(selectNotLemonRegex)); // [ 'Do you want to have an orange?' ]
const selectNotOrangeRegex = /[^?!]+have(?! an orange)[^?!]+[?!]/gi;
console.log(orangeNotLemon.match(selectNotOrangeRegex)); // [ ' Yes, I do not want to have a lemon!' ]
Lookbehind-Assertion
In diesem Beispiel ersetzen wir das Wort "orange" durch "apple", nur wenn es von dem Wort "ripe" vorangestellt ist.
const oranges = ["ripe orange A", "green orange B", "ripe orange C"];
const newFruits = oranges.map((fruit) =>
fruit.replace(/(?<=ripe )orange/, "apple"),
);
console.log(newFruits); // ['ripe apple A', 'green orange B', 'ripe apple C']
Weitere Beispiele finden Sie in der Referenz zu Lookbehind-Assertion.
Siehe auch
- Reguläre Ausdrücke Leitfaden
- Zeichenklassen Leitfaden
- Quantifiers Leitfaden
- Gruppen und Rückverweise Leitfaden
RegExp
- Reguläre Ausdrücke Referenz
- Input-Grenz-Assertion:
^
,$
- Lookahead-Assertion:
(?=...)
,(?!...)
- Lookbehind-Assertion:
(?<=...)
,(?<!...)
- Wortgrenzen-Assertion:
\b
,\B