Una guida rapida e semplice alle espressioni regolari JavaScript

Ti interessa imparare JavaScript? Ottieni il mio ebook gratuito su jshandbook.com

Introduzione alle espressioni regolari

Un'espressione regolare (chiamata anche regex in breve) è un modo rapido per lavorare con stringhe di testo.

Formulando un'espressione regolare con una sintassi speciale, è possibile:

  • cerca il testo in una stringa
  • sostituire le sottostringhe in una stringa
  • ed estrarre informazioni da una stringa

Quasi ogni linguaggio di programmazione prevede l'implementazione di espressioni regolari. Ci sono piccole differenze tra ogni implementazione, ma i concetti generali si applicano quasi ovunque.

Le espressioni regolari risalgono agli anni '50, quando furono formalizzate come modello di ricerca concettuale per gli algoritmi di elaborazione delle stringhe.

Implementati in strumenti UNIX come grep, sed e nei popolari editor di testi, le regex sono cresciute in popolarità. Sono stati introdotti nel linguaggio di programmazione Perl e successivamente anche in molti altri.

JavaScript, insieme a Perl, è uno dei linguaggi di programmazione che supporta le espressioni regolari direttamente integrate nel linguaggio.

Difficile ma utile

Le espressioni regolari possono sembrare un'assurdità assoluta per il principiante e molte volte anche per lo sviluppatore professionista, se non investi il ​​tempo necessario per capirle.

Le espressioni criptiche regolari sono difficili da scrivere, difficili da leggere e difficili da mantenere / modificare.

Ma a volte un'espressione regolare è l'unico modo sano per eseguire alcune manipolazioni delle stringhe, quindi è uno strumento molto prezioso in tasca.

Questo tutorial ha lo scopo di farti conoscere le espressioni regolari JavaScript in modo semplice e di fornirti tutte le informazioni per leggere e creare espressioni regolari.

La regola empirica è che le semplici espressioni regolari sono semplici da leggere e scrivere, mentre le espressioni regolari complesse possono rapidamente trasformarsi in un disastro se non si afferrano profondamente le basi.

Che aspetto ha un'espressione regolare?

In JavaScript, un'espressione regolare è un oggetto, che può essere definito in due modi.

Il primo consiste nell'istanziare un nuovo oggetto RegExp usando il costruttore:

const re1 = new RegExp ('hey')

Il secondo sta usando l'espressione regolare in forma letterale:

const re1 = / hey /

Sai che JavaScript ha letterali di oggetti e letterali di array? Ha anche letterali regex.

Nell'esempio sopra, hey è chiamato il modello. Nella forma letterale è delimitato da barre, mentre non lo è con il costruttore di oggetti.

Questa è la prima differenza importante tra le due forme, ma ne vedremo altre in seguito.

Come funziona?

L'espressione regolare che abbiamo definito come re1 sopra è molto semplice. Cerca la stringa hey, senza alcuna limitazione. La stringa può contenere molto testo e hey nel mezzo e la regex è soddisfatta. Potrebbe anche contenere solo ehi, e anche la regex sarebbe soddisfatta.

È abbastanza semplice.

Puoi testare il regex usando RegExp.test (String), che restituisce un valore booleano:

re1.test ('hey') // 
re1.test ('blablabla hey blablabla') // 
re1.test ('he') // 
re1.test ('blablabla') // 

Nell'esempio sopra, abbiamo appena verificato se "hey" soddisfa il modello di espressione regolare memorizzato in re1.

Questo è il più semplice che può essere, ma ora conosci già molti concetti sui regex.

ancoraggio

/Hey/

corrisponde hey ovunque sia stato inserito all'interno della stringa.

Se si desidera abbinare le stringhe che iniziano con hey, utilizzare l'operatore ^:

/^hey/.test('hey ') // 
/^hey/.test('bla hey ') // 

Se vuoi abbinare le stringhe che finiscono con hey, usa l'operatore $:

/hey$/.test('hey ') // 
/hey$/.test('bla hey ') // 
/hey$/.test('hey you ') // 

Combina quelli e abbina le stringhe che corrispondono esattamente a hey, e solo quella stringa:

/^hey$/.test('hey ') // 

Per abbinare una stringa che inizia con una sottostringa e termina con un'altra, puoi usare. *, Che corrisponde a qualsiasi carattere ripetuto 0 o più volte:

/^hey.*joe$/.test('hey joe ') // 
/^hey.*joe$/.test('heyjoe ') // 
/^hey.*joe$/.test('hey how you you joe ') // 
/^hey.*joe$/.test('hey joe! ') // 

Abbina gli articoli negli intervalli

Invece di abbinare una particolare stringa, puoi scegliere di abbinare qualsiasi carattere in un intervallo, come:

/ [a-z] / // a, b, c, ..., x, y, z
/ [A-Z] / // A, B, C, ..., X, Y, Z
/ [a-c] / // a, b, c
/ [0-9] / // 0, 1, 2, 3, ..., 8, 9

Queste regex corrispondono a stringhe che contengono almeno uno dei caratteri in quegli intervalli:

/[a-z[/.test('a ') // 
/[a-z[/.test('1 ') // 
/[a-z[/.test('A ') // 
/[a-c[/.test('d ') // 
/[a-c[/.test('dc ') // 

Gli intervalli possono essere combinati:

/ [A-Za-Z0-9] /
/[A-Za-z0-9[/.test('a ') // 
/[A-Za-z0-9[/.test('1 ') // 
/[A-Za-z0-9[/.test('A ') // 

Corrispondenza di un elemento di intervallo più volte

Puoi controllare se una stringa contiene uno e un solo carattere in un intervallo usando il carattere -:

/ ^ [-Za-z0-9 A] $ /
/^[A-Za-z0-9[$/.test('A ') // 
/^[A-Za-z0-9[$/.test('Ab ') // 

Negare uno schema

Il carattere ^ all'inizio di un modello lo fissa all'inizio di una stringa.

Utilizzato all'interno di un intervallo, lo annulla, quindi:

/[^A-Za-z0-9[/.test('a ') // 
/[^A-Za-z0-9[/.test('1 ') // 
/[^A-Za-z0-9[/.test('A ') // 
/[^A-Za-z0-9[/.test('@ ') // 
  • \ d corrisponde a qualsiasi cifra, equivalente a [0-9]
  • \ D corrisponde a qualsiasi carattere che non sia una cifra, equivalente a [^ 0-9]
  • \ w corrisponde a qualsiasi carattere alfanumerico, equivalente a [A-Za-z0-9]
  • \ W corrisponde a qualsiasi carattere non alfanumerico, equivalente a [^ A-Za-z0-9]
  • \ s corrisponde a qualsiasi carattere di spazio: spazi, tabulazioni, nuove righe e spazi Unicode
  • \ S corrisponde a qualsiasi personaggio che non sia uno spazio bianco
  • \ 0 corrisponde a null
  • \ n corrisponde a un carattere di nuova riga
  • \ t corrisponde a un carattere di tabulazione
  • \ uXXXX corrisponde a un carattere unicode con il codice XXXX (richiede il flag u)
  • . corrisponde a qualsiasi carattere che non sia un carattere newline (ad es. \ n) (a meno che non si usi il flag s, spiegato più avanti)
  • [^] corrisponde a qualsiasi carattere, inclusi i caratteri di nuova riga. È utile su stringhe multilinea.

Scelte di espressioni regolari

Se si desidera cercare una stringa o un'altra, utilizzare | operatore.

/hey|ho/.test('hey ') // 
/hey|ho/.test('ho ') // 

quantificatori

Supponi di avere questa regex che controlla se una stringa contiene una cifra e nient'altro:

/ ^ \ D $ /

Puoi usare il? quantificatore per renderlo facoltativo, richiedendo quindi zero o uno:

/ ^ \ D? $ /

ma cosa succede se si desidera abbinare più cifre?

Puoi farlo in 4 modi, usando +, *, {n} e {n, m}. Diamo un'occhiata a questi uno per uno.

+

Abbina uno o più (> = 1) elementi

/ ^ \ D + $ /
/^\d+$/.test('12 ') // 
/^\d+$/.test('14 ') // 
/^\d+$/.test('144343 ') // 
/ ^ \ d + $ /. test ('') // 
/^\d+$/.test('1a ') // 

*

Abbina 0 o più (> = 0) elementi

/ ^ \ D + $ /
/^\d*$/.test('12 ') // 
/^\d*$/.test('14 ') // 
/^\d*$/.test('144343 ') // 
/ ^ \ d * $ /. test ('') // 
/^\d*$/.test('1a ') // 

{N}

Abbina esattamente n articoli

/ ^ \ D {3} $ /
/^\d{3}$/.test('123 ') // 
/^\d{3}$/.test('12 ') // 
/^\d{3}$/.test('1234 ') // 
/^[A-Za-z0-9[{3}$/.test('Abc ') // 

{N, m}

Corrispondenza tra n e m volte:

/ ^ \ D {3,5} $ /
/^\d{3,5}$/.test('123 ') // 
/^\d{3,5}$/.test('1234 ') // 
/^\d{3,5}$/.test('12345 ') // 
/^\d{3,5}$/.test('123456 ') // 

m può essere omesso per avere un finale aperto, quindi hai almeno n elementi:

/ ^ \ D {3,} $ /
/^\d{3,}$/.test('12 ') // 
/^\d{3,}$/.test('123 ') // 
/^\d{3,}$/.test('12345 ') // 
/^\d{3,}$/.test('123456789 ') // 

Articoli opzionali

Stai seguendo un articolo con? lo rende opzionale:

/ ^ \ D {3} \ w? $ /
/^\d{3}\w?$/.test('123 ') // 
/^\d{3}\w?$/.test('123a ') // 
/^\d{3}\w?$/.test('123ab ') // 

gruppi

Usando le parentesi, puoi creare gruppi di caratteri: (...)

Questo esempio corrisponde esattamente a 3 cifre seguite da uno o più caratteri alfanumerici:

/ ^ (\ D {3}) (\ w +) $ /
/^(\d{3})(\w+)$/.test('123 ') // 
/^(\d{3})(\w+)$/.test('123s ') // 
/^(\d{3})(\w+)$/.test('123something ') // 
/^(\d{3})(\w+)$/.test('1234 ') // 

I caratteri di ripetizione inseriti dopo che un gruppo chiude le parentesi si riferiscono all'intero gruppo:

/ ^ (\ D {2}) + $ /
/^(\d{2})+$/.test('12 ') // 
/^(\d{2})+$/.test('123 ') // 
/^(\d{2})+$/.test('1234 ') // 

Catturare gruppi

Finora abbiamo visto come testare le stringhe e verificare se contengono un determinato schema.

Una caratteristica molto interessante delle espressioni regolari è la capacità di catturare parti di una stringa e inserirle in un array.

Puoi farlo utilizzando Gruppi, in particolare Acquisizione di gruppi.

Per impostazione predefinita, un gruppo è un gruppo di acquisizione. Ora, invece di utilizzare RegExp.test (String), che restituisce solo un valore booleano se il modello è soddisfatto, utilizziamo String.match (RegExp) o RegExp.exec (String).

Sono esattamente gli stessi e restituiscono un array con l'intera stringa corrispondente nel primo elemento, quindi ogni contenuto del gruppo corrispondente.

Se non c'è corrispondenza, restituisce null:

'123s'.match (/ ^ (\ d {3}) (\ w +) $ /)
// Array ["123s", "123", "s"]
/^(\d{3})(\w+)$/.exec('123s')
// Array ["123s", "123", "s"]
'Hey'.match (/ (hey | ho) /)
// Array ["hey", "hey"]
/(hey|ho)/.exec('hey ')
// Array ["hey", "hey"]
/(hey|ho)/.exec('ha! ')
//nullo

Quando un gruppo viene abbinato più volte, nella matrice dei risultati viene inserita solo l'ultima corrispondenza:

'123456789'.match (/ (\ d) + /)
// Array ["123456789", "9"]

Gruppi opzionali

Un gruppo di acquisizione può essere reso facoltativo utilizzando (...) ?. Se non viene trovato, lo slot di matrice risultante conterrà non definito:

/^(\d{3})(\s)?(\w+)$/.exec('123 s ')
// Array ["123 s", "123", "", "s"]
/^(\d{3})(\s)?(\w+)$/.exec('123s')
// Array ["123s", "123", non definito, "s"]

Gruppi di riferimento corrispondenti

A ogni gruppo abbinato viene assegnato un numero. $ 1 si riferisce al primo, $ 2 al secondo e così via. Ciò sarà utile quando parleremo più avanti della sostituzione di parti di una stringa.

Gruppi di acquisizione nominati

Questa è una nuova funzionalità ES2018.

A un gruppo può essere assegnato un nome, anziché semplicemente assegnare uno slot nell'array risultante:

const re = / (?  \ d {4}) - (?  \ d {2}) - (?  \ d {2}) /
const result = re.exec ('2015-01-02')
// result.groups.year === '2015';
// result.groups.month === '01';
// result.groups.day === '02';

Utilizzo di match ed exec senza gruppi

Esiste una differenza tra l'utilizzo di match e exec senza gruppi: il primo elemento dell'array non è l'intera stringa corrispondente, ma la corrispondenza direttamente:

/hey|ho/.exec('hey ')
// [ "Hey" ]
/(hey).(ho)/.exec('hey ho ')
// ["hey ho", "hey", "ho"]

Gruppi non catturanti

Poiché per impostazione predefinita i gruppi sono gruppi di acquisizione, è necessario un modo per ignorare alcuni gruppi nell'array risultante. Ciò è possibile utilizzando i gruppi non acquisiti, che iniziano con un (?: ...)

'123s'.match (/ ^ (\ d {3}) (:? \ S) (\ w +) $ /)
//nullo
'123 s'.match (/ ^ (\ d {3}) (?: \ S) (\ w +) $ /)
// Array ["123 s", "123", "s"]

bandiere

È possibile utilizzare i seguenti flag su qualsiasi espressione regolare:

  • g: corrisponde più volte al modello
  • i: rende insensibile al maiuscolo regex
  • m: abilita la modalità multilinea. In questa modalità, ^ e $ corrispondono all'inizio e alla fine dell'intera stringa. Senza questo, con stringhe multilinea corrispondono all'inizio e alla fine di ogni riga.
  • u: abilita il supporto per Unicode (introdotto in ES6 / ES2015)
  • s: (nuovo in ES2018) abbreviazione di linea singola, causa il. per abbinare anche i nuovi caratteri di linea.

Le bandiere possono essere combinate e vengono aggiunte alla fine della stringa in letterali regex:

/hey/ig.test('HEy ') // 

o come secondo parametro con i costruttori di oggetti RegExp:

nuovo RegExp ('hey', 'ig'). test ('HEy') // 

Ispezionare una regex

Data una regex, puoi ispezionarne le proprietà:

  • fonte la stringa del modello
  • multilinea vero con la bandiera m
  • globale vero con la bandiera g
  • ignoreCase true con il flag i
  • lastIndex
/^(\w{3})$/i.source // "^ (\\ d {3}) (\\ w +) $"
/^(\w{3})$/i.multiline // false
/^(\w{3})$/i.lastIndex // 0
/^(\w{3})$/i.ignoreCase // true
/^(\w{3})$/i.global // false

Escaping

Questi personaggi sono speciali:

  • \
  • /
  • []
  • ()
  • {}
  • ?
  • +
  • *
  • |
  • .
  • ^
  • $

Sono speciali perché sono personaggi di controllo che hanno un significato nel modello di espressione regolare. Se si desidera utilizzarli all'interno del modello come caratteri corrispondenti, è necessario evitarli, anteponendo una barra rovesciata:

/ ^ \\ $ /
/ ^ \ ^ $ / // /^\^$/.test('^ ') 
/ ^ \ $$ / // /^\$$/.test('$ ') 

Confini delle stringhe

\ b e \ B ti consentono di verificare se una stringa è all'inizio o alla fine di una parola:

  • \ b corrisponde a una serie di caratteri all'inizio o alla fine di una parola
  • \ B corrisponde a un insieme di caratteri non all'inizio o alla fine di una parola

Esempio:

'I saw a bear'.match (/ \ bbear /) // Array ["bear"]
'I saw a beard'.match (/ \ bbear /) // Array ["bear"]
'Ho visto una barba'.match (/ \ bbear \ b /) // null
'cool_bear'.match (/ \ bbear \ b /) // null

Sostituisci, usando le espressioni regolari

Abbiamo già visto come verificare se una stringa contiene un modello.

Abbiamo anche visto come estrarre parti di una stringa in un array, abbinando un modello.

Vediamo come sostituire le parti di una stringa in base a un modello.

L'oggetto String in JavaScript ha un metodo replace (), che può essere utilizzato senza espressioni regolari per eseguire una singola sostituzione su una stringa:

"Ciao mondo!". Sostituisci ("mondo", "cane")
// Ciao cane!
"Il mio cane è un buon cane!". Sostituisci ('cane', 'gatto')
// Il mio gatto è un buon cane!

Questo metodo accetta anche un'espressione regolare come argomento:

"Ciao mondo!". Sostituisci (/ mondo /, 'cane') // Ciao cane!

L'uso del flag g è l'unico modo per sostituire più ricorrenze in una stringa in JavaScript vanilla:

"Il mio cane è un buon cane!". Sostituisci (/ dog / g, 'cat')
// Il mio gatto è un buon gatto!

I gruppi ci consentono di fare cose più fantasiose, come muoversi intorno a parti di una stringa:

"Ciao, mondo!". Sostituisci (/ (\ w +), (\ w +)! /, '$ 2: $ 1 !!!')
// "mondo: Ciao !!!"

Invece di usare una stringa puoi usare una funzione, per fare cose ancora più fantasiose. Riceverà un numero di argomenti come quello restituito da String.match (RegExp) o RegExp.exec (String), con un numero di argomenti che dipende dal numero di gruppi:

"Ciao, mondo!". Sostituisci (/ (\ w +), (\ w +)! /, (MatchedString, first, second) => {
  console.log (prima);
  console.log (secondo);
  return `$ {second.toUpperCase ()}: $ {first} !!!`
})
// "MONDO: Ciao !!!"

golosità

Si dice che le espressioni regolari siano avide per impostazione predefinita.

Cosa significa?

Prendi questa regex:

/\$(.+)\s?/

Dovrebbe estrarre un importo in dollari da una stringa:

/\$(.+)\s?/.exec('Questo costa $ 100 ') [1]
// 100

ma se abbiamo più parole dopo il numero, si spaventa:

/\$(.+)\s?/.exec('Questo costa $ 100 ed è inferiore a $ 200 ') [1] // 100 ed è inferiore a $ 200

Perché? Perché la regex dopo il simbolo $ corrisponde a qualsiasi carattere con. + E non si fermerà fino a quando non raggiunge la fine della stringa. Quindi, finisce perché \ s? rende lo spazio finale opzionale.

Per risolvere questo problema, dobbiamo dire al regex di essere pigro ed eseguire il minor numero possibile di corrispondenze. Possiamo farlo usando il? simbolo dopo il quantificatore:

/\$(.+?)\s/.exec('Questo costa $ 100 ed è inferiore a $ 200 ') [1]
// 100
Ho rimosso il? dopo \ s. Altrimenti corrispondeva solo al primo numero, poiché lo spazio era facoltativo

Così, ? significa cose diverse in base alla sua posizione, perché può essere sia un quantificatore che un indicatore della modalità pigra.

Lookaheads: abbina una stringa a seconda di ciò che la segue

Utilizza? = Per abbinare una stringa seguita da una sottostringa specifica:

/ Roger (? = Waters) /
/ Roger (? = Waters) /. Test ('Roger is my dog') // false
/ Roger (? = Waters) /. Test ('Roger è il mio cane e Roger Waters è un musicista famoso')
//vero

?! esegue l'operazione inversa, facendo corrispondere se una stringa non è seguita da una sottostringa specifica:

/ Roger (?! Waters) /
/ Roger (?! Waters) /. Test ('Roger is my dog') // true
/ Roger (?! Waters) /. Test ('Roger Waters è un musicista famoso')
// false

Lookbehinds: abbina una stringa a seconda di cosa la precede

Questa è una funzione ES2018.

I lookahead usano il simbolo? =. Lookbehinds use? <=.

/ (? <= Roger) Acque /
/ (? <= Roger) Waters / .test ('Pink Waters è il mio cane')
// false
/ (? <= Roger) Waters / .test ('Roger è il mio cane e Roger Waters è un musicista famoso')
//vero

Un lookbehind viene negato usando?

/ (? 
/ (? 
/ (? 

Espressioni regolari e Unicode

Il flag u è obbligatorio quando si lavora con stringhe Unicode. In particolare, ciò si applica quando potrebbe essere necessario gestire personaggi nei piani astrali (quelli che non sono inclusi nei primi 1600 caratteri Unicode).

Gli emoji sono un buon esempio, ma non sono i soli.

Se non aggiungi quel flag, questa semplice regex che dovrebbe corrispondere a un carattere non funzionerà, perché per JavaScript quell'emoji è rappresentato internamente da 2 caratteri (vedi Unicode in JavaScript):

/^.$/.test('a ') // 
/^.$/.test(' ') // 
/^.$/u.test(' ') // 

Quindi, usa sempre la bandiera u.

Unicode, proprio come i normali caratteri, gestisce gli intervalli:

/[a-z[/.test('a ') // 
/[1-9[/.test('1 ') // 
/[-[/u.test(' ') // 
/[-[/u.test(' ') // 

JavaScript controlla la rappresentazione del codice interno, quindi < < perché \ u1F436 <\ u1F43A <\ u1F98A. Controlla l'elenco Emoji completo per ottenere quei codici e per scoprire l'ordine (suggerimento: il selettore Emoji macOS ha alcuni emoji in un ordine misto, quindi non contare su di esso).

Esce dalla proprietà Unicode

Come abbiamo visto sopra, in un modello di espressione regolare puoi usare \ d per far corrispondere qualsiasi cifra, \ s per abbinare qualsiasi carattere che non sia uno spazio bianco, \ w per abbinare qualsiasi carattere alfanumerico e così via.

La proprietà Unicode sfugge è una funzionalità ES2018 che introduce una funzionalità molto interessante, estendendo questo concetto a tutti i caratteri Unicode introducendo \ p {} e la sua negazione \ P {}.

Qualsiasi carattere Unicode ha un set di proprietà. Ad esempio, Script determina la famiglia di lingue, ASCII è un valore booleano vero per i caratteri ASCII e così via. Puoi mettere questa proprietà tra parentesi grafiche e la regex verificherà che sia vera:

/^\p{ASCII}+$/u.test('abc ') // 
/^\p{ASCII}+$/u.test('ABC@ ') // 
/^\p{ASCII}+$/u.test('ABC ') // 

ASCII_Hex_Digit è un'altra proprietà booleana che controlla se la stringa contiene solo cifre esadecimali valide:

/^\p{ASCII_Hex_Digit}+$/u.test('0123456789ABCDEF ') //  /^\p{ASCII_Hex_Digit}+$/u.test('h') // 

Ci sono molte altre proprietà booleane, che puoi controllare aggiungendo il loro nome tra parentesi grafiche, tra cui Maiuscole, Minuscole, Spazio_bianco, Alfabetico, Emoji e altro:

/^\p{Lowercase}$/u.test('h ') // 
/^\p{Uppercase}$/u.test('H ') // 
/^\p{Emoji}+$/u.test('H ') // 
/^\p{Emoji}+$/u.test(' ') // 

Oltre a quelle proprietà binarie, è possibile controllare una qualsiasi delle proprietà dei caratteri unicode per abbinare un valore specifico. In questo esempio, controllo se la stringa è scritta in alfabeto greco o latino:

/^\p{Script=Greek}+$/u.test('ελληνικά ') // 
/^\p{Script=Latin}+$/u.test('hey ') // 

Ulteriori informazioni su tutte le proprietà che è possibile utilizzare direttamente sulla proposta.

Esempi

Supponendo che una stringa abbia un solo numero che devi estrarre, / \ d + / dovrebbe farlo:

'Test 123123329'.match (/ \ d + /)
// Array ["123123329"]

Abbina un indirizzo email

Un approccio semplicistico consiste nel controllare i caratteri non spaziali prima e dopo il segno @, usando \ S:

/(\S+)@(\S+)\.(\S+)/
/(\S+)@(\S+)\.(\S+)/.exec('copesc@gmail.com ')
//["copesc@gmail.com "," copesc "," gmail "," com "]

Questo è un esempio semplicistico, tuttavia, poiché molte e-mail non valide sono ancora soddisfatte da questa regex.

Cattura il testo tra virgolette doppie

Supponiamo di avere una stringa che contiene qualcosa tra virgolette doppie e di voler estrarre quel contenuto.

Il modo migliore per farlo è utilizzare un gruppo di acquisizione, perché sappiamo che la partita inizia e finisce con ", e possiamo facilmente scegliere come target, ma vogliamo anche rimuovere quelle citazioni dal nostro risultato.

Troveremo ciò di cui abbiamo bisogno nel risultato [1]:

const hello = 'Ciao "bel fiore"'
const result = /"([^'[*)"/.exec(hello)
// Matrice ["\" bel fiore \ "", "bel fiore"]

Ottieni il contenuto all'interno di un tag HTML

Ad esempio, ottenere il contenuto all'interno di un tag span, consentendo un numero qualsiasi di argomenti all'interno del tag:

/]*>(.*?)<\/span>/
/]*>(.*?)<\/span>/.exec('test ')
// nullo
/ ] *> (. *?) <\ / Span> /. Exec ( ' test ')
// [" test ", "test"]
/[*>(.*?)<\/span>/.exec(' test  ')
// [" test ", "test"]
Ti interessa imparare JavaScript? Ottieni il mio ebook gratuito su jshandbook.com