Regular Expressions
Modificateurs de regex (flags)

Introduction

Remarques

Modificateur DOTALL

Un modèle de regex où un modificateur DOTALL (dans la plupart des expressions de regex exprimées avec s ) modifie le comportement de . lui permettant de correspondre à un symbole de nouvelle ligne (LF):

/cat (.*?) dog/s

Cette regex de style Perl correspondra à une chaîne telle que "cat fled from\na dog" capturant "fled from\na" vers le groupe 1.

Une version en ligne: (?s) (par exemple (?s)cat (.*?) dog )

Note : En Ruby, l’équivalent du modificateur DOTALL est m , le modificateur Regexp::MULTILINE (par exemple /a.*b/m ).

Remarque : JavaScript ne fournit pas de modificateur DOTALL, donc a . ne peut jamais être autorisé à correspondre à un caractère de nouvelle ligne. Pour obtenir le même effet, une solution de contournement est nécessaire, par exemple en remplaçant tout le . s avec une classe de caractère catch-all comme [\S\s] , ou une classe de caractère non rien [^] (cependant, cette construction sera traitée comme une erreur par tous les autres moteurs et n'est donc pas portable).

Modificateur MULTILINE

Un autre exemple est un modificateur MULTILINE (généralement exprimé avec m flag (pas dans Oniguruma (par exemple Ruby) qui utilise m pour désigner un modificateur DOTALL)) qui fait que les ancres ^ et $ correspondent au début / à la fin d'une ligne , pas au début / à la fin de la chaîne entière.

/^My Line \d+$/gm

trouvera toutes les lignes commençant par My Line , puis contiendra un espace et 1+ chiffres jusqu’à la fin de la ligne.

Une version en ligne: (?m) (par exemple (?m)^My Line \d+$ )

NOTE : Dans Oniguruma (par exemple en Ruby), et aussi dans presque tous les éditeurs de texte prenant en charge les expressions rationnelles, les ancres ^ et $ indiquent les positions de début / fin de ligne par défaut . Vous devez utiliser \A pour définir le document / la chaîne de début et \z pour indiquer la fin du document / de la chaîne. La différence entre \Z et \z est que le premier peut correspondre au symbole de nouvelle ligne (LF) à la fin de la chaîne (par exemple /\Astring\Z/ trouvera une correspondance dans "string\n" ) (sauf Python, où le comportement de \Z est égal à \z et \z anchor n'est pas pris en charge).

IGNORE CASE modificateur

Le modificateur commun pour ignorer la casse est i :

/fog/i

va correspondre à Fog , foG , etc.

La version en ligne du modificateur ressemble à (?i) .

Remarques:

En Java, par défaut, la correspondance insensible à la casse suppose que seuls les caractères du jeu de caractères US-ASCII sont mis en correspondance. La correspondance insensible à la casse compatible Unicode peut être activée en spécifiant l'indicateur UNICODE_CASE conjointement avec cet CASE_INSENSITIVE ( CASE_INSENSITIVE ) . (par ex. Pattern p = Pattern.compile("YOUR_REGEX", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); ). Vous trouverez plus d'informations à ce sujet dans la correspondance insensible à la casse dans Java RegEx . De même, UNICODE_CHARACTER_CLASS peut être utilisé pour rendre la correspondance Unicode compatible.

Modificateur VERBOSE / COMMENT / IgnorePatternWhitespace

Le modificateur qui permet d'utiliser des espaces à l'intérieur de certaines parties du motif pour le formater pour une meilleure lisibilité et pour permettre des commentaires commençant par # :

/(?x)^          # start of string
  (?=\D*\d)     # the string should contain at least 1 digit 
  (?!\d+$)      # the string cannot consist of digits only
  \#            # the string starts with a hash symbol
  [a-zA-Z0-9]+ # the string should have 1 or more alphanumeric symbols
  $             # end of string
/

Exemple de chaîne: #word1here . Notez que le symbole # est échappé pour indiquer un littéral # qui fait partie d'un modèle.

L'espace blanc non échappé dans le modèle d'expression régulière est ignoré, y échappe pour en faire une partie du motif.

Généralement, les espaces à l'intérieur des classes de caractères ( [...] ) sont traités comme des espaces littéraux, sauf en Java.

En outre, il est important de mentionner que dans PCRE, .NET, Python, Ruby Oniguruma, ICU, Boost regex peut utiliser les commentaires (?#:...) dans le modèle regex.

Modificateur de capture explicite

Ceci est un modificateur spécifique à .ge regex exprimé avec n . Lorsqu'ils sont utilisés, les groupes non nommés (comme (\d+) ) ne sont pas capturés. Seules les captures valides sont des groupes explicitement nommés (par exemple (?<name> subexpression) ).

(?n)(\d+)-(\w+)-(?<id>\w+)

correspondra à l'ensemble 123-1_abc-00098 , mais (\d+) et (\w+) ne créeront pas de groupes dans l'objet de correspondance résultant. Le seul groupe sera ${id} . Voir la démo .

Modificateur UNICODE

Le modificateur UNICODE, généralement exprimé sous la forme u (PHP, Python) ou U (Java), fait que le moteur regex traite le modèle et la chaîne d'entrée comme des chaînes et des motifs Unicode, ce qui rend les classes comme \w , \d , \s , etc. compatible Unicode.

/\A\p{L}+\z/u

est une regex PHP pour correspondre à des chaînes composées d'au moins une lettre Unicode. Voir la démo regex .

Notez qu'en PHP , le modificateur /u permet au moteur PCRE de gérer les chaînes en tant que chaînes UTF8 (en PCRE_UTF8 verbe PCRE_UTF8 ) et de rendre les classes de caractères abrégées du modèle Unicode (en activant le verbe PCRE_UCP , voir plus sur pcre.org ) .

Les chaînes de motif et de sujet sont traitées comme UTF-8. Ce modificateur est disponible depuis PHP 4.1.0 ou supérieur sous Unix et depuis PHP 4.2.3 sous win32. La validité UTF-8 du modèle et du sujet est vérifiée depuis PHP 4.3.5. Un sujet invalide fera que la fonction preg_ * ne correspondra à rien; un motif invalide déclenchera une erreur de niveau E_WARNING. Les séquences UTF-8 de cinq et six octets sont considérées comme non valides depuis PHP 5.3.4 (resp. PCRE 7.3 2007-08-28); anciennement ceux-ci ont été considérés comme valables UTF-8.

Dans Python 2.x, le re.UNICODE n'affecte que le motif lui-même: Faites en re.UNICODE que \w , \W , \b , \B , \d , \D , \s et \S dépendent de la base de données des propriétés de caractère Unicode.

Une version en ligne: (?u) en Python, (?U) en Java. Par exemple:

print(re.findall(ur"(?u)\w+", u"Dąb")) # [u'D\u0105b']
print(re.findall(r"\w+", u"Dąb"))      # [u'D', u'b']

System.out.println("Dąb".matches("(?U)\\w+")); // true
System.out.println("Dąb".matches("\\w+"));     // false

Modificateur PCRE_DOLLAR_ENDONLY

Le modificateur PCRE_DOLLAR_ENDONLY compatible PCRE qui établit la correspondance $ anchor à la toute fin de la chaîne (en excluant la position avant le dernier changement de ligne dans la chaîne).

/^\d+$/D

est égal à

/^\d+\z/

et correspond à une chaîne entière composée de 1 chiffre ou plus et ne correspondra pas à "123\n" , mais correspondra à "123" .

Modificateur PCRE_ANCHORED

Un autre modificateur conforme à PCRE exprimé avec le modificateur /A Si ce modificateur est défini, le motif est obligé d'être "ancré", c'est-à-dire qu'il est contraint de ne correspondre qu'au début de la chaîne recherchée (la "chaîne sujet"). Cet effet peut également être obtenu par des constructions appropriées dans le modèle lui-même, ce qui est le seul moyen de le faire en Perl.

/man/A

est le même que

/^man/

Modificateur PCRE_UNGREEDY

L'indicateur PCRE_UNGREEDY conforme à PCRE exprimé avec /U Il fait basculer la gourmandise dans un pattern: /a.*?b/U = /a.*b/ et vice versa.

Modificateur PCRE_INFO_JCHANGED

Un autre modificateur PCRE permettant l'utilisation de groupes nommés en double.

REMARQUE : seule la version en ligne est prise en charge - (?J) et doit être placée au début du modèle.

Si tu utilises

/(?J)\w+-(?:new-(?<val>\w+)|\d+-empty-(?<val>[^-]+)-collection)/

les valeurs du groupe "val" ne seront jamais vides (seront toujours définies). Un effet similaire peut être obtenu avec la réinitialisation de branche.

Modificateur PCRE_EXTRA

Un modificateur PCRE qui provoque une erreur si une barre oblique inverse dans un motif est suivie d'une lettre sans signification particulière. Par défaut, une barre oblique suivie d'une lettre sans signification particulière est traitée comme un littéral.

Par exemple

/big\y/

va correspondre à bigy , mais

/big\y/X

jettera une exception.

Version en ligne: (?X)