Expressions régulières en Kotlin avec exemples : en pratique

Expressions régulières en Kotlin avec exemples : en pratique

Les expressions régulières (regex) sont un outil puissant pour travailler avec du texte, permettant d'effectuer des recherches, des remplacements et des validations de chaînes selon un modèle. En Kotlin, le travail avec les expressions régulières est implémenté via la classe Regex et un ensemble de fonctions d'extension pratiques. Dans cet article, nous allons analyser la syntaxe, les méthodes principales et examiner des exemples pratiques qui vous aideront à maîtriser rapidement regex en Kotlin.

1. Bases du travail avec la classe Regex

En Kotlin, une expression régulière est créée à l'aide de la classe Regex. Le modèle peut être défini par une chaîne ou à l'aide d'une chaîne brute (triples guillemets """), ce qui est particulièrement pratique pour éviter d'échapper les barres obliques inverses.

// Chaîne ordinaireval pattern1 = Regex("\\\\d+")  // un ou plusieurs chiffres

// Chaîne brute (recommandée)val pattern2 = Regex("""\\d+""") // la même chose, mais sans échappement

La classe Regex accepte également des indicateurs optionnels, par exemple RegexOption.IGNORE_CASE pour une recherche insensible à la casse.

val caseInsensitive = Regex("""hello""", RegexOption.IGNORE_CASE)

2. Méthodes principales : match, find, replace

Kotlin fournit plusieurs méthodes clés pour travailler avec les expressions régulières. Examinons les plus populaires.

2.1. Méthode matchEntire (correspondance complète)

Vérifie si la chaîne entière correspond au modèle. Retourne MatchResult? ou null.

val regex = Regex("""\\d{3}-\\d{2}-\\d{4}""")val text = "123-45-6789"val matchResult = regex.matchEntire(text)println(matchResult?.value) // Affiche : 123-45-6789

// Si la chaîne ne correspond pas au modèleval badText = "123-45-678"println(regex.matchEntire(badText)) // Affiche : null

2.2. Méthode find (première correspondance)

Recherche la première occurrence du modèle dans la chaîne. Retourne MatchResult?.

val regex = Regex("""\\d+""")val text = "Prix : 150 roubles, réduction : 30%"val firstMatch = regex.find(text)println(firstMatch?.value) // Affiche : 150

2.3. Méthode findAll (toutes les correspondances)

Trouve toutes les occurrences non chevauchantes du modèle. Retourne une séquence de MatchResult.

val regex = Regex("""\\d+""")val text = "Prix : 150 roubles, réduction : 30%"val allMatches = regex.findAll(text)allMatches.forEach { println(it.value) }// Affiche :// 150// 30

2.4. Méthode replace (remplacement)

Remplace toutes les occurrences du modèle par une chaîne spécifiée ou le résultat d'une lambda.

val regex = Regex("""\\d+""")val text = "ID : 12345, code : 67890"val result = regex.replace(text, "***")println(result) // Affiche : ID : ***, code : ***

// Remplacement avec une lambda (remplacement dynamique)val dynamicResult = regex.replace(text) { matchResult ->    "[" + matchResult.value.toInt().toString() + "]"}println(dynamicResult) // Affiche : ID : [12345], code : [67890]

3. Groupes de capture (capturing groups)

Les groupes de capture permettent d'extraire des parties de la correspondance. En Kotlin, on peut accéder aux groupes par index ou par nom (si défini).

3.1. Accès par index

val regex = Regex("""(\\d{2})\\.(\\d{2})\\.(\\d{4})""") // date au format JJ.MM.AAAAval text = "Aujourd'hui : 15.03.2024"val match = regex.find(text)if (match != null) {    val (day, month, year) = match.destructured    println("Jour : $day, Mois : $month, Année : $year")    // Affiche : Jour : 15, Mois : 03, Année : 2024}

3.2. Groupes nommés

En Kotlin, on peut utiliser des groupes nommés (syntaxe (?<name>...)).

val regex = Regex("""(?<username>\\w+)@(?<domain>\\w+\\.\\w+)""")val text = "email : user@example.com"val match = regex.find(text)if (match != null) {    val username = match.groups["u