JavaScript => Espressioni regolari

Sintassi

lascia regex = / pattern / [ flags ]
let regex = new RegExp (' pattern ', [ flags ])
let ismatch = regex.test (' testo ')
let results = regex.exec (' testo ')

Parametri

bandiere	Dettagli
g	g lobal. Tutte le partite (non tornare alla prima partita).
m	m ulti-line. Fa sì che ^ & $ corrisponda all'inizio / alla fine di ogni riga (non solo inizio / fine stringa).
io	io nsensibile. Corrispondenza insensibile al maiuscolo / minuscolo (ignora il caso di [a-zA-Z]).
u	u nicode: Le stringhe sono trattate come UTF-16. Inoltre, fa in modo che le sequenze di escape corrispondano ai caratteri Unicode.
y	stick y : corrisponde solo all'indice indicato dalla proprietà lastIndex di questa espressione regolare nella stringa di destinazione (e non tenta di corrispondere da alcun indice successivo).

Osservazioni

L'oggetto RegExp è tanto utile quanto la tua conoscenza delle espressioni regolari è forte. Vedi qui per un primer introduttivo, o vedi MDN per una spiegazione più approfondita.

Creazione di un oggetto RegExp

Creazione standard

Si consiglia di utilizzare questo modulo solo quando si crea un'espressione regolare da variabili dinamiche.

Utilizzare quando l'espressione può cambiare o l'espressione è generata dall'utente.

var re = new RegExp(".*");

Con le bandiere:

var re = new RegExp(".*", "gmi");

Con una barra rovesciata: (questo deve essere preceduto da escape perché la regex è specificata con una stringa)

var re = new RegExp("\\w*");

Inizializzazione statica

Usare quando si sa che l'espressione regolare non cambierà e si conosce l'espressione prima del runtime.

var re = /.*/;

Con le bandiere:

var re = /.*/gmi;

Con una barra rovesciata: (questo non dovrebbe essere sfuggito perché la regex è specificata in un letterale)

var re = /\w*/;

RegExp Flags

Esistono diversi flag che è possibile specificare per modificare il comportamento RegEx. Le bandiere possono essere aggiunte alla fine di un regex letterale, ad esempio specificando gi in /test/gi , oppure possono essere specificate come secondo argomento del costruttore RegExp , come nel new RegExp('test', 'gi') .

g - Globale. Trova tutte le corrispondenze invece di fermarsi dopo il primo.

i - Ignora caso. /[az]/i è equivalente a /[a-zA-Z]/ .

m - Multiline. ^ e $ corrispondono all'inizio e alla fine di ogni riga rispettivamente trattando \n e \r come delimitatori invece che semplicemente all'inizio e alla fine dell'intera stringa.

u - Unicode. Se questo flag non è supportato devi corrispondere a caratteri Unicode specifici con \uXXXX dove XXXX è il valore del carattere in esadecimale.

y - Trova tutte le partite consecutive / adiacenti.

Corrispondenza con .exec ()

Abbina usando `.exec()`

RegExp.prototype.exec(string) restituisce una matrice di acquisizioni, o null se non ci sono corrispondenze.

var re = /([0-9]+)[a-z]+/;
var match = re.exec("foo123bar");

match.index è 3, la posizione (a base zero) della corrispondenza.

match[0] è la stringa di corrispondenza completa.

match[1] è il testo corrispondente al primo gruppo catturato. match[n] sarebbe il valore del n ° gruppo catturato.

Loop Through Matches utilizzando `.exec()`

var re = /a/g;
var result;
while ((result = re.exec('barbatbaz')) !== null) {
    console.log("found '" + result[0] + "', next exec starts at index '" + re.lastIndex + "'");
}

Uscita prevista

trovato 'a', il prossimo exec inizia all'indice '2'
trovato 'a', il prossimo exec inizia all'indice '5'
trovato 'a', il prossimo exec inizia all'indice '8'

Controlla se la stringa contiene pattern usando .test ()

var re = /[a-z]+/;
if (re.test("foo")) {
    console.log("Match exists.");
}

Il metodo di test esegue una ricerca per verificare se un'espressione regolare corrisponde a una stringa. L'espressione regolare [az]+ cercherà una o più lettere minuscole. Poiché il pattern corrisponde alla stringa, "match exists" verrà registrato nella console.

Utilizzare RegExp con le stringhe

L'oggetto String ha i seguenti metodi che accettano espressioni regolari come argomenti.

"string".match(...
"string".replace(...
"string".split(...
"string".search(...

Abbina con RegExp

console.log("string".match(/[i-n]+/));
console.log("string".match(/(r)[i-n]+/));

Uscita prevista

Array ["in"]
Array ["rin", "r"]

Sostituisci con RegExp

console.log("string".replace(/[i-n]+/, "foo"));

Uscita prevista

strfoog

Dividi con RegExp

console.log("stringstring".split(/[i-n]+/));

Uscita prevista

Array ["str", "gstr", "g"]

Cerca con RegExp

.search() restituisce l'indice al quale viene trovata una corrispondenza o -1.

console.log("string".search(/[i-n]+/));
console.log("string".search(/[o-q]+/));

Uscita prevista

3
-1

Sostituire la corrispondenza della stringa con una funzione di callback

String#replace può avere una funzione come secondo argomento in modo da poter fornire una sostituzione basata su una logica.

"Some string Some".replace(/Some/g, (match, startIndex, wholeString) => {
  if(startIndex == 0){
    return 'Start';
  } else {
    return 'End';
  }
});
// will return Start string End

Libreria di modelli di una riga

let data = {name: 'John', surname: 'Doe'}
"My name is {surname}, {name} {surname}".replace(/(?:{(.+?)})/g, x => data[x.slice(1,-1)]);

// "My name is Doe, John Doe"

Gruppi RegExp

JavaScript supporta diversi tipi di gruppi nelle sue espressioni regolari, gruppi di cattura , gruppi non di acquisizione e look-ahead . Attualmente, non vi è alcun supporto look-behind .

Catturare

A volte la partita desiderata dipende dal suo contesto. Questo significa che un semplice RegExp troverà il pezzo della String che interessa, quindi la soluzione è scrivere un gruppo di cattura (pattern) . I dati acquisiti possono quindi essere referenziati come ...

Sostituzione delle stringhe "$n" dove n è il n ° gruppo di cattura (a partire da 1 )
Il n argomento in una funzione di callback
Se RegExp non è contrassegnato con g , il n + 1 ° elemento in una matrice str.match restituita
Se RegExp è contrassegnato con g , str.match scarta catture, usa invece re.exec

Diciamo che c'è una stringa in cui tutti i segni + devono essere sostituiti con uno spazio, ma solo se seguono un carattere di lettera. Ciò significa che una corrispondenza semplice includerebbe quel carattere lettera e sarebbe anche rimosso. Catturarlo è la soluzione in quanto significa che la lettera abbinata può essere preservata.

let str = "aa+b+cc+1+2",
    re = /([a-z])\+/g;

// String replacement
str.replace(re, '$1 '); // "aa b cc 1+2"
// Function replacement
str.replace(re, (m, $1) => $1 + ' '); // "aa b cc 1+2"

Non-Capture

Usando il modulo (?:pattern) , questi funzionano in modo simile per catturare gruppi, tranne che non memorizzano il contenuto del gruppo dopo la partita.

Possono essere particolarmente utili se vengono catturati altri dati di cui non si desidera spostare gli indici, ma è necessario eseguire alcuni pattern matching avanzati come un OR

let str = "aa+b+cc+1+2",
    re = /(?:\b|c)([a-z])\+/g;

str.replace(re, '$1 '); // "aa+b c 1+2"

Guarda avanti

Se la partita desiderata fa affidamento su qualcosa che la segue, piuttosto che abbinarla e catturarla, è possibile usare un look-ahead per testarlo ma non includerlo nella partita. Un look-ahead positivo ha la forma (?=pattern) , una prospettiva negativa (dove l'espressione corrisponde solo se il modello look-ahead non corrisponde) ha la forma (?!pattern)

let str = "aa+b+cc+1+2",
    re = /\+(?=[a-z])/g;

str.replace(re, ' '); // "aa b cc+1+2"

Usando Regex.exec () con parentesi regex per estrarre le corrispondenze di una stringa

A volte non vuoi semplicemente sostituire o rimuovere la stringa. A volte vuoi estrarre ed elaborare le corrispondenze. Ecco un esempio di come si manipolano le partite.

Cos'è una partita? Quando viene trovata una sottostringa compatibile per l'intera regex nella stringa, il comando exec produce una corrispondenza. Una corrispondenza è una matrice che compone in primo luogo l'intera sottostringa corrispondente e tutte le parentesi nella corrispondenza.

Immagina una stringa html:

<html>
<head></head>
<body>
  <h1>Example</h1>
  <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>
  Copyright <a href="https://stackoverflow.com">Stackoverflow</a>
</body>

Si desidera estrarre e ottenere tutti i link all'interno di un a tag. All'inizio, qui la regex scrivi:

var re = /<a[^>]*href="https?:\/\/.*"[^>]*>[^<]*<\/a>/g;

Ma ora, immagina di volere l' href e l' anchor di ogni collegamento. E tu lo vuoi insieme. Puoi semplicemente aggiungere una nuova espressione regolare per ogni corrispondenza OPPURE puoi usare le parentesi:

var re = /<a[^>]*href="(https?:\/\/.*)"[^>]*>([^<]*)<\/a>/g; 
var str = '<html>\n    <head></head>\n    <body>\n        <h1>Example</h1>\n        <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>\n\n        Copyright <a href="https://stackoverflow.com">Stackoverflow</a>\n    </body>\';\n';
var m;
var links = [];

while ((m = re.exec(str)) !== null) {
    if (m.index === re.lastIndex) {
        re.lastIndex++;
    }
    console.log(m[0]); // The all substring
    console.log(m[1]); // The href subpart
    console.log(m[2]); // The anchor subpart

    links.push({
      match : m[0],   // the entire match
      href : m[1],    // the first parenthesis => (https?:\/\/.*)
      anchor : m[2],  // the second one => ([^<]*)
    });
}

Alla fine del ciclo, hai un array di link con anchor e href e puoi usarlo per scrivere markdown ad esempio:

links.forEach(function(link) {
  console.log('[%s](%s)', link.anchor, link.href);
});

Andare oltre :

Parentesi nidificata

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

JavaScript
Espressioni regolari

Ricerca…

Sintassi

Parametri

Osservazioni

Creazione di un oggetto RegExp

Creazione standard

Inizializzazione statica

RegExp Flags

Corrispondenza con .exec ()

Abbina usando `.exec()`

Loop Through Matches utilizzando `.exec()`

Controlla se la stringa contiene pattern usando .test ()

Utilizzare RegExp con le stringhe

Abbina con RegExp

Sostituisci con RegExp

Dividi con RegExp

Cerca con RegExp

Sostituire la corrispondenza della stringa con una funzione di callback

Gruppi RegExp

Catturare

Non-Capture

Guarda avanti

Usando Regex.exec () con parentesi regex per estrarre le corrispondenze di una stringa

Sintassi

Parametri

Osservazioni

Creazione di un oggetto RegExp

Creazione standard

Inizializzazione statica

RegExp Flags

Corrispondenza con .exec ()

Abbina usando .exec()

Loop Through Matches utilizzando .exec()

Controlla se la stringa contiene pattern usando .test ()

Utilizzare RegExp con le stringhe

Abbina con RegExp

Sostituisci con RegExp

Dividi con RegExp

Cerca con RegExp

Sostituire la corrispondenza della stringa con una funzione di callback

Gruppi RegExp

Catturare

Non-Capture

Guarda avanti

Usando Regex.exec () con parentesi regex per estrarre le corrispondenze di una stringa

Abbina usando `.exec()`

Loop Through Matches utilizzando `.exec()`