Julia Language
regex

Sintassi

• Regex ( "[regex]")
• r "[regex]"
• partita (ago, pagliaio)
• matchall (ago, pagliaio)
• eachmatch (ago, pagliaio)
• ismatch (ago, pagliaio)

Parametri

Regalali letterali

Julia supporta le espressioni regolari ¹ . La libreria PCRE viene utilizzata come implementazione regex. I regex sono come una mini-lingua in una lingua. Poiché la maggior parte delle lingue e molti editor di testo forniscono un supporto per regex, la documentazione e gli esempi di come utilizzare le espressioni regolari in generale non rientrano nell'ambito di questo esempio.

È possibile costruire un Regex da una stringa usando il costruttore:

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

Ma per comodità e facilità di escape, è possibile utilizzare la macro stringa @r_str invece:

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

¹ : Tecnicamente, Julia supporta regex, che sono distinte e più potenti di quelle che vengono chiamate espressioni regolari nella teoria del linguaggio. Frequentemente, il termine "espressione regolare" sarà usato per riferirsi anche alle regex.

Trovare partite

Ci sono quattro funzioni utili primarie per le espressioni regolari, che prendono tutti argomenti in needle, haystack ordine di needle, haystack . La terminologia "ago" e "pagliaio" derivano dall'idioma inglese "trovare un ago in un pagliaio". Nel contesto delle espressioni regolari, la regex è l'ago e il testo è il pagliaio.

La funzione di match può essere utilizzata per trovare la prima corrispondenza in una stringa:

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

La funzione di matchall può essere utilizzata per trovare tutte le corrispondenze di un'espressione regolare in una stringa:

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

La funzione ismatch restituisce un valore booleano che indica se è stata trovata una corrispondenza all'interno della stringa:

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

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

La funzione eachmatch restituisce un iteratore su oggetti RegexMatch , adatto per l'uso con i cicli 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

Cattura gruppi

Le sottostringhe catturate dai gruppi di cattura sono accessibili dagli oggetti RegexMatch usando la notazione di indicizzazione.

Ad esempio, la regex seguente analizza i numeri di telefono nordamericani scritti nel formato (555)-555-5555 :

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

e supponiamo di voler estrarre i numeri di telefono da un testo:

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"

Usando la funzione matchall , possiamo ottenere una matrice di sottostringhe corrispondenti:

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

Ma supponiamo di voler accedere ai prefissi (le prime tre cifre, racchiuse tra parentesi). Quindi possiamo usare l'iteratore 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

Nota qui che usiamo m[1] perché il prefisso è il primo gruppo di cattura nella nostra espressione regolare. Possiamo ottenere tutte e tre le componenti del numero di telefono come una tupla usando una funzione:

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

Quindi possiamo applicare tale funzione a un particolare RegexMatch :

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

O potremmo map trasversalmente ogni partita:

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