JavaScript Regex Cheat Sheet

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.

Definizione di un'espressione regolare in JavaScript

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.

Corrispondenza con un set specifico di caratteri

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.

Specifica del numero di caratteri da abbinare

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.

Espressioni regolari relative alla parentesi

  • (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.

Altri caratteri di espressione regolare

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.

Uso di bandiere con espressioni regolari

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.

Metodi di espressione regolari utili in JavaScript

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))

Conclusione

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.

  • Guida per principianti alle espressioni regolari in JavaScript

    Le espressioni regolari ti consentono di manipolare le stringhe con il tuo codice. Sono molto potenti, ma hanno una sintassi speciale che può essere fonte di confusione. Questo tutorial ...
    Monty Shokeen
    Espressioni regolari
  • JavaScript Espressioni regolari: oltre le basi

    Questo tutorial ti insegnerà come usare alcune espressioni regolari sofisticate in JavaScript per abbinare i modelli in una stringa. Inizieremo con un rapido ...
    Monty Shokeen
    JavaScript

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.