Julia Language
Regexes

Syntaxe

• Regex ("[regex]")
• r "[regex]"
• match (aiguille, botte de foin)
• matchall (aiguille, botte de foin)
• chaque pièce (aiguille, meule de foin)
• ismatch (aiguille, botte de foin)

Paramètres

Littéraux Regex

Julia prend en charge les expressions régulières ¹ . La bibliothèque PCRE est utilisée comme implémentation regex. Les expressions rationnelles sont comme une mini-langue dans une langue. Étant donné que la plupart des langages et de nombreux éditeurs de texte prennent en charge les expressions rationnelles, la documentation et des exemples d'utilisation des expressions rationnelles en général ne sont pas abordés dans cet exemple.

Il est possible de construire une Regex partir d'une chaîne en utilisant le constructeur:

julia> Regex("(cat|dog)s?")

Mais pour plus de commodité et d’échapper plus facilement, la macro de chaîne @r_str peut être utilisée à la place:

julia> r"(cat|dog)s?"

¹ : Techniquement, Julia supporte les expressions rationnelles, qui sont distinctes et plus puissantes que ce que l'on appelle les expressions régulières dans la théorie des langues. Souvent, le terme "expression régulière" sera également utilisé pour désigner les expressions rationnelles.

Trouver des allumettes

Il existe quatre fonctions utiles principales pour les expressions régulières, qui prennent toutes des arguments dans needle, haystack ordre de needle, haystack . La terminologie "aiguille" et "botte de foin" vient de l'expression anglaise "trouver une aiguille dans une botte de foin". Dans le contexte des expressions rationnelles, le regex est l'aiguille et le texte est la botte de foin.

La fonction de match peut être utilisée pour trouver la première correspondance dans une chaîne:

julia> match(r"(cat|dog)s?", "my cats are dogs")
RegexMatch("cats", 1="cat")

La fonction matchall peut être utilisée pour rechercher toutes les correspondances d'une expression régulière dans une chaîne:

julia> matchall(r"(cat|dog)s?", "The cat jumped over the dogs.")
2-element Array{SubString{String},1}:
 "cat" 
 "dogs"

La fonction ismatch renvoie un booléen indiquant si une correspondance a été trouvée dans la chaîne:

julia> ismatch(r"(cat|dog)s?", "My pigs")
false

julia> ismatch(r"(cat|dog)s?", "My cats")
true

La fonction eachmatch renvoie un itérateur sur les objets RegexMatch , utilisable avec les boucles for :

julia> for m in eachmatch(r"(cat|dog)s?", "My cats and my dog")
           println("Matched $(m.match) at index $(m.offset)")
       end
Matched cats at index 4
Matched dog at index 16

Groupes de capture

Les sous-chaînes capturées par les groupes de capture sont accessibles à partir des objets RegexMatch aide de la notation d'indexation.

Par exemple, la regex suivante analyse les numéros de téléphone nord-américains écrits au format (555)-555-5555 :

julia> phone = r"\((\d{3})\)-(\d{3})-(\d{4})"

et supposons que nous souhaitons extraire les numéros de téléphone d'un texte:

julia> text = """
       My phone number is (555)-505-1000.
       Her phone number is (555)-999-9999.
       """
"My phone number is (555)-505-1000.\nHer phone number is (555)-999-9999.\n"

En utilisant la fonction matchall , nous pouvons obtenir un tableau des sous-chaînes correspondantes:

julia> matchall(phone, text)
2-element Array{SubString{String},1}:
 "(555)-505-1000"
 "(555)-999-9999"

Mais supposons que nous voulions accéder aux indicatifs régionaux (les trois premiers chiffres, entre crochets). Ensuite, nous pouvons utiliser l'itérateur eachmatch :

julia> for m in eachmatch(phone, text)
           println("Matched $(m.match) with area code $(m[1])")
       end
Matched (555)-505-1000 with area code 555
Matched (555)-999-9999 with area code 555

Notez ici que nous utilisons m[1] car le code de zone est le premier groupe de capture de notre expression régulière. Nous pouvons obtenir les trois composants du numéro de téléphone comme un tuple en utilisant une fonction:

julia> splitmatch(m) = m[1], m[2], m[3]
splitmatch (generic function with 1 method)

Ensuite, nous pouvons appliquer une telle fonction à un RegexMatch particulier:

julia> splitmatch(match(phone, text))
("555","505","1000")

Ou nous pourrions map chaque match:

julia> map(splitmatch, eachmatch(phone, text))
2-element Array{Tuple{SubString{String},SubString{String},SubString{String}},1}:
 ("555","505","1000")
 ("555","999","9999")