Delimitatore di parola in JavaScript Regex (\b)

Introduzione ai delimitatori di parola

In JavaScript le espressioni regolari usano l'ancora \b per individuare i confini di parola. Un confine di parola è una posizione che si trova tra un carattere di parola (definito dalla classe di caratteri \w, che comprende [a-zA-Z0-9_]) e un carattere non di parola (qualsiasi carattere che non sia di parola). Questo consente di ottenere corrispondenze precise di parole intere ed è particolarmente utile per ricerche, sostituzioni o validazione di specifici pattern di parole nel testo.

\b è una delle ancore delle espressioni regolari. A differenza delle ancore di inizio e fine stringa ^ e $, che vincolano la corrispondenza ai bordi dell'input, \b la vincola ai bordi di una parola, così un singolo pattern può corrispondere a parole intere in qualsiasi punto di una stringa.

Questo capitolo illustra cosa costituisce un confine di parola, come funziona l'ancora complementare \B, la natura a larghezza zero di entrambe, i pattern comuni per la corrispondenza di parole intere e i limiti che si incontrano con il testo Unicode.

Uso dell'ancora \b

L'ancora \b è un'asserzione a larghezza zero: corrisponde a una posizione, non a un carattere. La posizione deve trovarsi tra un carattere di parola (uno che \w riconosce: [a-zA-Z0-9_]) e un carattere non di parola — oppure tra un carattere di parola e l'inizio o la fine della stringa. Poiché è a larghezza zero, \b non consuma nulla; vincola soltanto dove il resto del pattern può trovare corrispondenza.

Esistono tre casi in cui si verifica un confine di parola:

• Prima del primo carattere, se quel carattere è un carattere di parola.
• Dopo l'ultimo carattere, se quel carattere è un carattere di parola.
• Tra due caratteri adiacenti in cui esattamente uno di essi è un carattere di parola.

L'ancora complementare \B corrisponde a ogni posizione che non è un confine di parola.

Per vedere dove cadono effettivamente i confini, inserire un marcatore in ogni posizione \b:

Spiegazione: I quattro confini sono: prima di a, dopo c (adiacente allo spazio), prima di d e dopo f (fine stringa). Il gap tra gli spazi non ha alcun confine perché nessuno dei due lati è un carattere di parola.

Esempio: corrispondenza di parole intere

Spiegazione:

• La regex /\bcat\b/ corrisponde alla parola "cat" come parola intera.
• Nella stringa 'The cat is here.', "cat" è una parola separata, quindi la corrispondenza è true.
• Nella stringa 'The caterpillar is here.', "cat" fa parte della parola "caterpillar", quindi la corrispondenza è false.

Esempio: ricerca di parole intere nel testo

Spiegazione:

• La regex /\bcat\b/g trova tutte le occorrenze di "cat" come parola intera nel testo.
• Corrisponde solo a "cat", e non a "scatter", "caterpillar" o "catfish", perché "cat" non è una parola separata in quei contesti.
• Il risultato è un array contenente ["cat"].

Confini di non-parola (\B)

\B è l'esatto opposto di \b: corrisponde a qualsiasi posizione che non è un confine di parola. Ciò significa che ha successo all'interno di una parola (tra due caratteri di parola) o tra due caratteri non di parola, e fallisce ovunque \b avrebbe avuto successo.

Usare \B quando si vuole che un pattern corrisponda solo quando è incorporato all'interno di una parola più grande.

Spiegazione:

• /\Boo\B/g richiede un confine di non-parola su entrambi i lati di oo.
• In 'noon', il oo ha n su entrambi i lati, quindi entrambe le asserzioni \B sono soddisfatte — trova corrispondenza.
• In 'zoo', il oo si trova alla fine della parola, quindi c'è un vero confine di parola e \B fallisce. Viene restituito solo il oo di 'noon'.

Un modo pratico per ricordare la relazione: in ogni posizione, esattamente uno tra \b e \B trova corrispondenza.

Applicazioni pratiche

Validazione di campi di input

I delimitatori di parola possono essere utili per validare campi di input in cui sono richieste corrispondenze esatte di parole.

Spiegazione:

• La regex /^\w+$/ garantisce che l'input sia una singola parola senza spazi.
• ^ asserisce l'inizio della stringa, e $ asserisce la fine. Poiché \w corrisponde solo a caratteri di parola, ^ e $ impongono implicitamente i confini di parola, rendendo \b ridondante qui.
• \w+ corrisponde a uno o più caratteri di parola (incluse lettere, cifre e trattini bassi).
• 'user123' corrisponde perché è una singola parola senza spazi.
• 'user 123' non corrisponde perché contiene uno spazio, che interrompe la sequenza di caratteri di parola.
• Si noti che \w include i trattini bassi, il che potrebbe influenzare la logica di validazione se si intende escluderli.

Estrazione di parole da una frase

È possibile estrarre parole specifiche da una frase usando i confini di parola.

Spiegazione:

• Il pattern regex /\btest\w*\b/gi corrisponde a qualsiasi parola che inizia con "test".
• Il flag g garantisce che vengano restituite tutte le corrispondenze nella stringa.
• Il flag i garantisce che la corrispondenza sia case-insensitive, quindi corrisponde sia a "test" che a "Testing".
• Il risultato è ["test", "Testing"], poiché entrambe le parole iniziano con "test" e sono seguite da zero o più caratteri di parola.

Combinare i delimitatori di parola con altri pattern

I delimitatori di parola possono essere combinati con altri pattern regex per corrispondenze più complesse.

Esempio: ricerca di parole con prefisso

Spiegazione:

• La regex /\bpre\w*\b/g corrisponde alle parole che iniziano con il prefisso "pre".
• \bpre asserisce un confine di parola seguito da "pre".
• \w* corrisponde a zero o più caratteri di parola.
• \b asserisce un confine di parola alla fine.
• Il risultato è un array contenente ["preheat", "prefix", "prepare", "pressure"].

Esempio: ricerca di parole con suffisso specifico

Spiegazione:

• La regex /\w+ing\b/g corrisponde alle parole che terminano con "ing".
• \w+ corrisponde a uno o più caratteri di parola.
• ing\b corrisponde a "ing" seguito da un confine di parola.
• Il risultato è un array contenente ["running", "walking", "talking", "thinking"].

Usare \b per corrispondenze precise di parole

Spiegazione:

• La regex /\bdog\b/g corrisponde alla parola "dog" come parola intera.
• Non corrisponde a "dogs" perché "dog" non è una parola separata in quel contesto.
• Il risultato è un array contenente ["dog"].

Esempio: corrispondenza di numeri interi

Poiché le cifre sono caratteri di parola, \b funziona anche con i numeri — utile per estrarre interi da testo misto senza dividersi su un punto decimale.

Spiegazione:

• /\b\d+\b/g corrisponde a sequenze di cifre che si trovano isolate tra caratteri non numerici.
• 3.14 viene diviso in "3" e "14" perché il . è un carattere non di parola, quindi un confine di parola si trova su ciascun lato di esso.

Limitazioni con Unicode

L'ancora \b è definita esclusivamente in termini dell'insieme ASCII \w ([a-zA-Z0-9_]). Le lettere con diacritici o i caratteri di script non latini vengono trattati come caratteri non di parola, quindi il confine appare in punti inaspettati.

Spiegazione:

• é non fa parte di \w, quindi il motore vede un confine di parola tra caf ed é.
• Il \b finale dopo é si aspetta che é sia un carattere di parola — non lo è — quindi l'intera asserzione fallisce anche se il testo contiene chiaramente la parola "café".

JavaScript non fornisce una versione Unicode-aware di \b (i flag u e v non ne cambiano la definizione). Se è necessario trovare corrispondenze di parole accentate o non latine come parole intere, è opportuno costruire confini personalizzati utilizzando una classe di caratteri esplicita, ad esempio:

Spiegazione:

• \p{L} (abilitato dal flag u) corrisponde a qualsiasi lettera Unicode.
• Il lookbehind (?<![\p{L}]) e il lookahead (?![\p{L}]) ricreano un confine consapevole delle lettere, così café trova corrispondenza ma cafés no.
• Questa è la soluzione standard quando il \b ASCII è troppo limitato per il proprio alfabeto.

Conclusione

L'ancora \b nelle espressioni regolari JavaScript è uno strumento potente per trovare corrispondenze ai confini di parola. Usando questa ancora, è possibile creare pattern precisi ed efficaci per trovare, sostituire e validare parole all'interno del testo. Che si lavori con funzionalità di ricerca, validazione dei dati o elaborazione del testo, comprendere e utilizzare i confini di parola può migliorare significativamente le capacità delle espressioni regolari.

Esercizi