Les expressions régulières sont un moyen extrêmement souple de rechercher des motifs dans des strings, grâce à un langage dédié (DSL) conçu pour cet usage.
Comme plusieurs autres langages de programmation, Julia ne cherche pas à implémenter sa propre bibliothèque de regex.
À la place, elle encapsule la populaire bibliothèque PCRE2, ce qui lui donne une syntaxe de regex identique à celle de (par exemple) Gleam, et très proche de celle de JavaScript.
Ce programme Julia suppose que tu connais déjà la syntaxe de base des expressions régulières.
On se concentrera uniquement sur les fonctionnalités propres à Julia.
Tu trouveras ci-dessous quelques ressources pour rafraîchir tes connaissances en expressions régulières.
L'interface de Julia avec les expressions régulières est décrite dans le manuel.
Une expression régulière en Julia est simplement une string précédée de r avant le guillemet ouvrant ".
Toutes les fonctionnalités de base font partie de la bibliothèque standard.
En fait, beaucoup des fonctions déjà présentées dans le concept Strings sont conçues pour la recherche par expression régulière, comme occursin().
julia> re = r"test$"
r"test$"
julia> typeof(re)
Regex
# Does a string end with "test"?
julia> occursin(re, "this is a test")
true
julia> occursin(re, "these are tests")
false
Des caractères de modification peuvent suivre le guillemet fermant, comme i pour une correspondance insensible à la casse.
julia> occursin(r"test", "Testing")
false
julia> occursin(r"test"i, "Testing")
true
Captures
Le plus souvent, on veut savoir ce qui correspond. Pour cela, on inclut des groupes de capture entre parenthèses dans l'expression régulière, puis on utilise la fonction match().
julia> m = match(r"(\d+g) .* (\d+ml)", "dissolve 25g sugar in 200ml water")
RegexMatch("25g sugar in 200ml", 1="25g", 2="200ml")
julia> m.captures
2-element Vector{Union{Nothing, SubString{String}}}:
"25g"
"200ml"
# how many matches?
julia> length(m.captures)
2
# what matched?
julia> m[1], m[2]
("25g", "200ml")
# Starting positions of the matches (character index)
julia> m.offsets
2-element Vector{Int64}:
10
23
Bien sûr, une correspondance peut échouer.
Le résultat sera alors la valeur spéciale Nothing à la place d'un RegexMatch, alors prépare-toi à le tester.
# failed match
m = match(r"(not here)", "dissolve 25g sugar in 200ml water")
julia> typeof(m)
Nothing
julia> isnothing(m)
true
Bien que match commence par défaut au début de la string, on peut aussi préciser un décalage n pour ignorer les n premiers caractères.
# capture first match
julia> m = match(r"(\wat)", "cat, sat, mat")
RegexMatch("cat", 1="cat")
# ignore first 5 characters, then match
julia> m = match(r"(\wat)", "cat, sat, mat", 5)
RegexMatch("sat", 1="sat")
En Julia, match() ne trouve que la première correspondance dans la string cible : il n'existe pas de modificateur global comme dans certains autres langages.
On dispose à la place de eachmatch(), qui renvoie un itérateur de correspondances.
L'évaluation est paresseuse, tu devras donc peut-être le convertir dans le format qui t'intéresse.
julia> matches = eachmatch(r"(\wat)", "cat, sat, mat")
Base.RegexMatchIterator{String}(r"(\wat)", "cat, sat, mat", false)
# convert to vector
julia> collect(matches)
3-element Vector{RegexMatch}:
RegexMatch("cat", 1="cat")
RegexMatch("sat", 1="sat")
RegexMatch("mat", 1="mat")
# convert with comprehension
julia> [m.match for m in matches]
3-element Vector{SubString{String}}:
"cat"
"sat"
"mat"
# broadcast an anonymous function
julia> (m -> m.match).(matches)
3-element Vector{SubString{String}}:
"cat"
"sat"
"mat"
Remplace
Une raison fréquente d'utiliser une expression régulière est de remplacer la correspondance par une autre string.
La fonction replace() a été présentée dans le concept Strings, avec des littéraux de chaîne comme motif de recherche.
Cette même fonction peut exploiter toute la puissance des correspondances d'expressions régulières.
julia> replace("some string", r"[aeiou]" => "*")
"s*m* str*ng"
julia> replace("first second", r"(\w+) (?<agroup>\w+)" => s"\g<agroup> \1")
"second first"
Le deuxième exemple ci-dessus montre comment des groupes de capture numérotés et nommés peuvent être utilisés dans le remplacement, au sein d'une string s" ".
Voir le manuel pour plus de détails : c'est un sujet qui ramène sans cesse la plupart des développeurs à la documentation !
Exercice d'apprentissage
