Share
Ruby è una delle lingue più popolari utilizzate sul web. Abbiamo avviato una nuova sessione qui su Nettuts + che ti introdurrà a Ruby, oltre ai grandi framework e strumenti che accompagnano lo sviluppo di Ruby. In questa lezione vedremo come usare le espressioni regolari in Ruby.
Se hai familiarità con le espressioni regolari, sarai felice di sapere che la maggior parte della sintassi per la scrittura delle espressioni regolari è molto simile a quella che conosci da PHP, JavaScript o [la tua lingua qui].
Se non hai familiarità con le espressioni regolari, ti consigliamo di dare un'occhiata ai nostri tutorial Regex qui su Nettuts + per essere subito aggiornato.
Proprio come tutto il resto in Ruby, le espressioni regolari sono oggetti regolari: sono istanze di regexp classe. Tuttavia, di solito creerai un'espressione regolare con la sintassi standard, letterale:
/ myregex / / \ (\ d 3 \) \ d 3 - \ d 4 /
Per iniziare, il modo più semplice per usare un'espressione regolare è applicarlo a una stringa e vedere se c'è una corrispondenza. Sia le stringhe che gli oggetti regexp hanno a incontro metodo che fa questo:
"(123) 456-7890" .match / \ (\ d 3 \) \ d 3 - \ d 4 / / \ (\ d 3 \) \ d 3 - \ d 4 /. Match "(123) 456-7890"
Entrambi questi esempi corrispondono e quindi otterremo un MatchData istanza indietro (vedremo MatchData oggetti presto). Se non c'è nessuna corrispondenza, incontro tornerà zero. Perché a MatchData oggetto valuterà vero, puoi usare il incontro metodo in istruzioni condizionali (come un'istruzione if), e ignora semplicemente che stai ricevendo un valore di ritorno.
C'è un altro metodo che puoi usare per abbinare regexp con le stringhe: questo è il = ~ (l'operatore di tilde uguale a). Ricorda che gli operatori sono metodi in Ruby. Piace incontro, questo metodo restituisce zero in nessuna partita. Tuttavia, se c'è una corrispondenza, restituirà la posizione numerica della stringa in cui è iniziata la corrispondenza. Anche come la corrispondenza, hanno entrambe le stringhe e le espressioni regolari = ~.
"Ruby For Newbies: Regular Expressions" = ~ / Nuovo / # => 9
Le espressioni regolari diventano più utili quando vengono cancellati alcuni dati. Questo di solito è fatto con i raggruppamenti: avvolgendo alcune parti dell'espressione regolare tra parentesi. Diciamo che vogliamo abbinare un nome, cognome e occupazione in una stringa, in cui la stringa è formattata in questo modo:
str1 = "Joe Schmo, Plumber" str2 = "Stephen Harper, Primo Ministro"
Per ottenere i tre campi, creeremo questa espressione regolare:
re = / (\ w *) \ s (\ w *), \ s? ([\ w \ s] *) /
Corrisponde a qualsiasi numero di caratteri di parole, alcuni spazi bianchi, qualsiasi numero di caratteri di parole, una virgola, alcuni spazi bianchi opzionali e qualsiasi numero di caratteri di parole o spazi vuoti. Come puoi immaginare, le parti che includono i caratteri delle parole si riferiscono ai nomi o all'occupazione che stiamo cercando, quindi sono racchiuse tra parentesi.
Quindi, eseguiamo questo:
match1 = str1.match re match2 = str2.match re
Ora, il nostro match1 e Match2 le variabili tengono MatchData oggetti (perché entrambe le nostre partite hanno avuto successo). Quindi, vediamo come possiamo usarli MatchData oggetti.
Passando attraverso questo, noterai che ci sono diversi modi per ottenere gli stessi dati dai nostri MatchData oggetto. Inizieremo con la stringa con corrispondenza: se vuoi vedere quale stringa originale è stata abbinata alla regexp, usa stringa metodo. Puoi anche usare il [] (parentesi quadre) metodo e passare il parametro 0:
match1.string # => "Joe Schmo, Plumber" match1 [0] # (questo è uguale a match1. [] 0) => "Joe Schmo, Plumber"
E la stessa espressione regolare? Lo puoi trovare con il regexp metodo.
match1.regex # => wsw, s [ws] (questo è il modo univoco di IRB per mostrare le espressioni regolari, funzionerà comunque normalmente)
Ora, che ne dici di ottenere quei gruppi abbinati che sono stati il punto di questo esercizio? In primo luogo, possiamo ottenerli con indici numerati su MatchData oggetto stesso; certo, sono nell'ordine in cui li abbiamo abbinati in:
match1 [1] # => "Joe" match1 [2] # => "Schmo" match1 [3] # => "Plumber" match2 [1] # => "Stephen" match2 [2] # => "Harper" match2 [3] # => "Primo Ministro"
C'è in realtà un altro modo per ottenere queste acquisizioni: è con la proprietà dell'array cattura; poiché questo è un array, è basato su zero.
match1.captures [0] # => "Joe" match2.captures [2] # => "Primo ministro"
Che ci crediate o no, in realtà c'è un terzo modo per ottenere le vostre catture. Quando esegui incontro o = ~, Ruby riempie una serie di variabili globali, una per ciascuno dei gruppi catturati nella tua espressione regolare:
"Andrew Burgess" .match / (\ w *) \ s (\ w *) / # restituisce un oggetto MatchData, ma stiamo ignorando che $ 1 # => "Andrew" $ 2 # => "Burgess"
Torna a MatchData oggetti. Se vuoi scoprire l'indice di stringa di una determinata cattura, passa il numero di cattura a inizio funzione (qui, vuoi il numero della cattura come lo useresti con il [] metodo, non via cattura). In alternativa, puoi usare fine per vedere quando finisce quella cattura.
m = "Netsuts + è il migliore" .match / (is) (the) / m [1] # => "is" m.begin 1 # => 8 m [2] # => "end" m.end 2 # => 14
C'è anche il pre-partita e post_match metodi, che sono abbastanza accurati: questo ti mostra quale parte della stringa veniva prima e dopo la partita, rispettivamente.
# m dall'alto m.pre_match # => "Netsuts +" m.post_match # => "best"
Questo copre praticamente le basi del lavoro con le espressioni regolari in Ruby.
Poiché le espressioni regolari sono così utili durante la manipolazione delle stringhe, troverai numerosi metodi di stringa che ne traggono vantaggio. I più utili sono probabilmente i metodi di sostituzione. Questi includono
Accentsconagua
subsub!gsubgsub!Questi sono per sostituzione e sostituzione globale, rispettivamente. La differenza è questa gsub sostituisce tutte le istanze del nostro modello, mentre sub sostituisce solo la prima istanza nella stringa.
Ecco come li usiamo:
"una stringa" .sub / stringa /, "messaggio" # => "un messaggio" "L'uomo nel parco" .gsub / the /, "a" # => "un uomo in un parco"
Come forse saprai, i metodi bang (quelli che terminano con un punto esclamativo!) Sono metodi distruttivi: cambiano gli oggetti stringa reali, invece di restituire quelli attuali. Per esempio:
original = "Mi chiamo Andrew." nuovo = original.sub / Il mio nome è /, "Ciao, sono" originale # => Il mio nome è Andrew. "new # =>" Ciao, sono Andrew "original =" Chi sei? "originale. sub! / Who are /, "And" original # => "E tu?"
Oltre a questi semplici esempi, puoi fare cose più complesse, come questa:
"1234567890" .sub / (\ d 3) (\ d 3) (\ d 4) /, '(\ 1) \ 2- \ 3' # => "(123) 456-7890 "
Non capiamo MatchData oggetti o le variabili globali con i metodi di sostituzione; tuttavia, possiamo usare il numero? backslash? modello nella stringa di sostituzione, se lo avvolgiamo tra virgolette singole. Se vuoi manipolare ulteriormente la stringa catturata, puoi passare un blocco invece del secondo parametro:
"CHE COSA STA ANDANDO?". Gsub (/ \ S * /) | s | s.downcase # => "cosa sta succedendo?"
Ci sono molte altre funzioni che usano espressioni regolari; se sei interessato, dovresti dare un'occhiata String # scan e String # spaccatura, per i principianti.
Queste sono le espressioni regolari in Ruby per te. Se hai qualche domanda, sentiamoli nei commenti.
