Scala et les expressions régulières

Leave a Comment
Les expressions régulières sont puissantes et utilisées pour faire des choses comme la recherche, la suppression ou le remplacement de texte. Je vous propose dans ce billet d’explorer leur support dans Scala à travers quelques exemples.

Les regex avec le package java.util.regex


Étant donné que les API de Java sont accessibles à Scala vous pouvez utiliser le package java.util.regex de Java dans votre programme pour traiter les expressions régulières. Pour commencer prenons un exemple: écrire un programme qui vérifie si une chaîne de caractères donnée contient ou non “toto”. Le test devrait être positif avec “Oh ca va toto?” ou “toto tire nama.” et négatif avec “Tato” ou “Scalable Language”.
Le programme demande à l’utilisateur de taper quelque chose dans la console puis vérifie ce qu’il a tapé contient “toto”. Voici le code avec l’API de Java :

import java.util.regex.{Matcher, Pattern}

val Exit = "exit"
var input = ""
val regex = "toto"
val pattern = Pattern.compile(regex)

while(input != Exit) {
 println("Please enter something... Type exit to quit")
 input = readLine()
 println("You entered = " + input)
 
 if(input != Exit) {
  if(pattern.matcher(input).matches()) println("Found some matches!!")
  else println("Ooops!! " + input + " does not match " + regex);
 }
}


Nous commençons par écrire notre regex (ici “toto”) puis nous le compilons en invoquant la méthode statique compile de la classe java.util.regex.Pattern.  
Nous obtenons ainsi une représentation compilée de notre expression régulière.
val pattern = Pattern.compile(regex)
Ensuite nous testons si la chaîne de caractères fournie par l’utilisateur matche (contient “toto”) notre expression régulière en examinant la variable hasMatches :
boolean hasMatches = pattern.matcher(input).find()

Les regex avec la class scala.util.matching.Regex


Voyons maintenant la même chose avec l’API de Scala :
import scala.util.matching.Regex

val Exit = "exit"
val regex = new Regex("toto")
var input = ""

while(input != Exit) {
 println("Please enter something... Type \"exit\" to quit")
 input = readLine
 println("You entered = " + input)

 if(input != Exit) {
  regex findFirstIn input match {
   case Some(s)    => println("Found some matches!!")
   case None     => println("Oopps!!! No match found.")
  }
 }
}
Dans cette version nous avons utilisée l’API de Scala pour les expressions régulières notamment la classe scala.util.matching.Regex. Ensuite nous invoquons la méthode findFirstIn de l’objet Regex qui renvoie un objet de type Option. Si un match est trouvé nous obtenons Some(s) dans le cas contraire nous avons un None.

Avant de voir un exemple plus élaboré avec les expressions régulières voici une façon succinte de créer un objet de type Regex en Scala:
val regex = "toto".r
Comment cela se passe-t-il? Vous écrivez votre expression régulière comme une chaîne de caractères sur laquelle vous évoquez la méthode r et vous obtenez un objet java.util.matching. En action cela donne : 
scala> val reg = "toto".r
reg: scala.util.matching.Regex = toto
Le script suivant prend en entrée un ensemble de fichiers et essaie d’en extraire des numéros de téléphone :
/*This script parses files given as inputs and tries to extract phone numbers 
from them. The regular expression is based on the French telephone numbering plan */

import scala.io.Source

if(args.length > 0) {
 val phoneNumberRegex = "0[1-9]([ .-]?[0-9]{2}){4}".r
 
 for(file <- args) {
  val input = Source.fromFile(file).mkString
  for(phoneNumber <- phoneNumberRegex findAllIn input) 
   println(phoneNumber) 
 } 
} else {
 Console.err.println("Oops! Please enter a file!")
 println("Script usage : phone_number_search.scala input_file")
}
L'exécution du script avec deux fichiers texte contenant des numéros téléphones donc le résultat suivant :
nouhoum@pc:~/tutorials$ scala phone_number_search.scala file1.txt file2.txt 
01 02 03 04 05
0203040506
03-44-55-76-00
09 03 44 56 88
09 04 44 56 88
09 03 44 56 98
0404050699
01 02 03 04 65
0503040506
Essayez! Ca marche! J’espère vous avoir donné envie d’explorer la manipulation des expressions régulières avec Scala.  A bientôt! 
© Nouhoum TRAORE.. Fourni par Blogger.