Reguläre Ausdrücke - Assertions

Assertions sind Metazeichen in regulären Ausdrücken, die verwendet werden, um Match-Positionen anzugeben. Sie stimmen mit keinen tatsächlichen Zeichen überein, sondern mit den Positionen zwischen Zeichen.

Angenommen, wir möchten in einem langen Artikel alle Zahlen finden, die auf einen Preis folgen, statt alle Zahlen zu finden. Ein regulärer Ausdruck könnte alle Zahlen abgleichen, aber mit Assertions können Sie präzise angeben:Ich gleiche nur die Zahlen ab, die unmittelbar auf Preise folgen。

Dieser Artikel vermittelt Ihnen systematisch die vier grundlegenden Assertions in regulären Ausdrücken: positiver Lookahead, negativer Lookahead, positiver Lookbehind und negativer Lookbehind.

Eigenschaften von Assertions

  1. Nullbreite: Belegt keine Positionen übereinstimmender Zeichen
  2. Bedingungsprüfung: Prüft nur, ob eine bestimmte Bedingung erfüllt ist
  3. Beeinflusst das Übereinstimmungsergebnis nicht: Dient nur als Einschränkung für die Übereinstimmung

Beispiel

// Beispiel: Übereinstimmung mit foo, auf das bar folgt
const regex = /foo(?=bar)/;
console.log(regex.test("foobar"));  // true
console.log(regex.test("food"));    // false

Arten von Assertions

Assertions in regulären Ausdrücken werden hauptsächlich in zwei Kategorien und vier Typen unterteilt:

Assertion-Typ Regex-Syntax Alias Prüfrichtung Erwartete Bedingung Einfache Erklärung
Positiver Lookahead (?=pattern) Positiver Lookahead Rechts (vorwärts) Exists pattern Die Position, die ich suche, ihrerechte Seite musssein...
Negativer Lookahead (?!pattern) Negativer Lookahead Rechts (vorwärts) Existiert nicht pattern Die Position, die ich suche, ihrerechte Seite darf nichtsein...
Positiver Lookbehind (?<=pattern) Positiver Lookbehind Links (rückwärts) Exists pattern Die Position, die ich suche, ihrelinke Seite musssein...
Negativer Lookbehind (?<!pattern) Negativer Lookbehind Links (rückwärts) Existiert nicht pattern Die Position, die ich suche – ihrelinke Seite darf nichtsein...

Positiver Lookahead(?=...)

Positiver LookaheadWird verwendet, um eine Position so abzugleichen, dass unmittelbar nach dieser Position (rechts) das angegebene Muster erscheinen muss....。

Syntax und Parameter

  • Syntax:(?=pattern)
  • Funktion: Prüft, ob die rechte Seite der aktuellen Position übereinstimmtpattern. Wenn sie übereinstimmt, ist die Assertion erfolgreich, und die Engine kehrt zur aktuellen Position zurück, um das weitere Matching fortzusetzen.
  • Hauptmerkmale:Zero-Width, was bedeutet, dass sie nur prüft und keine Zeichen "konsumiert".patternDer Inhalt innerhalb der Assertion wird nicht Teil des endgültigen Match-Ergebnisses.

Codebeispiel 1: Extrahieren von Preisnummern

Angenommen, wir haben einen Text und müssen allePreise extrahieren:die Betragszahlen danach.

Beispiel: JavaScript

const text = "Preis für Produkt A: 299 yuan, Preis für Produkt B: 599 yuan, Versand: 20 yuan.";

// Positives Lookahead
// Eine oder mehrere Ziffern finden, aber es wird verlangt, dass auf der rechten Seite unmittelbar \"yuan\" folgt
// \"yuan\" selbst ist nicht im Übereinstimmungsergebnis enthalten
const pattern = /\d+(?=元)/g;

const matches = text.match(pattern);

console.log(\"Übereinstimmende Preisnummern:\", matches);
// Ausgabe: ['299', '599', '20']

Beispiel: Python

import re

text = \"Preis für Produkt A: 299 yuan, Preis für Produkt B: 599 yuan, Versand: 20 yuan.\"

# Positives Lookahead verwenden
# Eine oder mehrere Ziffern (\\d+) finden, aber es wird verlangt, dass auf der rechten Seite dieser Zahl unmittelbar \"yuan\" folgt
# Hinweis: "yuan" selbst wird nicht in das Ergebnis aufgenommen
pattern = r'\d+(?=元)'
matches = re.findall(pattern, text)

print("Gefundene Preisnummern:", matches)
# Ausgabe: Gefundene Preisnummern: ['299', '599', '20']

Code-Erklärung:

  1. \d+ist der Hauptausdruck, der auf eine oder mehrere Ziffern passt.
  2. (?=yuan)ist die Assertion, sie prüft\d+der übereinstimmenden Ziffernfolgerechten Seiteob unmittelbar ein "yuan"-Zeichen darauf folgt.
  3. Die Engine findet zuerst299, schaut dann nach rechts, findet "yuan", die Assertion gelingt, also299wird erfasst.
  4. Dann sucht sie weiter nach599, die rechte Seite ist "yuan", ist erfolgreich, erfasst es.
  5. Findet20, die rechte Seite ist "Yuan", trifft zu und erfasst sie. Am Ende erhalten wir nur den numerischen Teil.

Codebeispiel 2: Komplexe Passwörter validieren

Anforderung: Das Passwort muss mindestens einen Großbuchstaben, einen Kleinbuchstaben und eine Ziffer enthalten.

Beispiel: JavaScript

function validatePassword(password) {
  // Mehrere positive Lookahead-Assertions
  const pattern = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$/;
  // ^ Anfang der Zeichenkette
  // (?=.*[A-Z]) Die rechte Seite muss mindestens einen Großbuchstaben enthalten
  // (?=.*[a-z]) Die rechte Seite muss mindestens einen Kleinbuchstaben enthalten
  // (?=.*\d) Die rechte Seite muss mindestens eine Ziffer enthalten
  // .{8,} Gesamtlänge mindestens 8
  // $ Ende der Zeichenkette

  return pattern.test(password);
}

// Testdaten
const passwords = ["Weak", "strong123", "STRONG123", "Strong123"];

passwords.forEach(pwd => {
  console.log(`Passwort'${pwd}'ist gültig: ${validatePassword(pwd)}`);
});

// Ausgabe:
// Passwort 'Weak' ist gültig: false
// Passwort 'strong123' ist gültig: false
// Passwort 'STRONG123' ist gültig: false
// Passwort 'Strong123' ist gültig: true

Beispiel: Pyhton

import re

def validate_password(password):
    # Verwende mehrere positive Lookahead-Assertions, um Bedingungen separat zu prüfen
    pattern = r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$'
    # ^ repräsentiert den Anfang der Zeichenkette
    # (?=.*[A-Z]) Assertion: Von der aktuellen Position (Start) aus nach rechts gesehen muss man nach beliebigen Zeichen (.*) einen Großbuchstaben finden können
    # (?=.*[a-z]) Assertion: Ähnlich muss man vom Start aus nach rechts gesehen einen Kleinbuchstaben finden können
    # (?=.*\d) Assertion: Vom Start aus nach rechts gesehen muss man eine Ziffer finden können
    # .{8,} Hauptausdruck: stimmt mit einem beliebigen Zeichen mindestens 8 Mal überein (Anforderung an die Gesamtlänge)
    # $ repräsentiert das Ende der Zeichenkette
    if re.match(pattern, password):
        return True
    else:
        return False

# Testdaten
passwords = ["Weak", "strong123", "STRONG123", "Strong123"]
for pwd in passwords:
    print(f"Passwort '{pwd}' ist gültig: {validate_password(pwd)}")

# Output:
# Passwort 'Weak' ist gültig: False # Länge unzureichend und fehlende Ziffer
# Passwort 'strong123' ist gültig: False # Fehlender Großbuchstabe
# Passwort 'STRONG123' ist gültig: False # Fehlender Kleinbuchstabe
# Passwort 'Strong123' ist gültig: True # Erfüllt alle Bedingungen

Negativer Lookahead(?!...)

Negativer LookaheadDas Gegenteil von positivem Lookahead. Er stimmt mit einer Position überein, sodass nach dieser Position (rechts) das angegebene Musternichtunmittelbar folgen darf...。

Syntax und Parameter

  • Syntax:(?!pattern)
  • Zweck: Prüfen, ob die rechte Seite der aktuellen Positionnicht übereinstimmt pattern. Wenn sie nicht übereinstimmt, ist die Assertion erfolgreich.
  • Hauptmerkmale: Ebenfalls nullbreit.

Codebeispiel: Wörter finden, die nicht auf ing enden

In einem Satz alle Wörter findeningdie nicht damit enden.

Beispiel: JavaScript

// Beispiel 1: Negative Lookahead-Assertion
const text1 = "playing swimming run walk jumping sing";
const pattern1 = /\b\w+(?<!ing)\b/g;
console.log(text1.match(pattern1));
// ['run', 'walk', 'sing']

// Beispiel 2: Wörter abgleichen, die nicht mit q enden (semantisch korrekte Version)
const text2 = "I like faq apple Iraq you banana q";
const pattern2 = /\b\w*[^q\W]\b/g;
// Bedeutung:
// [^q\W] Das letzte Zeichen des Wortes ist nicht q
// Erfüllt die eigentliche Anforderung "nicht mit q enden" besser als (?!q)
console.log(text2.match(pattern2));
// ['I', 'like', 'apple', 'you', 'banana']

// Beispiel 3: Dateinamen abgleichen, die nicht mit .js enden
const files = "index.js app.ts config.json main.js readme.md";
const pattern3 = /\b\w+\.(?!js\b)\w+\b/g;
// Bedeutung: \.(?!js\b) Der Punkt darf nicht von js gefolgt werden
console.log(files.match(pattern3));
// ['app.ts', 'config.json', 'readme.md']

Positiver Lookbehind(?<=...)

Positive Lookbehind-AssertionWird verwendet, um eine Position zu finden, an der das angegebene Muster unmittelbar vor dieser Position (links davon) stehen muss....。

Hinweis: Nicht alle Regex-Engines von Programmiersprachen unterstützen Lookbehind-Assertions. JavaScript unterstützt sie erst ab ES2018 vollständig, und Pythonsre`re`-Modul unterstützt sie.

Syntax und Parameter

  • Syntax:(?<=pattern)
  • Zweck: Prüfen, ob die linke Seite der aktuellen Position übereinstimmtpattern. Wenn sie übereinstimmt, ist die Assertion erfolgreich.
  • Hauptmerkmale: Nullbreite.patternMuss eine feste Länge haben (darf nicht*oder+ein Quantifizierer mit variabler Länge usw. sein, in einigen Implementierungen).

Codebeispiel: Beträge nach Währungssymbolen extrahieren

Extrahiere die Ziffern nach dem Dollar- oder Pfundzeichen, aber ohne das Zeichen selbst.

Beispiel: JavaScript

// Beispiel 1: Den Betrag nach $ oder £ abgleichen (klassisch, semantisch korrekt)
const text1 = "Price: $199, £89, ¥1200";
const pattern1 = /(?<=\$|£)\d+/g;
// Bedeutung:
// (?<=\$|£) Die linke Seite muss $ oder £ sein
// \d+ Die Ziffern selbst abgleichen
console.log(text1.match(pattern1));
// ['199', '89']

// Beispiel 2: Die Zahl nach einem Doppelpunkt abgleichen
const text2 = "port:8080 pid:1234 uid:1000";
const pattern2 = /(?<=:)\d+/g;
// Die linke Seite muss : sein
console.log(text2.match(pattern2));
// ['8080', '1234', '1000']

// Beispiel 3: Die Minor-Version in einer Versionsnummer abgleichen (nach der Major-Version)
const text3 = "v1.2 v2.15 v10.3";
const pattern3 = /(?<=v\d+\.)\d+/g;
// Die linke Seite muss v + Ziffern + Punkt sein
console.log(text3.match(pattern3));
// ['2', '15', '3']

// Beispiel 4: Den Benutzernamen nach @ abgleichen (ohne @ einzuschließen)
const text4 = "hello @alice and @bob_smith";
const pattern4 = /(?<=@)[a-zA-Z_]\w*/g;
console.log(text4.match(pattern4));
// ['alice', 'bob_smith']

// Beispiel 5: Die Kapitelnummer im chinesischen "第 X 章" abgleichen
const text5 = "第1章 第12章 第3章";
const pattern5 = /(?<=第)\d+(?=章)/g;
// Beide Seiten gleichzeitig einschränken, klarer
console.log(text5.match(pattern5));
// ['1', '12', '3']

Negativer Lookbehind(?<!...)

Negative Lookbehind-AssertionSie ist das Gegenteil der positiven Lookbehind-Assertion. Sie stimmt mit einer Position überein, an der vor ihr (links),das angegebene Muster nichtunmittelbar erscheinen kann....。

Syntax und Parameter

  • Syntax:(?<!pattern)
  • Zweck: Prüfen, ob die linke Seite der aktuellen Positionnicht übereinstimmt pattern。
  • Hauptmerkmale: Nullbreite, erfordert normalerweisepatterneine feste Länge.

Codebeispiel: Nicht-negative Ganzzahlen finden

Suchen Sie in einem Absatz nach allen Ganzzahlen, die nicht negativ sind (d. h. kein Minuszeichen auf der linken Seite-der Ziffer).

Beispiel: JavaScript

const text = "Heute beträgt die Temperatur -5 Grad, morgen wird sie auf 3 Grad steigen, übermorgen wird sie -1 Grad betragen, und die Temperatur im Innenraum bleibt bei 22 Grad.";

// Negative Lookbehind-Assertion
// Ziffern abgleichen, aber die linke Seite darf kein Minuszeichen sein -
const pattern = /(?<!-)\b\d+\b/g;

const matches = text.match(pattern);

console.log("Nicht-negative Ganzzahlen:", matches);
// Ausgabe: ['3', '22']
// Die linke Seite von -5 und -1 ist '-', die Assertion schlägt fehl, kein Match

Umfassende Anwendung und Flussdiagramm

Um den Ablauf der vier Assertions intuitiver zu verstehen, können wir das folgende Flussdiagramm verwenden, um einen komplexen Matching-Prozess mit mehreren Assertions zu veranschaulichen:

Flussdiagrammbeschreibung: Das Diagramm zeigt, wie die Regex-Engine Assertions während des Matchings behandelt. Der Kern ist, dassAssertions unabhängige Prüfknoten sind. Die Engine, an deraktuellen Position, an der der Hauptausdruck zu matchen versucht,prüft den Kontext nach links oder rechts je nach Assertion-Typ. Nur wenn alle Assertion-Bedingungen erfüllt sind, kann der Match vorwärts fortgesetzt werden und Zeichen "konsumieren"; andernfalls geht die Engine zurück, um andere Möglichkeiten zu versuchen, oder erklärt einen Match-Fehler.

Tab-Wechsel
Positive Lookahead-Assertion
Negative Lookahead-Assertion
Positive Lookbehind-Assertion
Negative Lookbehind-Assertion
Umfassende Übung
Interaktives Testen
Positive Lookahead-Assertion
Positive Lookahead-Assertion
(?=pattern)
Negative Lookahead-Assertion
Negative Lookahead-Assertion
(?!pattern)
Positive Lookbehind-Assertion
Positive Lookbehind-Assertion
(?<=pattern)
Negative Lookbehind-Assertion
Negative Lookbehind-Assertion
(?<!pattern)
Umfassende Übung
Umfassendes Übungsbeispiel
Interaktiver Test
Interaktiver Testbereich

Mini-Quiz zu Assertions in regulären Ausdrücken

1. Für das Muster `Python(?=3)` in der Zeichenfolge `"我喜欢Python3和Python2"`, welche der folgenden ist korrekt?

2. Welche Assertion kann verwendet werden, um eine Ziffer `7` zu matchen, der nicht der Buchstabe `q` vorausgeht?

3. Wie lautet das Match-Ergebnis des Musters `(?<=@)\w+` in der Zeichenkette `"联系 @admin 和 user@example.com"`?

4. Was sind die Hauptmerkmale von Assertions? (Mehrfachauswahl)

Andere Erweiterungen