Metodi RegExp di JavaScript

Le espressioni regolari in JavaScript sono un potente strumento per cercare, confrontare e manipolare string. Questa guida illustra i principali metodi che si invocano su un'espressione regolare (test, exec) e su una string (search, split, match, matchAll, replace, replaceAll), con un esempio eseguibile e il reale valore restituito per ciascuno. Comprendere questi metodi permette di gestire in modo efficiente il pattern matching nel proprio codice.

Un rapido ripasso delle regex

Prima dei metodi, un'introduzione di un minuto per i lettori nuovi alle espressioni regolari.

Un letterale regex si scrive tra barre, seguito opzionalmente da flag:

/pattern/flags   // e.g. /hello/gi

Si può anche costruirne uno dinamicamente con il costruttore RegExp, utile quando il pattern proviene da una variabile (nota che le barre inverse devono essere raddoppiate all'interno di una string):

const word = "hello";
const regex = new RegExp(word, "gi"); // same as /hello/gi
const digits = new RegExp("\\d+");    // same as /\d+/

I flag modificano il comportamento del confronto:

Per la sintassi completa dei pattern e i dettagli sui flag, vedere Pattern e Flag JavaScript e Gruppi di cattura. Molti dei metodi seguenti sono documentati anche dal lato string in String JavaScript.

RegExp.test()

Il metodo test() verifica se una string corrisponde a un'espressione regolare. Restituisce true se viene trovata una corrispondenza, oppure false in caso contrario.

Esempio

In questo esempio, il metodo test() verifica se la string "Hello world!" contiene il pattern "hello". Poiché il metodo è sensibile alle maiuscole/minuscole, restituisce false. Aggiungendo il flag i (/hello/i) restituirebbe true.

RegExp.exec()

Il metodo exec() cerca in una string una corrispondenza con un'espressione regolare. Restituisce un array contenente il testo corrispondente e i gruppi di cattura, oppure null se non viene trovata alcuna corrispondenza. Il valore restituito non è un array semplice: contiene anche index (dove è iniziata la corrispondenza), input (la string originale) e groups (i gruppi di cattura con nome, oppure undefined se non ce ne sono).

Esempio

Qui exec() trova una o più cifre in "The year is 2024." L'elemento 0 è la corrispondenza completa, l'elemento 1 è il primo gruppo di cattura (\d+), e le proprietà aggiuntive indicano dove è stata trovata la corrispondenza.

L'insidia di lastIndex con /g

Quando la regex ha il flag global (g) o sticky (y), exec() diventa stateful: ogni chiamata riprende dalla proprietà lastIndex della regex e la aggiorna, restituendo null quando non ci sono più corrispondenze. Usarla in un ciclo permette di scorrere ogni corrispondenza — ma è importante sapere che riutilizzare la stessa regex /g in chiamate non correlate può dare risultati inaspettati perché lastIndex viene ricordato.

Senza il flag g, exec() non è stateful e restituisce sempre la prima corrispondenza, quindi un ciclo while come questo andrebbe all'infinito. Per un uso non globale, è preferibile match() o matchAll().

String.search()

Il metodo search() verifica se una string corrisponde a un'espressione regolare. Restituisce l'indice in base zero della prima corrispondenza, oppure -1 se non ne viene trovata alcuna.

Esempio

In questo esempio, il metodo search() restituisce l'indice della prima occorrenza di "awesome" nella string, che è 14.

String.split()

Il metodo split() divide una string in un elenco ordinato di sottostringhe e le restituisce in un array. È un metodo generico per le string: il separatore può essere una string semplice (str.split(",")) oppure un'espressione regolare. La forma con regex è solo uno dei casi d'uso, comoda quando il delimitatore varia — ad esempio, dividere su uno o più spazi bianchi.

Esempio

La prima chiamata divide su una virgola letterale; la seconda usa la regex /\s+/ per dividere su qualsiasi sequenza di spazi bianchi, così spazi multipli e tabulazioni vengono compressi in separatori puliti.

String.match()

Il metodo match() recupera il risultato del confronto di una string con un'espressione regolare. Il valore restituito dipende dai flag:

• Con /g: un array di tutte le sottostringhe corrispondenti (senza index o groups), oppure null se non ci sono corrispondenze.
• Senza /g: lo stesso array ricco restituito da exec() — la prima corrispondenza più i gruppi di cattura, con index, input e groups — oppure null se non c'è corrispondenza.

Poiché match() restituisce null invece di un array vuoto quando non trova nulla, è necessario verificare sempre il risultato prima di usarlo.

Esempio

Con il flag global, match() restituisce ogni occorrenza di "ain"; un pattern che non corrisponde restituisce null, non un array vuoto.

String.matchAll()

Il metodo matchAll() restituisce un iteratore di tutte le corrispondenze, inclusi i gruppi di cattura. Ogni elemento prodotto è un array di corrispondenza completo (un RegExpMatchArray), con la stessa struttura prodotta da exec() — quindi ogni corrispondenza porta index, input e groups, non solo le string corrispondenti. L'espressione regolare deve avere il flag g, altrimenti matchAll() lancia un TypeError. A differenza di exec() in un ciclo, matchAll() non lascia un lastIndex residuo sulla regex, il che lo rende la scelta più pulita per iterare su tutte le corrispondenze. (Richiede ES2020+.)

Esempio

Poiché gli elementi sono veri array di corrispondenza, è possibile leggere match.index e i gruppi catturati (match[1], match[2], …) per ogni risultato. Convertire l'iteratore in un array con Array.from(str.matchAll(regex)) o l'operatore spread quando si ha bisogno di accedere ai risultati tramite indice.

String.replace()

Il metodo replace() restituisce una nuova string con le corrispondenze del pattern sostituite (la string originale non viene mai modificata). Con una string semplice o una regex senza /g sostituisce solo la prima corrispondenza; aggiungendo il flag g le sostituisce tutte.

La string di sostituzione supporta token speciali: $& è l'intera corrispondenza, $` e $' sono il testo prima/dopo di essa, $n inserisce il gruppo di cattura n-esimo e $<name> inserisce un gruppo con nome.

Esempio

È anche possibile passare una funzione come sostituzione; riceve la corrispondenza e i gruppi catturati come argomenti e restituisce il testo di sostituzione, il che è utile per valori calcolati:

String.replaceAll()

Il metodo replaceAll() sostituisce ogni occorrenza e restituisce una nuova string. Quando si passa un'espressione regolare, essa deve avere il flag g altrimenti viene lanciato un TypeError — questo protegge dall'errore comune di aspettarsi che replace() sia globale. Supporta gli stessi token di sostituzione $1 / $<name> e i replacer funzione di replace(). (Richiede ES2021+.)

Esempio

Usare replaceAll() con una string semplice quando si vuole semplicemente sostituire tutte le copie di una sottostring letterale; ricorrere alla forma con regex quando il target è un pattern.

Conclusione

Questa guida ha illustrato i principali metodi usati con le espressioni regolari in JavaScript — test e exec lato regex, e search, split, match, matchAll, replace e replaceAll lato string — insieme ai loro reali valori restituiti e al comportamento stateful di lastIndex con il flag /g. Per approfondire i pattern stessi, continuare con Pattern e Flag, Gruppi di cattura e il flag sticky y.

Esercitazione