Lavorare con successo con le espressioni regolari richiede che tu sappia cosa fanno ogni carattere speciale, flag e metodo. Questo è un foglio di espressioni regolari a cui puoi fare riferimento quando cerchi di ricordare come funziona un metodo, un carattere speciale o una bandiera.
Esistono due modi per definire un'espressione regolare in JavaScript.
var rgx = / ^ (\ d +) /
- Puoi usare un'espressione regolare letterale e racchiudere il modello tra le barre. Questo viene valutato al momento della compilazione e offre prestazioni migliori se l'espressione regolare rimane costante.var rgx = new RegExp ('^ (\ d +)')
- La funzione di costruzione è utile quando l'espressione regolare può cambiare a livello di codice. Questi sono compilati durante il runtime.Le seguenti sequenze possono essere utilizzate per abbinare un set specifico di caratteri.
\ w
- Corrisponde a tutti i caratteri delle parole. I caratteri di parole sono alfanumerici (a-z, caratteri A-Z e carattere di sottolineatura).\ W
- Corrisponde a caratteri non parole. Tutto tranne caratteri alfanumerici e sottolineatura.\ d
- Corrisponde a caratteri numerici. Qualsiasi cifra da 0 a 9.\ D
- Corrisponde a caratteri non numerici. Tutto tranne da 0 a 9.\S
- Corrisponde ai caratteri degli spazi bianchi. Questo include spazi, tabulazioni e interruzioni di riga.\S
- Corrisponde a tutti gli altri caratteri tranne gli spazi bianchi..
- Corrisponde a qualsiasi carattere tranne le interruzioni di riga.[A-Z]
- Trova i caratteri in un intervallo. Per esempio, [A-E]
corrisponderà A, B, C, D ed E.[ABC]
- Corrisponde a un personaggio nel set specificato. Per esempio, [AMT]
corrisponderà solo A, M e T.[^ ABC]
- Corrisponde a tutti i personaggi non presente nel set dato. Per esempio, [^ A-E]
corrisponderà a tutti gli altri caratteri tranne A, B, C, D ed E.Tutte le espressioni sopra corrispondono a un singolo personaggio alla volta. Puoi aggiungere quantificatori per specificare quanti caratteri dovrebbero essere inclusi nella partita in una sola volta.
+
- Corrisponde a una o più occorrenze del token precedente. Per esempio, \ w+
tornerà ABD12D come una singola partita invece di sei partite diverse.*
- Corrisponde a zero o più occorrenze del token precedente. Per esempio, b \ w *
corrisponde alle parti in grassetto in B, pipistrello, bajhdsfbfjhbe. Fondamentalmente, corrisponde a zero o più caratteri parola dopo "b".m, n
- Corrisponde almeno a me al massimo n occorrenze del token precedente. M,
corrisponderà ad almeno m occorrenze e non ci sarà limite superiore alla corrispondenza. K
corrisponderà esattamente a k occorrenze del token precedente.?
- Corrisponde a zero o a una occorrenza del carattere precedente. Ad esempio, questo può essere utile quando si confrontano due varianti di ortografia per lo stesso lavoro. Per esempio, /comportamento/
abbinerà entrambi comportamento e comportamento.|
- Corrisponde all'espressione prima o dopo il carattere pipe. Per esempio, / SE (a | e) /
corrisponde sia al mare che al mare.(ABC)
- Questo raggrupperà più token insieme e ricorderà la sottostringa corrispondente da essi per un uso successivo. Questo è chiamato un gruppo di cattura.(:? ABC)
- Questo raggrupperà anche più token insieme ma non ricorderà la partita. È un gruppo non catturante.\ D + (? = ABC)
- Questo corrisponderà al token (s) che precede il (? = ABC)
parte solo se è seguita da ABC
. La parte ABC
non sarà incluso nella partita. Il \ d
parte è solo un esempio. Potrebbe essere qualsiasi altra stringa di espressioni regolari.\ D + (?! ABC)
- Questo corrisponderà al token (s) che precede il (?! ABC)
parte solo se lo è non seguito da ABC
. La parte ABC
non sarà incluso nella partita. Il \ d
parte è solo un esempio. Potrebbe essere qualsiasi altra stringa di espressioni regolari.Ci sono anche altri caratteri di espressioni regolari che non sono stati trattati nelle sezioni precedenti:
^
- Cerca l'espressione regolare all'inizio della stringa o l'inizio di una riga se il flag multilinea è abilitato.$
- Cerca l'espressione regolare alla fine della stringa o alla fine di una riga se il flag multilinea è abilitato.\ b
- Abbina il token precedente solo se esiste un limite di parole.\ B
- Abbina il token precedente solo se non ci sono limiti di parole.Le bandiere possono essere utilizzate per controllare come deve essere interpretata un'espressione regolare. Puoi usare le bandiere da sole o insieme nell'ordine che preferisci. Questi sono i cinque flag disponibili in JavaScript.
g
- Cerca la stringa per tutte le corrispondenze dell'espressione data invece di restituire solo la prima.io
- Rendi la ricerca maiuscole e minuscole insensibile, in modo che parole come Apple, aPPLe e Apple possano essere tutte abbinate contemporaneamente.m
- Questa bandiera farà in modo che il ^
e $
i token cercano una corrispondenza all'inizio o alla fine di ogni riga invece dell'intera stringa.u
- Questo flag ti consentirà di utilizzare gli escape del punto di codice Unicode nell'espressione regolare.y
- Questo dirà a JavaScript di cercare solo una corrispondenza nella posizione corrente nella stringa di destinazione.Puoi specificare i flag per un'espressione regolare in JavaScript aggiungendoli alla fine di un'espressione regolare letterale o passandoli a RegExp
costruttore. Per esempio, / Cat / i
corrisponde a tutte le occorrenze di gatto indipendentemente dal caso, e RegExp ("cat", "i")
fa lo stesso.
Le espressioni regolari che create usando le flag e le sequenze di caratteri che abbiamo discusso finora sono pensate per essere usate con metodi diversi per cercare, sostituire o dividere una stringa. Ecco alcuni metodi relativi alle espressioni regolari.
test()
- Controlla se la stringa principale contiene una sottostringa che corrisponde al modello specificato dall'espressione regolare specificata. Ritorna vero
sulla partita di successo e falso
altrimenti.var textA = 'Mi piacciono molto le mele'; var textB = 'Mi piacciono le mele'; var regexOne = / apples $ / i // Output: false console.log (regexOne.test (textA)); // Output: true console.log (regexOne.test (textB));
Nell'esempio sopra, l'espressione regolare dovrebbe cercare la parola mele solo alla fine della stringa. Ecco perché abbiamo ottenuto falso
nel primo caso.
ricerca()
- Controlla se la stringa principale contiene una sottostringa che corrisponde al modello specificato dall'espressione regolare specificata. Restituisce l'indice della partita in caso di successo e -1 altrimenti.var textA = 'Mi piacciono molto le mele'; var regexOne = / apples /; var regexTwo = / apples / i; // Output: -1 console.log (textA.search (regexOne)); // Output: 7 console.log (textA.search (regexTwo));
In questo caso, viene restituita la prima espressione regolare -1 perché non c'era una corrispondenza esatta con distinzione tra maiuscole e minuscole.
incontro()
- Cerca se la stringa principale contiene una sottostringa che corrisponde al modello specificato dall'espressione regolare specificata. Se la g
flag è abilitato, più corrispondenze verranno restituite come array.var textA = 'Tutto quello che vedo qui sono mele, mele e apPleS'; var regexOne = / apples / gi; // Output: ["apples", "APPles", "apPleS"] console.log (textA.match (regexOne));
exec ()
- Cerca se la stringa principale contiene una sottostringa che corrisponde al modello specificato dall'espressione regolare specificata. L'array restituito conterrà informazioni sulla corrispondenza e sui gruppi di cattura.var textA = 'Ti piacciono le mele?'; var regexOne = / apples /; // Output: apples console.log (regexOne.exec (textA) [0]); // Output: ti piacciono le mele? console.log (regexOne.exec (Texta) .input);
sostituire()
- Cerca una sottostringa che corrisponda al modello specificato e sostituiscila con la stringa di sostituzione fornita.var textA = 'Ti piacciono le aPPles?'; var regexOne = / apples / i // Output: ti piacciono i manghi? console.log (textA.replace (regexOne, 'mangoes'));
Diviso()
- Questo metodo consente di dividere la stringa principale in sottostringhe in base al separatore specificato come espressione regolare.var textA = 'Questa stringa 593 sarà brok294en nei luoghi in cui sono presenti d1gits.'; var regexOne = / \ d + / g // Output: ["Questo", "stringa sarà brok", "en nei luoghi in cui d", "gits sono". ] console.log (textA.split (regexOne))
Nelle esercitazioni precedenti, ho trattato le basi delle espressioni regolari e di alcune espressioni più complicate che possono rivelarsi utili ogni tanto. Questi due tutorial hanno spiegato come personaggi diversi o sequenze di caratteri funzionano in espressioni regolari.
Se le espressioni regolari ti confondono, il mio consiglio sarebbe di continuare a praticare e vedere come gli altri escono con espressioni regolari per fare un particolare schema.