Assertions
Assertionen umfassen Begrenzungen, die den Anfang und das Ende von Zeilen und Wörtern anzeigen, sowie andere Muster, die auf irgendeine Weise andeuten, dass ein Treffer möglich ist (einschließlich Look-ahead, Look-behind und bedingte Ausdrücke).
Probieren Sie es aus
Typen
Begrenzungs-Typ Assertionen
| Zeichen | Bedeutung |
|---|---|
^ |
Anfangs-Assertions-Grenze:
Entspricht dem Anfang der Eingabe. Wenn das Hinweis: Dieses Zeichen hat eine andere Bedeutung, wenn es am Anfang einer Zeichenklasse erscheint. |
$ |
Ende-Assertions-Grenze:
Entspricht dem Ende der Eingabe. Wenn das |
\b |
Wort-Grenzen-Assertion: Entspricht einer Wortgrenze. Dies ist die Position, an der ein Wortzeichen nicht von einem anderen Wortzeichen gefolgt oder vorhergegangen wird, wie z.B. zwischen einem Buchstaben und einem Leerzeichen. Beachten Sie, dass eine gefundene Wortgrenze nicht im Treffer enthalten ist. Mit anderen Worten, die Länge einer gefundenen Wortgrenze ist null. Beispiele:
Um ein Rückschrittzeichen ( |
\B |
Nicht-Wort-Grenzen-Assertion:
Entspricht 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 sein, oder
beide müssen Nicht-Wörter sein, z.B. zwischen zwei Buchstaben oder zwei
Leerzeichen. Der Anfang und das Ende einer Zeichenkette werden als Nicht-Wörter angesehen.
Genauso wie die gefundene Wortgrenze ist die gefundene Nicht-Wortgrenze
auch nicht im Treffer enthalten. Zum Beispiel
|
Andere Assertionen
Hinweis:
Das Zeichen ? kann auch als Quantor verwendet werden.
| Zeichen | Bedeutung |
|---|---|
x(?=y) |
Lookahead-Assertion:
Entspricht "x" nur, wenn "x"
von "y" gefolgt wird. Zum Beispiel passt |
x(?!y) |
Negative Lookahead-Assertion:
Entspricht "x" nur, wenn "x"
nicht von "y" gefolgt wird. Zum Beispiel passt |
(?<=y)x |
Lookbehind-Assertion:
Entspricht "x" nur, wenn "x"
von "y" vorhergegangen wird. Zum Beispiel passt
|
(?<!y)x |
Negative Lookbehind-Assertion:
Entspricht "x" nur, wenn
"x" nicht von "y" vorhergegangen wird. Zum Beispiel passt
|
Beispiele
Allgemeine Überblicksbeispiele zu Begrenzungen
// 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'.
Das Anfang der Eingabe mit einem ^ Steuerzeichen abgleichen
Verwenden Sie ^, um am Anfang der Eingabe abzugleichen. In diesem Beispiel können wir die Früchte erhalten, die mit 'A' beginnen, indem wir einen /^A/ Regex verwenden. Zum Auswählen der passenden Früchte können wir die filter Methode mit einer Pfeil- Funktion nutzen.
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 zum Abgleichen am Anfang der Eingabe verwendet als auch zum Erstellen einer negierten oder ergänzenden Zeichenklasse, wenn es innerhalb von Zeichenklassen eingesetzt wird.
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' ]
Siehe weitere Beispiele in der Referenz zur Eingabe-Grenz-Assertion.
Eine Wortgrenze abgleichen
In diesem Beispiel gleichen wir Fruchtnamen ab, die ein Wort enthalten, das in "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' ]
Siehe weitere Beispiele in der Referenz zur Wort-Grenzen-Assertion.
Lookahead-Assertion
In diesem Beispiel gleichen wir das Wort "First" nur ab, wenn es von dem Wort "test" gefolgt wird, aber wir schließen "test" nicht in die Treffer-Ergebnisse ein.
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
Siehe weitere Beispiele in der Referenz zur Lookahead-Assertion.
Grundlegende negative Lookahead-Assertion
Zum Beispiel passt /\d+(?!\.)/ zu einer Zahl nur, wenn sie nicht von einem Dezimalpunkt gefolgt wird. /\d+(?!\.)/.exec('3.141') passt zu "141", aber nicht zu "3".
console.log(/\d+(?!\.)/g.exec("3.141")); // [ '141', index: 2, input: '3.141' ]
Siehe weitere Beispiele in der Referenz zur Lookahead-Assertion.
Unterschiedliche Bedeutung der '?!' Kombination bei der Verwendung in Assertionen und Zeichenklassen
Die ?! Kombination hat unterschiedliche Bedeutungen in Assertionen 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" vorhergegangen wird.
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']
Siehe weitere Beispiele in der Referenz zur Lookbehind-Assertion.
Siehe auch
- Reguläre Ausdrücke Leitfaden
- Zeichenklassen Leitfaden
- Quantoren Leitfaden
- Gruppen und Rückverweise Leitfaden
RegExp- Reguläre Ausdrücke Referenz
- Eingabe-Grenz-Assertion:
^,$ - Lookahead-Assertion:
(?=...),(?!...) - Lookbehind-Assertion:
(?<=...),(?<!...) - Wort-Grenzen-Assertion:
\b,\B