Le espressioni regolari, comunemente note come "regex" o "regexp", sono stringhe che descrivono un modello di ricerca. È possibile utilizzare le espressioni regolari per verificare se una stringa contiene uno schema specifico, estrarre informazioni da una stringa e sostituire parti di una stringa con nuovo testo.
Impara la sintassi di base delle espressioni regolari e come utilizzarle in JavaScript.
La sintassi di base delle espressioni regolari
Ci sono due modi per creare un'espressione regolare in JavaScript: usando un'espressione regolare letterale e usando il RegExp costruttore.
Un valore letterale di un'espressione regolare è costituito da uno schema racchiuso tra barre, seguito da un flag facoltativo.
Per esempio:
// Senza bandiera
cost regexExpression_1 = /pattern/
// Con bandiera
cost regexExpression_2 = /pattern/bandiera
Un flag è un parametro facoltativo che puoi aggiungere a un'espressione regolare per modificarne il comportamento. Per esempio:
cost regexFlag = /the/g;
IL G flag indica che l'espressione deve corrispondere a tutte le occorrenze, non solo alla prima.
Puoi anche creare un'espressione regolare usando il RegExp costruttore. Per esempio:
cost regexExpression = nuovoRegExp("Modello", "G");
IL RegExp Il costruttore accetta due parametri: un modello (una stringa o un'espressione regolare letterale) e uno o più flag.
Esistono due flag abbastanza comuni che utilizzerai con l'espressione regolare in JavaScript:
- G: Il flag globale fa in modo che l'espressione regolare corrisponda a tutte le occorrenze del modello nella stringa data anziché a una singola occorrenza.
- io: Il flag senza distinzione tra maiuscole e minuscole fa in modo che l'espressione regolare ignori le maiuscole e minuscole del modello e corrisponda ai caratteri maiuscoli e minuscoli nella stringa data.
È possibile utilizzare i flag insieme in un'unica espressione in qualsiasi ordine. Per esempio:
cost regexExpression = nuovoRegExp("Modello", "gi");
Questa espressione corrisponderà a tutte le occorrenze di "Pattern", indipendentemente dal caso.
Nelle espressioni regolari, alcuni caratteri, noti come metacaratteri, hanno significati speciali. Puoi usarli per abbinare tipi specifici di caratteri o modelli.
Ecco alcuni dei metacaratteri più comunemente usati e il loro significato:
- Il carattere jolly (.): questo carattere corrisponde a qualsiasi singolo carattere ad eccezione di una nuova riga. È uno strumento utile per abbinare modelli con caratteri sconosciuti.
- La Stella Kleene (*): questo carattere corrisponde a zero o più occorrenze del carattere o gruppo precedente. Consente al carattere o al gruppo precedente di comparire un numero qualsiasi di volte nella stringa, compreso lo zero.
- Il carattere facoltativo (?): questo carattere corrisponde a zero o a un'occorrenza di un carattere o gruppo precedente.
- Inizio della linea di ancoraggio (^): questo carattere corrisponde solo all'inizio di una riga o di una stringa.
- Ancoraggio di fine linea ($): questo carattere corrisponde alla fine di una riga o di una stringa.
- Set di caratteri/classe ([]): un set di caratteri corrisponde a qualsiasi carattere da un set di caratteri in una stringa. Li definisci usando le parentesi quadre [] ed è possibile specificare un set di caratteri fissi, caratteri speciali o determinati gruppi di caratteri.
- Carattere di alternanza (|): Questo carattere corrisponde al carattere o gruppo precedente o successivo. Funziona in modo simile all'OR Operatore JavaScript.
- Carattere di raggruppamento (()): Il carattere di raggruppamento consente di raggruppare caratteri o sottoespressioni, applicare loro operatori come unità e controllare l'ordine delle operazioni.
Test di una stringa rispetto a un'espressione regolare in JavaScript
In JavaScript, puoi testare una stringa rispetto a un'espressione regolare utilizzando diversi metodi.
Questa sezione presuppone che tu abbia una conoscenza di base delle espressioni regolari e dei pattern. Se ti senti a disagio con le espressioni regolari, dai un'occhiata una guida per principianti alle espressioni regolari Primo.
Il metodo di prova
IL .test() Il metodo restituisce un valore booleano che indica se l'espressione regolare corrisponde o meno alla stringa. Questo metodo accetta come argomento una stringa su cui eseguire la ricerca. È particolarmente utile per controlli semplici.
Per esempio:
permettere espressione regolare = /.com$/;
permettere stra = "esempio.com";
consolare.log (regex.test (str)); // VERO
Questa espressione regolare corrisponde a una stringa che termina con ".com".
Il metodo exec
IL .exec() Il metodo restituisce un array contenente il testo corrispondente e tutti i gruppi acquisiti o nullo se non trova corrispondenza. Questo metodo accetta come argomento una stringa su cui eseguire la ricerca. È utile per espressioni regolari più complesse.
Per esempio:
permettere espressione regolare = /^\\(?([0-9]{3})\\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/;
permettere stra = "123-456-7890";
permettere risultato = regex.exec (str);
Se (risultato !== nullo) {
consolare.tronco d'albero(`${risultato[0]} è un numero di telefono valido`);
} altro {
consolare.tronco d'albero("Numero di telefono invalido");
}
L'espressione regolare sopra corrisponde a una stringa che inizia con un facoltativo "(", tre cifre e un facoltativo ")". Quindi cerca un facoltativo "-", ".", o spazio, seguito da tre cifre. Alla fine cerca un optional "-", ".", o uno spazio seguito da quattro cifre alla fine della stringa.
Questa espressione regolare corrisponde ai numeri di telefono nel formato "(xxx) xxx-xxxx", "xxx-xxx-xxxx", "xxx.xxx.xxxx" o "xxx xxx xxxx".
Se trova una corrispondenza, .exec() restituisce un array contenente il testo corrispondente e tutti i gruppi acquisiti (definiti tra parentesi). Includerà ogni gruppo come elemento aggiuntivo nell'array che restituisce. Ciò ti consente di accedere a parti specifiche del testo corrispondente, che può aiutarti a estrarre informazioni da una stringa.
Il metodo di sostituzione
IL .sostituire() Il metodo cerca una corrispondenza tra un'espressione regolare e una stringa e sostituisce il testo corrispondente con un testo sostitutivo specificato. Questo è un metodo di oggetti stringa e accetta un'espressione regolare e una stringa di sostituzione come argomenti.
Per esempio:
permettere stringa = "La veloce volpe bruna salta sopra il cane pigro.";
permettere espressione = /The/gi;
permettere newString = string.replace (espressione, "UN");
consolare.log (nuovaStringa); // "una veloce volpe bruna salta sopra un cane pigro."
Questo esempio chiama il sostituire() metodo sul corda variabile, passando l'espressione regolare, espressione. L'espressione regolare corrisponderà a tutte le occorrenze di "The" nella stringa, indipendentemente dal caso. La chiamata al metodo replace gli dice di sostituire ogni occorrenza con la stringa "a".
Considerazioni sulle prestazioni durante l'utilizzo delle espressioni regolari
Sebbene le espressioni regolari aiutino ad abbinare e manipolare le stringhe, possono anche essere costose in termini di prestazioni. Rendere i modelli il più specifici possibile e mantenerli semplici è fondamentale per mantenerli performanti.