Guida alle espressioni regolari in R

Il concetto di espressioni regolari, di solito chiamate regex, esiste in molti linguaggi di programmazione, come R, Python, C, C++, Perl, Java e JavaScript. Puoi accedere alle funzionalità delle regex sia nella versione base di questi linguaggi sia tramite librerie. Per la maggior parte dei linguaggi, la sintassi dei pattern regex è simile.

In questo tutorial esploreremo cosa sono le espressioni regolari in R, perché sono importanti, quali strumenti e funzioni ci permettono di lavorarci, quali pattern regex sono i più comuni e come usarli. Alla fine, passeremo in rassegna anche alcune applicazioni avanzate delle regex in R.

Cosa sono le regex in R e perché dovresti usarle?

Un'espressione regolare, regex, in R è una sequenza di caratteri (o anche un solo carattere) che descrive un certo pattern presente in un testo. I pattern regex possono essere corti come “a” o lunghi quanto quello menzionato in questo thread su StackOverflow.

In senso ampio, la definizione sopra non riguarda solo R, ma qualsiasi altro linguaggio di programmazione che supporti le espressioni regolari.

Le regex sono uno strumento molto flessibile e potente, ampiamente usato per elaborare ed estrarre informazioni da dati testuali non strutturati. Ad esempio, trovano applicazione nei motori di ricerca, nell'analisi lessicale, nel filtraggio dello spam e nei text editor.

Strumenti e funzioni per lavorare con le regex in R

Sebbene i pattern regex siano simili per la maggior parte dei linguaggi di programmazione, le funzioni per lavorarci sono diverse.

In R, possiamo usare le funzioni di base per rilevare, confrontare, localizzare, estrarre e sostituire tramite regex. Di seguito sono riportate le principali funzioni che cercano corrispondenze regex in un vettore di caratteri e quindi eseguono le seguenti azioni:

• grep(), grepl() – restituiscono gli indici delle stringhe che contengono una corrispondenza (grep()) o un vettore logico che indica quali stringhe contengono una corrispondenza (grepl()).

• regexpr(), gregexpr() – restituiscono per ciascuna stringa l'indice da cui inizia la corrispondenza e la lunghezza della corrispondenza. Mentre regexpr() fornisce queste informazioni solo per la prima corrispondenza (da sinistra), gregexpr() fa lo stesso per tutte le corrispondenze.

• sub(), gsub() – sostituiscono una corrispondenza rilevata in ciascuna stringa con una stringa specificata (sub() – solo per la prima corrispondenza, gsub() – per tutte le corrispondenze).

• regexec() – funziona come regexpr() ma restituisce le stesse informazioni anche per una sottoespressione specificata all'interno della corrispondenza.

• regmatches() – funziona come regexec() ma restituisce le stringhe esatte rilevate per la corrispondenza complessiva e per una sottoespressione specificata.

Tuttavia, invece di usare le funzioni native di R, un modo più comodo e coerente per lavorare con le regex in R è usare il pacchetto specializzato stringr della collezione tidyverse. Questa libreria è costruita sopra il pacchetto stringi. Nella libreria stringr, tutte le funzioni iniziano con str_ e hanno nomi molto più intuitivi (così come i nomi dei loro parametri opzionali) rispetto a quelli della base R.

Per installare e caricare il pacchetto stringr, esegui quanto segue:

install.packages('stringr')
library(stringr)

La tabella seguente mostra la corrispondenza tra le funzioni di stringr e quelle della base R discusse in questa sezione:

Puoi trovare l'elenco completo delle funzioni di stringr e delle espressioni regolari in questi cheat sheet, ma ne discuteremo alcune più avanti in questo tutorial.

Nota: nelle funzioni stringr, passiamo prima i dati e poi una regex, mentre nelle funzioni base di R – esattamente il contrario.

Un'altra nota: Questo tutorial usa stringr 1.5.1, la versione attuale al 2026. Se stai usando una versione più vecchia, alcuni comportamenti potrebbero differire — in particolare per str_view(), che è stato aggiornato in modo significativo nella 1.5.0.

Pattern regex in R

Ora passeremo in rassegna i pattern regex in R più diffusi e il loro utilizzo e, allo stesso tempo, faremo pratica con alcune funzioni di stringr.

Prima di farlo, diamo un'occhiata a un esempio molto semplice. In particolare, verifichiamo se un unicorno ha almeno un corno 😉

str_detect('unicorn', 'corn')

Output:

TRUE

In questo esempio, abbiamo usato la funzione str_detect() di stringr per verificare la presenza della stringa corn nella stringa unicorn.

Di solito, però, non cerchiamo una stringa letterale specifica in un testo, ma piuttosto un certo pattern – un'espressione regolare. Entriamo nel dettaglio ed esploriamo questi pattern.

Escape dei caratteri

Ci sono alcuni caratteri che hanno un significato speciale quando usati nelle espressioni regolari in R. Più precisamente, non fanno match con se stessi, come fanno invece lettere e cifre, ma compiono qualcosa di diverso:

str_extract_all('unicorn', '.')

Output:

1. 'u' 'n' 'i' 'c' 'o' 'r' 'n'

È chiaro che non ci sono punti nel nostro unicorno. Tuttavia, la funzione str_extract_all() ha estratto ogni singolo carattere da questa stringa. Questa è esattamente la “missione” del carattere . – fare match con qualsiasi singolo carattere tranne un a capo.

E se volessimo estrarre un punto letterale? A questo scopo, dobbiamo usare un carattere di escape regex prima del punto – una barra rovesciata (\). C'è però una trappola da ricordare: la barra rovesciata è usata anche nelle stringhe stesse come carattere di escape. Significa che dobbiamo prima “escapare il carattere di escape” usando due barre rovesciate. Vediamo come funziona:

str_extract_all('Eat. Pray. Love.', '\\.')

Output:

1. '.' '.' '.'

Quindi, la barra rovesciata aiuta a annullare il significato speciale di alcuni simboli nelle espressioni regolari in R e a interpretarli letteralmente. Ha anche la missione opposta: attribuire un significato speciale ad alcuni caratteri che altrimenti verrebbero interpretati letteralmente. Di seguito una tabella con le sequenze di escape più usate:

Vediamo alcuni esempi ricordando che anche in questi casi dobbiamo usare una doppia barra rovesciata. Nel frattempo, introduciamo un'altra funzione di stringr: str_view() per visualizzare il rendering HTML della prima corrispondenza o di tutte le corrispondenze:

str_view('Unicorns are so cute!', 's\\b')
str_view('Unicorns are so cute!', 's\\B')

Output:

Unicorns are so cute!
Unicorns are so cute!

Nella stringa Unicorns are so cute! ci sono due occorrenze della lettera s. Sopra, il primo pattern regex in R ha evidenziato la prima istanza della lettera s (poiché è seguita da uno spazio), mentre il secondo – la seconda istanza (poiché è seguita da un'altra lettera, non da un confine di parola).

Ancora un paio di esempi:

cat('Unicorns are\nso cute!')
str_view('Unicorns are\nso cute!', '\\n')

Output:

Unicorns are
so cute!

Unicorns are_so cute!

cat('Unicorns are\tso cute!')
str_view('Unicorns are\tso cute!', '\\t')

Output:

Unicorns are so    cute!

Unicorns are_so cute!

Classi di caratteri

Una classe di caratteri fa match con qualsiasi carattere di un insieme predefinito di caratteri. Le classi di caratteri integrate hanno la stessa sintassi delle sequenze di escape viste nella sezione precedente: una barra rovesciata seguita da una lettera a cui attribuisce un significato speciale piuttosto che letterale. Le costruzioni più comuni sono elencate di seguito:

Vediamo alcuni esempi autoesplicativi:

str_view('Unicorns are so cute!', '\\w')
str_view('Unicorns are so cute!', '\\W')

Output:

[1] │ <U><n><i><c><o><r><n><s>< ><a><r><e>< ><s><o>< ><c><u><t><e>!
[1] │ Unicorns< >are< >so< >cute<!>

str_view('Unicorns are\nso cute!', '\\s')
str_view('Unicorns are\nso cute!', '\\S')

Output:

Unicorns are<\n>so cute!

str_detect('Unicorns are so cute!', '\\d')

Output:

FALSE

Le classi di caratteri integrate possono anche comparire in una forma alternativa – [:character_class_name:]. Alcune di queste classi hanno un equivalente tra quelle con la barra rovesciata; altre no. Le più comuni sono:

Esploriamo alcuni esempi ricordando che dobbiamo inserire uno qualsiasi dei pattern regex sopra tra parentesi quadre:

str_view('Unicorns are so cute!', '[[:upper:]]')
str_view('Unicorns are so cute!', '[[:lower:]]')

Output:

Unicorns are so cute!

Unicorns are so cute!

str_detect('Unicorns are so cute!', '[[:digit:]]')

Output:

FALSE

str_extract_all('Unicorns are so cute!', '[[:punct:]]')

Output:

1. '!'

str_view('Unicorns are so cute!', '[[:space:]]')

Output:

Unicorns_are_so_cute!

È anche possibile creare una classe di caratteri definita dall'utente inserendo tra parentesi quadre qualsiasi insieme di caratteri tra i quali vogliamo far corrispondere un singolo carattere. Possiamo racchiudere tra parentesi quadre un intervallo di lettere o numeri (in ordine Unicode), diversi intervalli, o qualsiasi insieme sequenziale o non sequenziale di caratteri o gruppi di caratteri.

Ad esempio, [A-D] farà match con qualsiasi lettera maiuscola da A a D inclusi, [k-r] – qualsiasi lettera minuscola da k a r inclusi, [0-7] – qualsiasi cifra da 0 a 7 inclusi, e [aou14%9] – qualsiasi dei caratteri indicati tra parentesi quadre. Se mettiamo il circonflesso (⁠^) come primo carattere dentro le parentesi quadre, il nostro pattern regex in R farà match con tutto tranne i caratteri forniti. Nota che i meccanismi di corrispondenza sopra sono case-sensitive.

str_view('Unicorns Are SOOO Cute!', '[O-V]')
str_view('Unicorns Are SOOO Cute!', '[^O-V]')

Output:

Unicorns Are SOOO Cute!

Unicorns Are SOOO Cute!

str_view('3.14159265359', '[0-2]')

Output:

3.14159265359

str_view('The number pi is equal to 3.14159265359', '[n2e9&]')

Output:

The number pi is equal to 3.14159265359

Quantificatori

Spesso abbiamo bisogno di far corrispondere ripetutamente un certo pattern regex in R, invece che una sola volta. A questo scopo usiamo i quantificatori. Un quantificatore va sempre dopo il pattern regex a cui si riferisce. I quantificatori più comuni sono riportati nella tabella seguente:

Proviamoli tutti:

str_extract('dog', 'dog\\d*')

Output:

'dog'

Abbiamo ottenuto la stringa iniziale dog: non ci sono cifre alla fine di quella stringa, ma va bene così (0 o più istanze di cifre).

str_extract('12345', '\\d+')

Output:

'12345'

str_extract('12345', '\\d?')

Output:

'1'

str_extract('12345', '\\d{3}')

Output:

'123'

str_extract('12345', '\\d{7,}')

Output:

NA

Abbiamo ottenuto NA perché non abbiamo almeno 7 cifre nella stringa, ma solo 5.

str_extract('12345', '\\d{2,4}')

Output:

'1234'

Ancore

Per impostazione predefinita, le regex in R effettuano il match su qualsiasi parte di una stringa fornita. Possiamo cambiare questo comportamento specificando una certa posizione del pattern regex all'interno della stringa. Più spesso, potremmo voler imporre la corrispondenza dall'inizio o dalla fine della stringa. A questo scopo, usiamo le due ancore principali nelle espressioni regolari in R:

• ^ – corrisponde dall'inizio della stringa (per stringhe multilinea – l'inizio di ogni riga)

• $ – corrisponde dalla fine della stringa (per stringhe multilinea – la fine di ogni riga)

Vediamo come funzionano sull'esempio del palindromo stella won no wallets:

str_view('stella won no wallets', '^s')
str_view('stella won no wallets', 's$')

Output:

<s>tella won no wallets
stella won no wallet<s>

Se vogliamo fare match con i caratteri ^ o $ stessi, dobbiamo farli precedere da una barra rovesciata (raddoppiandola):

str_view('Do not have 100$, have 100 friends', '\\$')

Output:

Do not have 100$, have 100 friends

È anche possibile ancorare le corrispondenze ai confini di parola o di non-parola all'interno della stringa (rispettivamente \b e \B):

str_view('road cocoa oasis oak boa coach', '\\boa')
str_view('road cocoa oasis oak boa coach', 'oa\\b')
str_view('road cocoa oasis oak boa coach', 'oa\\B')

Output:

road cocoa oasis oak boa coach

road cocoa oasis oak boa coach

road cocoa oasis oak boa coach

Qui sopra abbiamo fatto match con la combinazione di lettere oa:

• 1º esempio – all'inizio delle parole
• 2º esempio – alla fine delle parole
• 3º esempio – ogni volta che è seguita da un carattere di parola (nel nostro caso – da una lettera)

Alternanza

Applicando l'operatore di alternanza (|), possiamo far corrispondere più di un pattern regex in R nella stessa stringa. Nota che se usiamo questo operatore come parte di una classe di caratteri definita dall'utente, viene interpretato letteralmente e quindi non esegue alcuna alternanza.

str_view('coach koala board oak cocoa road boa load coat oasis boat', 'boa|coa')

Output:

coach koala board oak cocoa road boa load coat oasis boat

Nell'esempio sopra, abbiamo fatto match con tutte le occorrenze di boa o coa.

Raggruppamento

I pattern regex in R seguono determinate regole di precedenza. Ad esempio, la ripetizione (tramite quantificatori) ha priorità rispetto all'ancoraggio, mentre l'ancoraggio ha precedenza sull'alternanza. Per ignorare queste regole e aumentare la precedenza di una certa operazione, dovremmo usare il raggruppamento. Questo si ottiene racchiudendo una sottoespressione di interesse tra parentesi tonde.

Il raggruppamento funziona al meglio in combinazione con l'operatore di alternanza. Gli esempi seguenti mostrano chiaramente l'effetto di tale combinazione:

str_view('code rat coat cot cat', 'co|at')
str_view('code rat coat cot cat', 'c(o|a)t')

Output:

code rat coat cot cat

code rat coat cot cat

Applicazioni avanzate delle espressioni regolari in R

Tutto ciò che abbiamo discusso finora ci dà una buona base per iniziare a lavorare con le espressioni regolari in R. Tuttavia, ci sono molte altre cose che possiamo fare con questo potente strumento. Senza entrare nei dettagli, menzioniamo solo alcune operazioni avanzate che possiamo eseguire con le regex in R:

• Modificare i valori predefiniti delle funzioni di stringr
• Fare match con cluster di grafemi
• Backreferencing dei gruppi
• Fare match con proprietà Unicode
• Applicare escape avanzati dei caratteri
• Verificare l'esistenza di un pattern senza includerlo nell'output (i cosiddetti lookaround)
• Rendere il meccanismo di ripetizione del pattern “pigro” anziché “goloso”
• Lavorare con gruppi atomici

Scopri di più nel nostro corso Intermediate Regular Expressions in R.

sfida sulle regex in R

Ora tocca a te mettere in pratica i pattern regex in R che abbiamo visto in questo tutorial. Per farlo, usa il nostro Dataset: Internet News and Consumer Engagement e prova a fare quanto segue: estrai i domini di primo livello (TLD) da tutti gli URL. Alcuni esempi di TLD sono com, net, uk, ecc.

Ci sono più modi per completare questo compito, inclusi soluzioni eleganti e compatte in una riga (suggerimento: puoi approfondire i lookaround nelle regex in R menzionati nella sezione precedente e usarli per risolvere questo problema). Considera le seguenti linee guida molto generiche per un approccio relativamente “da principiante”:

• Ispeziona alcuni URL nel dataset e nota quali pattern sono sempre presenti in qualsiasi URL prima del TLD e quali sono opzionali
• Nota se ci sono pattern obbligatori in qualsiasi URL dopo il TLD (e in tal caso quali) e quali pattern sono opzionali
• Rimuovi tutto ciò che sta prima del TLD dell'URL
• Rimuovi tutto ciò che sta dopo il TLD dell'URL

Per risolvere il problema usando l'algoritmo sopra, non ti serve fare o imparare altro. Ripassa semplicemente tutto ciò che abbiamo discusso in questo tutorial e metti in pratica le tue conoscenze. In particolare, ti serviranno le funzioni di stringr, gli escape dei caratteri, le classi di caratteri, i quantificatori e il raggruppamento.

Bonus: sfida n. 2

Se vuoi fare altra pratica, questa volta senza suggerimenti, prova a fare quanto segue: usando lo stesso dataset della sfida precedente, estrai i nomi di dominio da tutti gli URL. Un esempio di nome di dominio è google nell'URL www.google.com.

Conclusione

Per concludere, in questo tutorial abbiamo imparato molte cose sulle espressioni regolari in R. In particolare, abbiamo discusso:

• Cosa sono le regex in R
• Perché sono importanti e dove si applicano
• Quali funzioni (sia di R base che di una libreria specializzata) si usano per lavorare con le espressioni regolari in R
• I pattern regex in R più comuni e il loro ambito, le sfumature e le insidie
• Quando e come usare escape dei caratteri, classi di caratteri, quantificatori, ancore, alternanza e raggruppamento con le regex in R
• Vari esempi di applicazione delle regex in R e delle funzioni
• Alcune operazioni avanzate con le espressioni regolari in R

Queste competenze e nozioni ti aiuteranno a lavorare in R e in molti altri linguaggi di programmazione, poiché il concetto di espressioni regolari è lo stesso per tutti questi linguaggi e anche la sintassi delle regex è piuttosto simile per la maggior parte di essi.

Se ti interessa padroneggiare le tue skill in R, prendi in considerazione i seguenti corsi, percorsi di competenze e articoli di DataCamp:

• Introduction to R
• Intermediate R
• R Programming
• Importing & Cleaning Data with R
• The Top 10 R Project Ideas for 2026
• What is R? – The Statistical Computing Powerhouse
• How to Get Started with R