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 les chaînes de caractères. En Kotlin, elles sont implémentées sur la base des classes Java Pattern et Matcher, mais le langage y ajoute ses propres extensions pratiques et du sucre syntaxique. Dans cet article, nous allons voir comment utiliser les expressions régulières en Kotlin sur des exemples concrets : de la simple recherche au remplacement et à la division de chaînes.

Bases de la syntaxe : création et compilation

En Kotlin, une expression régulière peut être créée de deux manières : via la classe Regex ou à l'aide d'une chaîne avec un motif. La première méthode est préférable car elle offre plus de méthodes.

// Méthode 1 : via la classe Regex\nval regex = Regex("\\\\d+") // un ou plusieurs chiffres\n\n// Méthode 2 : via une chaîne (déconseillé pour les expressions complexes)\nval pattern = "\\\\d+".toRegex()

Notez la double barre oblique d'échappement : \\\\d — c'est l'échappement pour Java/Kotlin afin d'obtenir le caractère \\d dans la chaîne. Pour simplifier, Kotlin prend en charge les chaînes brutes (triples guillemets """), où l'échappement n'est pas nécessaire :

val regex = Regex("""\\d+""") // chaîne brute — les barres obliques inverses n'ont pas besoin d'être doublées

On peut également ajouter des drapeaux, par exemple RegexOption.IGNORE_CASE :

val regex = Regex("kotlin", RegexOption.IGNORE_CASE)

Recherche et vérification de correspondances

Les opérations les plus courantes sont de vérifier si une chaîne contient une sous-chaîne correspondant au motif, et de trouver toutes les correspondances.

Vérification de présence d'une correspondance : containsMatchIn

val text = "Mon numéro : 123-45-678"\nval digitRegex = Regex("""\\d+""")\n\nif (digitRegex.containsMatchIn(text)) {\n    println("Le texte contient des chiffres !")\n}

Recherche de la première correspondance : find

val result = digitRegex.find(text)\nprintln(result?.value) // Affiche : 123

Recherche de toutes les correspondances : findAll

val allMatches = digitRegex.findAll(text)\nallMatches.forEach { match ->\n    println("Trouvé : ${match.value}") // 123, 45, 678\n}

La méthode findAll retourne une séquence d'objets MatchResult. Chaque objet contient non seulement la correspondance elle-même (.value), mais aussi sa position dans la chaîne (.range).

Travail avec les groupes de capture

Les groupes de capture sont des parties du motif placées entre parenthèses. Ils permettent d'extraire des fragments de données spécifiques. Par exemple, décomposons un email en nom d'utilisateur et domaine :

val email = "user@example.com"\nval emailRegex = Regex("""(.+)@(.+)""")\nval matchResult = emailRegex.find(email)\n\nif (matchResult != null) {\n    val (username, domain) = matchResult.destructured\n    println("Nom d'utilisateur : $username") // user\n    println("Domaine : $domain")             // example.com\n}

La construction destructured permet de décomposer facilement les groupes en variables. S'il y a plus de groupes, on peut accéder par index :

val fullMatch = matchResult.value      // user@example.com\nval group1 = matchResult.groupValues[1] // user\nval group2 = matchResult.groupValues[2] // example.com

Groupes nommés (Kotlin 1.7+)

À partir de Kotlin 1.7, il est possible d'utiliser des groupes nommés :

val namedRegex = Regex("""(?<name>\\w+)@(?<domain>\\w+\\.\\w+)""")\nval match = namedRegex.find("contact@kotlin.org")\nif (match != null) {\n    println(match.groups["name"]?.value)   // contact\n    println(match.groups["domain"]?.value) // kotlin.org\n}

Remplacement de texte avec replace

La méthode replace permet de remplacer toutes les correspondances par une nouvelle chaîne. Dans le motif de remplacement, on peut faire référence aux groupes de capture avec