Expressions régulières - Assertions

Les assertions sont des métacaractères dans les expressions régulières utilisés pour spécifier des positions de correspondance. Elles ne correspondent à aucun caractère réel, mais plutôt aux positions entre les caractères.

Supposons que nous voulions trouver tous les nombres qui suivent un prix dans un long article, plutôt que de trouver tous les nombres. Une expression régulière pourrait correspondre à tous les nombres, mais avec des assertions, vous pouvez spécifier précisément :Je ne fais correspondre que les nombres qui suivent immédiatement les prix。

Cet article vous enseignera systématiquement quatre assertions fondamentales des expressions régulières : l'anticipation positive, l'anticipation négative, la rétrospective positive et la rétrospective négative.

Caractéristiques des assertions

  1. Largeur nulle: n'occupe pas les positions des caractères correspondants
  2. Vérification de condition: vérifie uniquement si une condition spécifique est remplie
  3. N'affecte pas le résultat de la correspondance: sert uniquement de contrainte pour la correspondance

Exemple

// Exemple : correspond à foo suivi de bar
const regex = /foo(?=bar)/;
console.log(regex.test("foobar"));  // true
console.log(regex.test("food"));    // false

Types d'assertions

Les assertions dans les expressions régulières se divisent principalement en deux catégories et quatre types :

Type d'assertion Syntaxe regex Alias Direction de vérification Condition attendue Explication simple
Anticipation positive (?=pattern) anticipation positive Droite (avant) Exists pattern La position que je recherche, soncôté droit doitêtre...
Anticipation négative (?!pattern) anticipation négative Droite (avant) N'existe pas pattern La position que je recherche, soncôté droit ne doit pasêtre...
Rétrospective positive (?<=pattern) rétrospective positive Gauche (arrière) Exists pattern La position que je recherche, soncôté gauche doitêtre...
Lookbehind négatif (?<!pattern) lookbehind négatif Gauche (arrière) N'existe pas pattern La position que je recherche, soncôté gauche ne doit pasêtre...

Anticipation positive(?=...)

Lookahead positifSert à faire correspondre une position telle qu'immédiatement après cette position (à droite), le motif spécifié doit apparaître....。

Syntaxe et paramètres

  • Syntaxe:(?=pattern)
  • Fonction: Vérifie si le côté droit de la position actuelle correspondpattern. Si cela correspond, l'assertion réussit et le moteur revient à la position actuelle pour continuer la correspondance suivante.
  • Caractéristiques clés:Largeur nulle, ce qui signifie qu'il vérifie seulement et ne "consomme" aucun caractère.patternLe contenu à l'intérieur de l'assertion ne fera pas partie du résultat de correspondance final.

Exemple de code 1 : Extraction de nombres de prix

Supposons que nous ayons un morceau de texte et que nous devions extraire tousles prix :les montants numériques qui les suivent.

Exemple : JavaScript

const text = "Prix du produit A : 299 yuan, prix du produit B : 599 yuan, frais de port : 20 yuan.";

// Lookahead positif
// Faire correspondre un ou plusieurs chiffres, mais exiger que le côté droit soit immédiatement suivi de "yuan"
// "yuan" lui-même n'est pas inclus dans le résultat de la correspondance
const pattern = /\d+(?=元)/g;

const matches = text.match(pattern);

console.log("Nombres de prix correspondants :", matches);
// Sortie : ['299', '599', '20']

Exemple : Python

import re

text = "Prix du produit A : 299 yuan, prix du produit B : 599 yuan, frais de port : 20 yuan."

# Utiliser un lookahead positif
# Faire correspondre un ou plusieurs chiffres (\d+), mais exiger que le côté droit de ce nombre soit immédiatement suivi de "yuan"
# Remarque : "yuan" lui-même ne sera pas inclus dans le résultat
pattern = r'\d+(?=元)'
matches = re.findall(pattern, text)

print("Nombres de prix correspondants :", matches)
# Sortie : Nombres de prix correspondants : ['299', '599', '20']

Explication de code:

  1. \d+est l'expression principale, correspondant à un ou plusieurs chiffres.
  2. (?=yuan)est l'assertion, elle vérifie\d+de la chaîne de chiffres correspondantecôté droitsi elle est immédiatement suivie d'un caractère "yuan".
  3. Le moteur trouve d'abord299, puis regarde à droite, trouve "yuan", l'assertion réussit, donc299est enregistré.
  4. Puis continue à trouver599, le côté droit est "yuan", réussit, l'enregistre.
  5. Trouve20, le côté droit est "yuan", réussit, l'enregistre. Au final, on ne récupère que la partie numérique.

Exemple de code 2 : Validation de mots de passe complexes

Exigence : le mot de passe doit contenir au moins une lettre majuscule, une lettre minuscule et un chiffre.

Exemple : JavaScript

function validatePassword(password) {
  // Plusieurs assertions de prévision positive
  const pattern = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$/;
  // ^ Début de la chaîne
  // (?=.*[A-Z]) Le côté droit doit contenir au moins une lettre majuscule
  // (?=.*[a-z]) Le côté droit doit contenir au moins une lettre minuscule
  // (?=.*\d) Le côté droit doit contenir au moins un chiffre
  // .{8,} Longueur totale d'au moins 8
  // $ Fin de la chaîne

  return pattern.test(password);
}

// Données de test
const passwords = ["Weak", "strong123", "STRONG123", "Strong123"];

passwords.forEach(pwd => {
  console.log(`Mot de passe'${pwd}'est valide : ${validatePassword(pwd)}`);
});

// Sortie :
// Le mot de passe 'Weak' est valide : false
// Le mot de passe 'strong123' est valide : false
// Le mot de passe 'STRONG123' est valide : false
// Le mot de passe 'Strong123' est valide : true

Exemple : Pyhton

import re

def validate_password(password):
    # Utiliser plusieurs assertions d'anticipation positive pour vérifier les conditions séparément
    pattern = r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$'
    # ^ représente le début de la chaîne
    # (?=.*[A-Z]) Assertion : en regardant vers la droite à partir de la position actuelle (début), vous devez pouvoir trouver une lettre majuscule après n'importe quels caractères (.*)
    # (?=.*[a-z]) Assertion : de même, en regardant vers la droite depuis le début, vous devez pouvoir trouver une lettre minuscule
    # (?=.*\d) Assertion : en regardant vers la droite depuis le début, vous devez pouvoir trouver un chiffre
    # .{8,} Expression principale : correspond à n'importe quel caractère au moins 8 fois (exigence de longueur totale)
    # $ représente la fin de la chaîne
    if re.match(pattern, password):
        return True
    else:
        return False

# Données de test
passwords = ["Weak", "strong123", "STRONG123", "Strong123"]
for pwd in passwords:
    print(f"Password '{pwd}' is valid: {validate_password(pwd)}")

# Sortie :
# Le mot de passe 'Weak' est valide : False # Longueur insuffisante, et chiffre manquant
# Le mot de passe 'strong123' est valide : False # Lettre majuscule manquante
# Mot de passe 'STRONG123' est valide : False # Lettre minuscule manquante
# Mot de passe 'Strong123' est valide : True # Toutes les conditions sont remplies

Anticipation négative(?!...)

Lookahead négatifL'opposé du lookahead positif. Il correspond à une position telle qu'après cette position (vers la droite),ne doit passuivre immédiatement le motif spécifié...。

Syntaxe et paramètres

  • Syntaxe:(?!pattern)
  • Objectif: Vérifier si le côté droit de la position actuellene correspond pas pattern. Si cela ne correspond pas, l'assertion réussit.
  • Caractéristiques clés: Également de largeur nulle.

Exemple de code : Trouver des mots ne se terminant pas par ing

Dans une phrase, trouver tous les motsingqui ne se terminent pas par.

Exemple : JavaScript

// Exemple 1 : Assertion lookahead négative
const text1 = "playing swimming run walk jumping sing";
const pattern1 = /\b\w+(?<!ing)\b/g;
console.log(text1.match(pattern1));
// ['run', 'walk', 'sing']

// Exemple 2 : faire correspondre les mots ne se terminant pas par q (version sémantiquement correcte)
const text2 = "I like faq apple Iraq you banana q";
const pattern2 = /\b\w*[^q\W]\b/g;
// Signification :
// [^q\W] Le dernier caractère du mot n'est pas q
// Correspond mieux à l'exigence réelle de « ne pas se terminer par q » que (?!q)
console.log(text2.match(pattern2));
// ['I', 'like', 'apple', 'you', 'banana']

// Exemple 3 : faire correspondre les noms de fichiers ne se terminant pas par .js
const files = "index.js app.ts config.json main.js readme.md";
const pattern3 = /\b\w+\.(?!js\b)\w+\b/g;
// Signification : \.(?!js\b) Le point ne doit pas être suivi de js
console.log(files.match(pattern3));
// ['app.ts', 'config.json', 'readme.md']

Rétrospective positive(?<=...)

Assertion lookbehind positiveUtilisée pour correspondre à une position où le motif spécifié doit apparaître immédiatement avant cette position (à gauche)....。

Remarque : tous les moteurs d'expressions régulières des langages de programmation ne prennent pas en charge les assertions lookbehind. JavaScript ne les prend entièrement en charge qu'à partir d'ES2018, et leremodule `re` de Python les prend en charge.

Syntaxe et paramètres

  • Syntaxe:(?<=pattern)
  • Objectif: Vérifier si le côté gauche de la position actuelle correspondpattern. Si cela correspond, l'assertion réussit.
  • Caractéristiques principales: Largeur nulle.patternDoit avoir une longueur fixe (ne peut pas être*ou+un quantificateur de longueur variable, etc., dans certaines implémentations).

Exemple de code : extraction des montants après les symboles monétaires

Extraire les chiffres après le symbole dollar ou livre, mais sans inclure le symbole lui-même.

Exemple : JavaScript

// Exemple 1 : faire correspondre le montant après $ ou £ (classique, sémantiquement correct)
const text1 = "Prix : $199, £89, ¥1200";
const pattern1 = /(?<=\$|£)\d+/g;
// Signification :
// (?<=\$|£) Le côté gauche doit être $ ou £
// \d+ Correspond aux chiffres eux-mêmes
console.log(text1.match(pattern1));
// ['199', '89']

// Exemple 2 : faire correspondre le nombre après un deux-points
const text2 = "port:8080 pid:1234 uid:1000";
const pattern2 = /(?<=:)\d+/g;
// Le côté gauche doit être :
console.log(text2.match(pattern2));
// ['8080', '1234', '1000']

// Exemple 3 : faire correspondre la version mineure dans un numéro de version (après le numéro de version majeure)
const text3 = "v1.2 v2.15 v10.3";
const pattern3 = /(?<=v\d+\.)\d+/g;
// Le côté gauche doit être v + chiffres + point
console.log(text3.match(pattern3));
// ['2', '15', '3']

// Exemple 4 : faire correspondre le nom d'utilisateur après @ (sans inclure @)
const text4 = "hello @alice and @bob_smith";
const pattern4 = /(?<=@)[a-zA-Z_]\w*/g;
console.log(text4.match(pattern4));
// ['alice', 'bob_smith']

// Exemple 5 : faire correspondre le numéro de chapitre en chinois "第 X 章"
const text5 = "第1章 第12章 第3章";
const pattern5 = /(?<=第)\d+(?=章)/g;
// Contraindre les deux côtés simultanément, plus clair
console.log(text5.match(pattern5));
// ['1', '12', '3']

Lookbehind négatif(?<!...)

Assertion lookbehind négativeC'est l'opposé du lookbehind positif. Elle correspond à une position où, avant elle (à gauche),le motif spécifié ne peut pasapparaître immédiatement....。

Syntaxe et paramètres

  • Syntaxe:(?<!pattern)
  • Objectif: Vérifier si le côté gauche de la position actuellene correspond pas pattern。
  • Caractéristiques clés: Largeur nulle, nécessite généralementpatternune longueur fixe.

Exemple de code : Recherche d'entiers non négatifs

Dans un paragraphe, faire correspondre tous les entiers qui ne sont pas négatifs (c'est-à-dire sans signe moins à gauche-du chiffre).

Exemple : JavaScript

const text = "La température d'aujourd'hui est de -5 degrés, demain elle montera à 3 degrés, après-demain elle sera de -1 degrés, et la température intérieure reste de 22 degrés.";

// Assertion lookbehind négative
// Faire correspondre des chiffres, mais exiger que le côté gauche ne puisse pas être un signe moins -
const pattern = /(?<!-)\b\d+\b/g;

const matches = text.match(pattern);

console.log("Entiers non négatifs :", matches);
// Sortie : ['3', '22']
// Le côté gauche de -5 et -1 est '-', l'assertion échoue, aucune correspondance

Application complète et diagramme de flux

Pour mieux comprendre de façon intuitive le flux de travail des quatre assertions, nous pouvons utiliser le diagramme de flux suivant pour illustrer un processus de correspondance complexe contenant plusieurs assertions :

Description du diagramme de flux: Le diagramme montre comment le moteur regex gère les assertions pendant la correspondance. Le point central est queles assertions sont des nœuds de vérification indépendants. Le moteur, à laposition actuelle où l'expression principale tente de correspondre,vérifie le contexte à gauche ou à droite selon le type d'assertion. Ce n'est que lorsque toutes les conditions d'assertion sont remplies que la correspondance peut continuer vers l'avant et "consommer" des caractères ; sinon, le moteur revient en arrière pour essayer d'autres possibilités ou déclare un échec de correspondance.

Changement d'onglets
Assertion d'anticipation positive
Assertion d'anticipation négative
Assertion de rétrospection positive
Assertion de rétrospection négative
Pratique complète
Tests interactifs
Assertion d'anticipation positive
Assertion d'anticipation positive
(?=pattern)
Assertion d'anticipation négative
Assertion d'anticipation négative
(?!pattern)
Assertion de rétrospection positive
Assertion de rétrospection positive
(?<=pattern)
Assertion de rétrospection négative
Assertion de rétrospection négative
(?<!pattern)
Pratique complète
Exemple pratique complet
Test interactif
Zone de test interactif

Mini-quiz sur les assertions d'expressions régulières

1. Pour le motif `Python(?=3)` dans la chaîne `"我喜欢Python3和Python2"`, laquelle des propositions suivantes est correcte ?

2. Quelle assertion peut être utilisée pour correspondre à un chiffre `7` qui n'est pas précédé par la lettre `q` ?

3. Quel est le résultat de correspondance du motif `(?<=@)\w+` dans la chaîne `"联系 @admin 和 user@example.com"` ?

4. Quelles sont les principales caractéristiques des assertions ? (Choix multiple)

Autres extensions