Indicateurs de regex Java : CASE_INSENSITIVE, MULTILINE, DOTALL

Un indicateur modifie l'interprétation d'une expression régulière sans toucher au motif lui-même. La même expression peut correspondre avec ou sans distinction de casse, traiter une chaîne comme une seule ligne ou plusieurs, et laisser . traverser les sauts de ligne ou s'arrêter à eux — tout cela est décidé par les indicateurs. En Java, on les définit de deux façons : sous forme de constantes int passées à Pattern.compile(pattern, flags), ou sous forme de modificateurs inline (?i) écrits à l'intérieur du motif. Ce chapitre couvre les indicateurs utilisés au quotidien et la façon de les combiner.

Les deux façons de définir un indicateur

Chaque indicateur possède une constante dans la classe Pattern. Passez-la en deuxième argument à compile :

Pattern p = Pattern.compile("error", Pattern.CASE_INSENSITIVE);

Le même comportement est disponible à l'intérieur du motif sous forme de modificateur inline, ce qui permet à une expression régulière sous forme de chaîne brute de porter ses propres indicateurs sans second argument :

Pattern p = Pattern.compile("(?i)error");          // whole pattern, case-insensitive
Pattern q = Pattern.compile("(?i:error) CODE");    // only the group is case-insensitive

Les indicateurs inline sont pratiques lorsque le motif circule sous forme de chaîne brute — un fichier de configuration, une colonne de base de données, une annotation — là où il n'est pas possible de passer un int. La forme constante est plus lisible lorsque l'indicateur fait partie du code.

Les indicateurs que vous utiliserez vraiment

Constante	Inline	Effet
`CASE_INSENSITIVE`	`(?i)`	Correspondance des lettres ASCII sans distinction de casse
`MULTILINE`	`(?m)`	`^` et `$` correspondent à chaque limite de ligne, pas seulement aux extrémités de la chaîne
`DOTALL`	`(?s)`	`.` correspond également aux terminateurs de ligne (`s` = "single line")
`COMMENTS`	`(?x)`	Ignore les espaces non échappés et traite `#` comme un commentaire
`UNICODE_CASE`	`(?u)`	Fait en sorte que `CASE_INSENSITIVE` traite les lettres Unicode, pas seulement ASCII
`UNICODE_CHARACTER_CLASS`	`(?U)`	Fait en sorte que `\w`, `\d`, `\b` suivent les règles Unicode
`LITERAL`	—	Traite le motif entier comme du texte brut, sans métacaractères

Une surprise fréquente : CASE_INSENSITIVE seul ne plie que l'ASCII. Pour faire correspondre des lettres accentuées ou non latines sans distinction de casse, combinez-le avec UNICODE_CASE.

Insensibilité à la casse

Par défaut, une regex est sensible à la casse, donc error ne correspond pas à ERROR. Ajoutez CASE_INSENSITIVE et les deux correspondent :

Pattern.compile("error").matcher("ERROR").find();                      // false
Pattern.compile("error", Pattern.CASE_INSENSITIVE).matcher("ERROR").find(); // true

// For non-ASCII letters, add UNICODE_CASE:
Pattern.compile("é", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE)
       .matcher("É").find();                                           // true

Gestion des lignes : MULTILINE et DOTALL

Ces deux indicateurs sont indépendants et souvent confondus. MULTILINE modifie les ancres ^ et $ ; DOTALL modifie le point ..

String text = "first line\nsecond line";

// Without MULTILINE, ^ matches only the very start of the input.
Pattern.compile("^second").matcher(text).find();                  // false
// With MULTILINE, ^ matches the start of every line.
Pattern.compile("^second", Pattern.MULTILINE).matcher(text).find(); // true

// Without DOTALL, . will not cross the newline.
Pattern.compile("first.*second").matcher(text).find();            // false
// With DOTALL, . matches the newline too.
Pattern.compile("first.*second", Pattern.DOTALL).matcher(text).find(); // true

Utilisez MULTILINE pour analyser des journaux ou des textes multiligne ligne par ligne, et DOTALL lorsqu'une correspondance unique doit s'étendre sur plusieurs lignes (un bloc HTML, un enregistrement multiligne).

Combinaison des indicateurs

Les constantes d'indicateurs sont des masques de bits, donc vous les combinez avec l'opérateur OR bit à bit | :

int flags = Pattern.MULTILINE | Pattern.CASE_INSENSITIVE | Pattern.DOTALL;
Pattern p = Pattern.compile("^error.*done$", flags);

L'équivalent inline empile les lettres : (?ims) active les trois. Vous pouvez aussi désactiver un indicateur à l'intérieur d'un groupe avec un moins : (?-i) désactive l'insensibilité à la casse pour le reste du motif.

Motifs lisibles avec COMMENTS

L'indicateur COMMENTS (inline (?x)) permet à un motif complexe de respirer : les espaces non échappés sont ignorés et # commence un commentaire jusqu'à la fin de la ligne. Cela transforme une expression illisible en quelque chose que vous pouvez maintenir :

Pattern phone = Pattern.compile("""
    \\d{3}   # area code
    -        # separator
    \\d{4}   # line number
    """, Pattern.COMMENTS);
phone.matcher("555-1234").matches();   // true

Étant donné que les espaces réels sont ignorés, faites correspondre un espace littéral avec \\s, \\ , ou une classe de caractères comme [ ].

Un exemple complet : une expression, plusieurs indicateurs

Ce programme exécute le même ensemble de motifs avec et sans indicateurs pour que vous puissiez voir chaque indicateur changer le résultat. Il compte les correspondances sans distinction de casse, ancre les lignes avec MULTILINE, traverse les sauts de ligne avec DOTALL, combine les indicateurs avec |, et utilise à la fois les modificateurs inline globaux et délimités.

java— editable, runs on the server

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexFlagsDemo {
  public static void main(String[] args) {
    // 1. CASE_INSENSITIVE: match letters regardless of case.
    Pattern ci = Pattern.compile("error", Pattern.CASE_INSENSITIVE);
    Matcher m1 = ci.matcher("ERROR: disk full. error code 5.");
    int hits = 0;
    while (m1.find()) hits++;
    System.out.println("CASE_INSENSITIVE matches: " + hits);

// The default (no flag) is case-sensitive.
    int plain = 0;
    Matcher m0 = Pattern.compile("error").matcher("ERROR: disk full. error code 5.");
    while (m0.find()) plain++;
    System.out.println("default matches         : " + plain);

// 2. MULTILINE: ^ and $ match at every line boundary.
    String log = "warn: low memory\nerror: timeout\ninfo: ok";
    Pattern ml = Pattern.compile("^error:.*$", Pattern.MULTILINE);
    Matcher m2 = ml.matcher(log);
    m2.find();
    System.out.println("MULTILINE found line    : " + m2.group());

// 3. DOTALL: . matches newlines too, so it spans lines.
    Pattern dotall = Pattern.compile("warn.*info", Pattern.DOTALL);
    System.out.println("DOTALL spans newlines   : " + dotall.matcher(log).find());
    System.out.println("default dot stops at \\n : "
        + Pattern.compile("warn.*info").matcher(log).find());

// 4. Combine flags with bitwise OR.
    Pattern combo = Pattern.compile("^ERROR", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
    System.out.println("combined flags match    : " + combo.matcher(log).find());

// 5. Inline flag (?i) inside the pattern, no flag argument needed.
    Pattern inline = Pattern.compile("(?i)error");
    System.out.println("inline (?i) match       : " + inline.matcher("ERROR").find());

// Scoped inline flag (?i:...) applies only to the group.
    Pattern scoped = Pattern.compile("(?i:hello) WORLD");
    System.out.println("(?i:hello) WORLD vs HELLO WORLD: " + scoped.matcher("HELLO WORLD").find());
    System.out.println("(?i:hello) WORLD vs HELLO world: " + scoped.matcher("HELLO world").find());

// 6. COMMENTS (x): whitespace ignored, # starts a comment.
    Pattern commented = Pattern.compile(
        "\\d{3}  # area code \n"
      + "-       # separator \n"
      + "\\d{4}  # line number",
        Pattern.COMMENTS);
    System.out.println("COMMENTS pattern match  : " + commented.matcher("555-1234").matches());
  }
}

Ce que l'on retient de l'exécution :

CASE_INSENSITIVE a trouvé 2 occurrences de error (le ERROR en majuscules et le error en minuscules) tandis que le motif par défaut n'en a trouvé qu'1 — preuve que la sensibilité à la casse est active sauf si vous demandez l'indicateur.
MULTILINE a fait correspondre ^error:.*$ à la ligne du milieu du journal et affiché error: timeout ; sans l'indicateur, ^ et $ n'ancreraient qu'aux extrémités de la chaîne entière, donc cette ligne intérieure ne correspondrait jamais.
DOTALL a permis à warn.*info de franchir les deux sauts de ligne intégrés et de correspondre (true), alors que le même motif sans l'indicateur renvoyait false car . s'arrête par défaut à un terminateur de ligne.
Le motif combiné MULTILINE | CASE_INSENSITIVE a fait correspondre ^ERROR à une ligne qui commence effectivement par error: en minuscules — true confirme que les deux indicateurs ont été appliqués simultanément depuis un seul masque OR bit à bit.
Le (?i:hello) WORLD délimité a correspondu à HELLO WORLD (true) mais pas à HELLO world (false) : le groupe (?i:...) n'a plié la casse que pour hello, laissant le WORLD final strictement sensible à la casse — c'est précisément la précision que procure la délimitation inline.

Sujets connexes

Expressions régulières Java — Introduction — comment Pattern et Matcher s'articulent.
Pattern et Matcher — les classes qui utilisent les indicateurs ci-dessus.
Syntaxe des regex et Classes de caractères — les métacaractères que les indicateurs modifient.
Quantificateurs et Groupes — là où les modificateurs inline délimités comme (?i:...) sont les plus utiles.

Pratique

Vous compilez un motif avec Pattern.compile('first.*second', Pattern.MULTILINE) et le faites correspondre au texte 'first line\nsecond line'. Pourquoi la correspondance échoue-t-elle, et quel indicateur permettrait de corriger cela ?

MULTILINE ne change que les ancres ^ et $ ; le point s'arrête toujours au saut de ligne, donc il faut Pattern.DOTALL pour que . traverse les lignesMULTILINE est le bon indicateur, mais il doit être combiné avec CASE_INSENSITIVE pour prendre effetLa correspondance échoue parce que .* est gourmand ; passer à .*? lui permettrait de traverser le saut de ligneMULTILINE empêche . de correspondre complètement, donc supprimer l'indicateur résoudrait le problème