Regex: flag sticky "y", ricerca in una posizione specifica

Il flag y — il flag sticky — è uno dei flag che puoi aggiungere a un'espressione regolare JavaScript. Ancora ogni ricerca a una posizione esatta: il lastIndex dell'espressione regolare. Se una corrispondenza non può iniziare esattamente a lastIndex, la ricerca fallisce — il motore non scansiona in avanti alla ricerca di una corrispondenza altrove.

Questa pagina illustra cosa fa il flag sticky, come si distingue dal flag global (g), come viene letto e aggiornato lastIndex, le insidie più comuni e dove il flag è davvero utile (tokenizer e parser sequenziali).

Il concetto di flag sticky (y)

Il flag sticky (y) garantisce che la corrispondenza inizi esattamente all'indice memorizzato nella proprietà lastIndex dell'oggetto espressione regolare. Questo è il contrasto chiave con il flag global (g): g permette al motore di scansionare in avanti da lastIndex per trovare la prossima corrispondenza in qualsiasi punto della string, mentre y richiede che la corrispondenza inizi a lastIndex altrimenti fallisce. Quel comportamento "nessuna scansione in avanti" è esattamente ciò di cui un tokenizer ha bisogno — garantisce che l'input venga consumato in modo contiguo, senza lacune inattese tra i token.

y non scansiona in avanti — g sì

Il modo più chiaro per vedere la differenza è dare a entrambi i flag un pattern che non corrisponde alla posizione 0:

Il flag g trova abc anche se inizia all'indice 3. Il flag y restituisce null, perché alla posizione 0 si trova un ., non l'inizio di abc.

Nell'esempio sopra, il flag y garantisce che la seconda chiamata a test inizi la corrispondenza alla posizione immediatamente successiva alla corrispondenza precedente. Vale la pena notare due dettagli:

• Una corrispondenza riuscita avanza lastIndex all'indice subito dopo la corrispondenza (0 → 3 → 6). Questo avanzamento automatico è ciò che permette di chiamare test/exec in un ciclo.
• Una corrispondenza fallita reimposta lastIndex a 0. Dopo che la terza chiamata restituisce false, lastIndex torna a 0, pronto a ricominciare.

lastIndex viene letto e scritto

lastIndex non è solo un valore di input che si imposta — il motore lo aggiorna ad ogni chiamata test/exec che usa y (o g). Il pattern normale è quindi: impostare lastIndex una volta se si vuole iniziare da una posizione diversa da 0, poi lasciare che il ciclo lo gestisca.

Sticky influenza anche le ancore

Con il flag y, l'ancora di inizio stringa ^ non viene ri-ancorata a lastIndex — ^ significa ancora "inizio dell'intera string" (o inizio di una riga con il flag m). Il comportamento sticky deriva dalla regola implicita "corrispondenza a lastIndex", non dalla riscrittura di ^. Quindi un pattern come /^x/y fallirà a qualsiasi lastIndex maggiore di 0, perché ^ non può mai essere soddisfatta in quel punto.

Applicazioni pratiche del flag sticky

Analisi di flussi di dati

Il flag sticky è particolarmente vantaggioso quando si analizzano flussi di dati in cui è necessario abbinare i token in modo sequenziale.

Tokenizzazione di stringhe

Un altro caso d'uso comune è la tokenizzazione di stringhe, in cui è necessario garantire che il tokenizer proceda da una corrispondenza alla successiva senza saltare alcun carattere.

Ricerca in una posizione specifica

La proprietà lastIndex di JavaScript combinata con il flag sticky può essere utilizzata per cercare pattern a partire da una posizione specifica in una string.

In questo esempio, impostare lastIndex a 6 consente al metodo test di trovare la parola "world" a partire dalla posizione specificata.

Combinare il flag sticky con altri flag

Il flag sticky può essere combinato con altri flag come g (global) per potenziare le capacità di corrispondenza dei pattern. In questo esempio, il flag g consente una ricerca globale nell'intera string, mentre il flag y garantisce che ogni corrispondenza inizi esattamente alla posizione lastIndex. Questa combinazione permette di eseguire una ricerca globale con il comportamento di corrispondenza sequenziale rigorosa del flag sticky.

In questo esempio, abbiamo aggiornato la regex per consumare il delimitatore virgola. Ciò garantisce che la prossima corrispondenza inizi nella posizione corretta senza manipolazione manuale dell'indice.

Esempi avanzati

Estrazione di coppie chiave-valore

Considera uno scenario più complesso in cui è necessario estrarre coppie chiave-valore da una string con vari separatori. Ogni parte della coppia viene estratta con un gruppo di cattura — match[1] è la chiave e match[3] è il valore.

Analisi dei log

Il flag sticky può essere estremamente utile nell'analisi di log strutturati in cui le voci devono essere abbinate a partire da posizioni specifiche.

Si noti che il gruppo del messaggio è [^;]+ ("tutto fino al prossimo ;") anziché \w+. Con \w+, un messaggio contenente uno spazio interromperebbe la corrispondenza a metà voce; poiché il flag sticky si rifiuta di andare avanti, la prossima chiamata exec fallirebbe e il ciclo terminerebbe prematuramente — eliminando silenziosamente le voci rimanenti. Questa è l'insidia più comune del flag sticky: il pattern deve consumare l'input in modo contiguo, altrimenti il parsing si interrompe bruscamente.

Quando usare y (e quando no)

Ricorri al flag sticky quando:

• Stai scrivendo un tokenizer o parser e hai bisogno di consumare l'input in modo contiguo, un token alla volta, senza lacune consentite.
• Vuoi verificare se un pattern corrisponde a una posizione esatta, senza che il motore si sposti in cerca di una corrispondenza più avanti nella string.

Preferisci il semplice flag global (g) quando vuoi semplicemente tutte le corrispondenze in qualsiasi punto della string e non ti importa che siano adiacenti — ad esempio, trovare ogni indirizzo email in un documento.

Ricorda le due regole che causano la maggior parte dei bug legati al flag sticky: una corrispondenza fallita reimposta lastIndex a 0, e il pattern deve consumare ogni carattere tra le corrispondenze altrimenti il ciclo termina prematuramente.

Conclusione

Il flag sticky (y) scambia la comodità "cerca ovunque" di g per una corrispondenza rigorosa, ancorata alla posizione lastIndex. Questo compromesso è esattamente ciò che si vuole quando si costruiscono tokenizer e parser sequenziali, dove il consumo contiguo è fondamentale. Combinalo con i gruppi di cattura per estrarre dati strutturati e tieni d'occhio lastIndex — una volta compreso come avanza e si reimposta, la corrispondenza sticky diventa uno strumento preciso e prevedibile.

Argomenti correlati

• Pattern e flag
• Ancore: inizio ^ e fine $ della string
• Gruppi di cattura
• Espressioni regolari in JavaScript

Esercitazione