English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Corrispondenza zero-width dell'espressione regolare:
La corrispondenza zero-width dell'espressione regolare è una difficoltà, quindi questa sezione si concentra sull'analisi del principio di corrispondenza. La corrispondenza zero-width dell'espressione regolare ha altri nomi, come "visita" o "ricerca preventiva" ecc., ma questi non sono il nostro punto di attenzione.
1. Concetto di base:
La corrispondenza zero-width, come il suo nome suggerisce, è una corrispondenza zero-width, la cui corrispondenza non viene salvata nel risultato della corrispondenza, il risultato finale della corrispondenza è solo una posizione.
Il suo scopo è aggiungere una condizione limitativa alla posizione specificata, in modo che i caratteri prima o dopo la posizione devono soddisfare la condizione limitativa per far sì che l'espressione del carattere dell'espressione regolare corrisponda con successo.
Attenzione: qui si intende che l'espressione subordinata non è solo l'espressione racchiusa tra parentesi, ma qualsiasi unità di corrispondenza dell'espressione regolare.
javascript supporta solo la corrispondenza zero-width lookahead, e la corrispondenza zero-width lookahead può essere divisa in corrispondenza zero-width lookahead positiva e negativa.
Esempio di codice:
Esempio di codice uno:
var str="abZW863"; var reg=/ab(?=[A-Z])/; console.log(str.match(reg));
Nel codice sopra, il significato dell'espressione regolare è: corrisponde alla stringa "ab" seguita da qualsiasi lettera maiuscola. Il risultato finale della corrispondenza è "ab", perché la corrispondenza zero-width "(?=[A-Z])" non corrisponde a nessun carattere, serve solo per stabilire che la posizione corrente deve essere seguita da una lettera maiuscola.
Esempio di codice due:
var str="abZW863"; var reg=/ab(?![A-Z])/; console.log(str.match(reg));
Nel codice sopra, il significato dell'espressione regolare è: corrisponde alla stringa "ab" non seguita da nessuna lettera maiuscola. L'espressione regolare non ha corrisposto a nessun carattere, perché nella stringa, dopo "ab" c'è una lettera maiuscola.
2. Principio di corrispondenza:
Il codice sopra è solo un modo per introdurre concettualmente come le corrispondenze zero-width si corrispondono.
Di seguito, illustrerò separatamente come le corrispondenze zero-width positive e negative si corrispondono attraverso il metodo di principio di corrispondenza.
1. Corrispondenza zero-width positiva:
Esempio di codice:
var str="<div>antzone"; var reg=/^(?=<)<[^>]+>\w+/; console.log(str.match(reg));
Il processo di abbinamento è il seguente:
Prima di tutto, il "^" dell'espressione regolare ottiene il controllo, inizia la corrispondenza dal posizione 0, corrisponde alla posizione 0, corrisponde con successo, quindi il controllo viene trasferito a "(?=<)", poiché "^" è zero-width, quindi "(?=<)" inizia anche dalla posizione 0 per corrispondere, richiede che la posizione corrente sia il carattere '<' sulla destra, la posizione 0 è esattamente il carattere '<' sulla destra, corrisponde con successo, quindi il controllo viene trasferito a '<', poiché "(?=<)" è zero-width, inizia anche dalla posizione 0 per corrispondere, quindi corrisponde con successo, il processo di corrispondenza successivo non sarà descritto.
2. Affermazione di lunghezza zero negativa:
Esempio di codice:
var str="abZW863ab88"; var reg=/ab(?![A-Z])/g; console.log(str.match(reg));
Il processo di abbinamento è il seguente:
Prima di tutto, il carattere "a" dell'espressione regolare ottiene il controllo, inizia a abbinare dalla posizione 0, abbinamento del carattere "a" con successo, poi il controllo viene trasferito a "b", inizia a abbinare dalla posizione 1, abbinamento del carattere "b" con successo, poi il controllo viene trasferito a "(?![A-Z])", inizia a abbinare dalla posizione 2, richiede che la posizione a destra non possa essere qualsiasi lettera maiuscola, e la posizione a destra è la lettera maiuscola "Z", abbinamento fallito, poi il controllo viene nuovamente restituito al carattere "a", e inizia a abbinare dalla posizione 1, abbinamento fallito, poi il controllo viene nuovamente restituito al carattere "a", inizia a abbinare dalla posizione 2, abbinamento fallito, e così via, fino a che inizia a abbinare con successo dalla posizione 7, poi il controllo viene trasferito a "b", inizia a abbinare dalla posizione 8, abbinamento con successo, poi il controllo viene nuovamente trasferito a "(?![A-Z])", inizia a abbinare dalla posizione 9, stabilisce che la posizione a destra non possa essere una lettera maiuscola, abbinamento con successo, ma non abbinerà veramente il carattere, quindi il risultato dell'abbinamento finale è "ab".
Di seguito sono riportati supplementi
La dichiarazione di lunghezza zero è un metodo dell'espressione regolare, l'espressione regolare nella scienza informatica si riferisce a una stringa singola utilizzata per descrivere o abbinare una serie di stringhe che soddisfano determinate regole sintattiche.
Definizione e spiegazione
La dichiarazione di lunghezza zero è un metodo dell'espressione regolare
L'espressione regolare nella scienza informatica si riferisce a una stringa singola utilizzata per descrivere o abbinare una serie di stringhe che soddisfano determinate regole sintattiche. Nella maggior parte degli editor di testo e altri strumenti, l'espressione regolare viene spesso utilizzata per cercare e / o sostituire il contenuto del testo che soddisfa un determinato modello. Molti linguaggi di programmazione supportano l'uso dell'espressione regolare per operazioni su stringhe. Ad esempio, in Perl è integrato un motore di espressione regolare potente. Il concetto di espressione regolare è stato reso popolare dai software di strumenti Unix (ad esempio sed e grep). L'espressione regolare viene solitamente abbreviata in “regex”, singolare regexp, regex, plurale regexps, regexes, regexen.
Affermazione di lunghezza zero
Usato per cercare qualcosa prima o dopo di contenuti specifici (ma non inclusi in essi), ossia come \b, ^, $ che specificano una posizione che deve soddisfare determinate condizioni (cioè affermazioni), quindi sono anche chiamati affermazioni di lunghezza zero. È meglio spiegare con esempi: l'affermazione viene utilizzata per dichiarare un fatto che deve essere vero. Nella regex, la corrispondenza continua solo se l'affermazione è vera.
(?=exp) è anche chiamato affermazione di lunghezza zero前瞻先行，che afferma che la posizione in cui si trova può essere corrisponduta dall'espressione exp. Ad esempio, \b(?=re)\w+\b corrisponde alla parte posteriore della parola che inizia con re (eccetto re), come nella ricerca reading a book. corrisponde a ading.
var reg = new Regex(@"\w+(?=ing)"); var str = "muing"; Console.WriteLine(reg.Match(str).Value); // restituisce 'mu'
(?<=exp) è anche chiamato affermazione di lunghezza zero前瞻后发，che afferma che la posizione in cui si trova può essere corrisponduta dall'espressione exp. Ad esempio, \b\w+(?<=ing\b) corrisponde alla parte iniziale della parola che termina con ing (eccetto ing), ad esempio nella ricerca I am reading. corrisponde a read.
Se si desidera aggiungere una virgola ogni tre cifre in un numero molto lungo (ovviamente partendo dalla destra), si può cercare la parte che deve essere aggiunta davanti e dentro: ((?=\d)\d{3})+\b, utilizzandolo per cercare in 1234567890 il risultato è 234567890.
L'esempio seguente utilizza entrambi questi assertivi: '(?<=\s)\d+(?=\s)' corrisponde ai numeri intervallati da spazi (riassumendo, non includono questi spazi).
Affermazione di lunghezza zero negativa
Abbiamo menzionato in precedenza come cercare caratteri non presenti o non appartenenti a una classe di caratteri (opposto). Ma cosa succede se vogliamo solo assicurarci che un carattere non sia presente, ma non vogliamo matchingarlo? Ad esempio, se vogliamo cercare parole che contengono la lettera q ma non seguita dalla lettera u, possiamo provare a fare così:
La regex \b\w*q[^u]\w*\b corrisponde a parole che contengono la lettera q seguita da una lettera diversa da u. Tuttavia, se si esegue un test più approfondito (o se si è sufficientemente acuti di mente per notarlo direttamente), si scopre che se q appare alla fine della parola, come in Iraq, Benq, questa espressione fallisce. Questo perché [^u] deve sempre corrispondere a un carattere, quindi se q è l'ultimo carattere della parola, il [^u] dopo di esso corrisponderà al carattere di separazione della parola successiva (che potrebbe essere uno spazio, un punto o altro), e il \w*\b dopo di esso corrisponderà alla parola successiva, quindi \b\w*q[^u]\w*\b corrisponderà all'intera frase Iraq fighting. La negazione di affermazione di lunghezza zero risolve questo problema, poiché corrisponde solo a una posizione senza consumare alcun carattere. Ora, possiamo risolvere il problema in questo modo: \b\w*q(?!u)\w*\b.
L'affermazione negativa proattiva di lunghezza zero (?!exp), afferma che la posizione in cui si trova non può corrispondere all'espressione exp. Ad esempio: \d{3}(?!\d) corrisponde a tre cifre consecutive e queste cifre non possono essere seguite da altre cifre; \b((?!abc)\w)+\b corrisponde a una parola che non contiene la sequenza di caratteri consecutivi abc.
Allo stesso modo, possiamo utilizzare (?<!exp), affermazione retroattiva negativa di lunghezza zero, per affermare che la posizione in cui si trova non può corrispondere all'espressione exp: (?<![a-z])\d{7} corrisponde a sette cifre consecutive che non sono lettere minuscole precedenti.
Un esempio più complesso: (?<=<(\w+)>).*(?=<\/\1>) corrisponde al contenuto all'interno di un etichetta HTML semplice senza attributi. (<?=(\w+)>) specifica un prefisso: una parola tra parentesi angolari (ad esempio potrebbe essere <b>), seguita da .* (una stringa arbitraria), infine un suffisso (?=<\/\1>). Nota il\/ nel suffisso, che utilizza la sostituzione di caratteri discussa in precedenza; \1 è un richiamo inverso, che si riferisce al primo gruppo catturato, il contenuto matchato da (\w+). Quindi, se il prefisso è effettivamente <b>, il suffisso sarà </b>. L'espressione intera corrisponde al contenuto tra <b> e </b> (ricorda, escludendo il prefisso e il suffisso stessi).
Le precedenti sono un po' complicate. Arriviamo a qualcosa di supplementare:
Le affermazioni vengono utilizzate per dichiarare un fatto che dovrebbe essere vero. In un'espressione regolare, la corrispondenza continua solo se l'affermazione è vera.
Le prossime quattro vengono utilizzate per cercare qualcosa prima o dopo determinati contenuti (ma non includono questi contenuti), ossia come \b, ^, $ per specificare una posizione che deve soddisfare determinate condizioni (cioè affermazioni), quindi sono anche chiamate affermazioni di lunghezza zero. Meglio spiegare con esempi:
(?=exp) è anche chiamato affermazione proattiva di lunghezza zero, che afferma che la posizione in cui si trova può corrispondere all'espressione exp. Ad esempio \b\w+(?=ing\b) corrisponde alla parte anteriore di una parola che termina con ing (tranne ing stesso), come nella ricerca I'm singing while you're dancing, corrisponde a sing e danc。
(?<=exp) è anche chiamato affermazione retroattiva di lunghezza zero, che afferma che la posizione in cui si trova può corrispondere all'espressione exp. Ad esempio (?<=\bre)\w+\b corrisponde alla parte posteriore di una parola che inizia con re (tranne re stesso), ad esempio nella ricerca di reading a book, corrisponde a ading。
Se vuoi aggiungere una virgola ogni tre cifre in un numero molto lungo (ovviamente da destra a sinistra), puoi cercare la parte da aggiungere davanti e dentro in questo modo: ((?<=\d)\d{3})*\b, utilizzalo per cercare in 1234567890 e il risultato è 234567890。
L'esempio seguente utilizza entrambi questi assertivi: '(?<=\s)\d+(?=\s)' corrisponde ai numeri intervallati da spazi (riassumendo, non includono questi spazi).
Aggiunta due:
Recentemente, per elaborare il codice sorgente dei file html, è stato necessario effettuare una ricerca e una sostituzione con espressioni regolari. Prendendo questa occasione, ho deciso di studiare il sistema di espressioni regolari, anche se prima l'avevo usato, ogni volta solo per superare la situazione temporaneamente. Durante lo studio, ho incontrato molti problemi, specialmente le affermazioni di lunghezza zero (qui vorrei lamentarmi, su Internet ci sono sempre contenuti copiati e incollati, ho visto molte cose ripetute, sigh!!!), quindi ho deciso di scrivere il mio punto di vista qui, per facilitare la consultazione in futuro!
Cos'è la predizione anticipata di lunghezza zero? Vedi la spiegazione ufficiale su msdn
(?= Sotto-espressione)
(Predizione anticipata di lunghezza zero.) La corrispondenza continua solo quando la sotto-espressione in questa posizione è corrispondente alla destra. Ad esempio, '\w+(?=\d)' corrisponde a una parola seguita da un numero, ma non al numero stesso.
Esempio classico: per ottenere il contenuto prima di 'ing' in una parola che finisce con 'ing'
var reg = new Regex(@"\w+(?=ing)"); var str = "muing"; Console.WriteLine(reg.Match(str).Value); // restituisce 'mu'
Questo è un esempio che si può trovare ovunque su Internet, fino a questo punto, forse hai capito che è stato restituito il contenuto prima dell'espressione exp.
Guarda il codice seguente
var reg = new Regex(@"a(?=b)c"); var str = "abc"; Console.WriteLine(reg.IsMatch(str)); // restituisce false
Perché viene restituito false?
In realtà, la definizione ufficiale di msdn l'ha già detta, ma è solo che l'ha detta in modo ufficiale. Ecco un punto chiave che dobbiamo notare: questa posizione. Ha ragione, è una posizione e non un carattere. Ora, combinando la definizione ufficiale e il primo esempio per comprendere il secondo esempio:
Poiché dopo 'a' c'è 'b', viene restituito il contenuto corrispondente 'a' (come sappiamo dal primo esempio, viene restituito solo 'a' e non il contenuto corrispondente all'espressione exp), quindi la parte 'a(?=b)' di 'a(?=b)c' è stata risolta, ora è necessario risolvere il problema della corrispondenza di 'c'. Da dove iniziare a corrispondere 'c' nella stringa 'abc'? Considerando la definizione ufficiale, si sa che inizia dalla posizione della sotto-espressione verso destra, quindi inizia dalla posizione di 'b', ma 'b' non corrisponde alla parte rimanente 'c' di 'a(?=b)c', quindi 'abc' non corrisponde a 'a(?=b)c'.
Allora, se si vuole fare una corrispondenza con l'alto, come dovrebbe essere scritto lo script regolare?
La risposta è: a(?=b)bc
Certo, qualcuno potrebbe dire che corrisponde direttamente abc, perché dobbiamo fare tutto questo? Certamente non dobbiamo farlo, ma solo per spiegare esattamente cosa sia l'affermazione di previsione di lunghezza zero in avanti! Gli altri affermazioni di lunghezza zero sono dello stesso principio!
Aggiunta tre
(?=exp): affermazione di previsione di lunghezza zero in avanti, afferma che la posizione posteriore può corrispondere all'espressione exp。
#Corrisponde alla fine di _path, il risultato è product
'product_path'.scan /(product)(?=_path)/
(?<=exp): affermazione di previsione di lunghezza zero in avanti, afferma che la posizione anteriore può corrispondere all'espressione exp
#Corrisponde all'inizio di name: e il risultato è wangfei
'name:wangfei'.scan /(?<=name:)(wangfei)/ #wangfei
(?!exp): affermazione di previsione di lunghezza zero in avanti, afferma che la posizione posteriore non può corrispondere all'espressione exp.
#Corrisponde alla fine non di _path
'product_path'.scan /(product)(?!_path)/ #nil
#Corrisponde alla fine non di _url
'product_path'.scan /(product)(?!_url)/ #product
(?<!exp): affermazione di negazione di lunghezza zero in avanti per affermare che la posizione anteriore non può corrispondere all'espressione exp
#Corrisponde all'inizio non di name:
'name:angelica'.scan /(?<!name:)(angelica)/ #nil
#Corrisponde all'inizio non di nick_name:
'name:angelica'.scan /(?<!nick_name:)(angelica)/#angelica
Anche io sono stanco di questa cosa, aspetterò qualcosa di meglio da condividere, oggi mi lavo e vado a dormire