Expressions régulières en Kotlin : guide complet avec exemples

Expressions régulières en Kotlin : des bases aux techniques avancées

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte selon un modèle. En Kotlin, le travail avec les expressions régulières est implémenté via la classe Regex, qui fournit une API riche pour toutes les opérations standard. Dans cet article, nous allons analyser la syntaxe, les fonctions principales et des exemples pratiques d'utilisation des expressions régulières en Kotlin.

1. Création et syntaxe de base de Regex en Kotlin

En Kotlin, une expression régulière est créée à l'aide de la classe Regex ou via l'extension .toRegex() pour les chaînes de caractères. Tous les métacaractères et quantificateurs standard sont pris en charge.

Méthodes de création de Regex :

// Méthode 1 : via le constructeurval regex = Regex("\\\\d{3}-\\\\d{2}-\\\\d{4}")

// Méthode 2 : via toRegex()val pattern = "[a-z]+@[a-z]+\\\\.[a-z]+".toRegex()

// Méthode 3 : avec des options (insensible à la casse)val caseInsensitive = Regex("kotlin", RegexOption.IGNORE_CASE)

Métacaractères et quantificateurs principaux :

• . — n'importe quel caractère (sauf le saut de ligne)
• \\d — un chiffre (0-9)
• \\w — une lettre, un chiffre ou un tiret bas
• \\s — un caractère d'espacement
• ^ — début de la chaîne
• $ — fin de la chaîne
• * — 0 répétitions ou plus
• + — 1 répétition ou plus
• ? — 0 ou 1 répétition
• {n,m} — de n à m répétitions

2. Opérations principales : recherche, vérification et extraction

La classe Regex fournit plusieurs méthodes pour travailler avec le texte. Examinons les plus importantes.

Vérification de correspondance (matches)

La méthode matches() vérifie si la chaîne entière correspond entièrement au modèle :

val phonePattern = Regex("\\\\+7\\\\d{10}")println(phonePattern.matches("+79261234567")) // trueprintln(phonePattern.matches("+7926123456")) // false (9 chiffres au lieu de 10)

Recherche de la première correspondance (find)

La méthode find() retourne la première correspondance sous forme d'objet MatchResult? :

val text = "Contacts : email@test.com et support@domain.org"val emailRegex = "[\\\\w.]+@[\\\\w.]+\\\\.[a-z]+".toRegex()val match = emailRegex.find(text)println(match?.value) // email@test.comprintln(match?.range) // 10..23 (indices de début et de fin)

Recherche de toutes les correspondances (findAll)

Pour obtenir toutes les correspondances, utilisez findAll(), qui retourne une séquence Sequence<MatchResult> :

val allMatches = emailRegex.findAll(text)allMatches.forEach { match ->    println("Trouvé : ${match.value} à la position ${match.range.first}")}// Affichage :// Trouvé : email@test.com à la position 10// Trouvé : support@domain.org à la position 28

Vérification de présence (containsMatchIn)

La méthode containsMatchIn() retourne un Boolean — s'il y a au moins une correspondance :

val hasEmail = emailRegex.containsMatchIn(text)println(hasEmail) // true

3. Remplacement et split avec Regex

Les expressions régulières sont parfaitement adaptées pour remplacer des parties d'une chaîne et diviser du texte.

Remplacement de la première correspondance (replaceFirst)

val original = "ID : 12345, code : 67890"val digitRegex = "\\\\d+".toRegex()val masked = digitRegex.replaceFirst(original, "***")println(masked) // ID : ***, code : 67890

Remplacement de toutes les correspondances (replace)

val censored = digitRegex.replace(original, "***")println(censored) // ID : ***, code : ***

Remplacement avec une lambda

Vous pouvez passer une lambda qui sera appelée pour chaque correspondance