Condividi tramite

Espressioni regolari (C++)

  • Articolo

La libreria standard C++ supporta più grammatiche di espressioni regolari. In questo argomento vengono illustrate le varianti grammaticali disponibili quando si usano espressioni regolari.

Grammatica delle espressioni regolari

La grammatica dell'espressione regolare da usare è specificata dall'uso di uno dei valori di std::regex_constants::syntax_option_type enumerazione. Queste grammatiche delle espressioni regolari sono definite in std::regex_constants:

  • ECMAScript: è più vicino alla grammatica usata da JavaScript e dai linguaggi .NET.
  • basic: espressioni regolari POSIX basic o BRE.
  • extended: espressioni regolari POSIX extended o ERE.
  • awk: è extended, ma include più caratteri di escape per i caratteri non stampati.
  • grep: è basic, ma consente anche ai caratteri di nuova riga (\n) di separare le alternanze.
  • egrep: è extended, ma consente anche ai caratteri di nuova riga di separare le alternanze.

Per impostazione predefinita, se non viene specificata alcuna grammatica, ECMAScript viene utilizzato . È possibile specificare una sola grammatica.

È anche possibile applicare diversi flag:

  • icase: ignora maiuscole/minuscole quando corrisponde.
  • nosubs: ignora le corrispondenze contrassegnate( ovvero le espressioni tra parentesi); non vengono archiviate sostituzioni.
  • optimize: rendere più veloce la corrispondenza, a scapito possibile di un maggiore tempo di costruzione.
  • collate: usare sequenze di regole di confronto sensibili alle impostazioni locali, ad esempio intervalli del formato [a-z].

È possibile combinare zero o più flag con la grammatica per specificare il comportamento del motore delle espressioni regolari. Se vengono specificati solo flag, ECMAScript viene considerato come grammatica.

Elemento

Un elemento può essere uno dei seguenti:

  • Un carattere ordinario che corrisponde allo stesso carattere nella sequenza di destinazione.

  • Carattere '.' jolly che corrisponde a qualsiasi carattere nella sequenza di destinazione, ad eccezione di una nuova riga.

  • Espressione tra parentesi quadre del formato [expr], che corrisponde a un carattere o a un elemento delle regole di confronto nella sequenza di destinazione che si trova anche nel set definito dall'espressione expro della maschera [^expr], che corrisponde a un carattere o a un elemento delle regole di confronto nella sequenza di destinazione che non è nel set definito dall'espressione expr.

    L'espressione expr può contenere qualsiasi combinazione di quanto segue:

    • Un singolo carattere. Aggiunge il carattere al set definito da expr.

    • Intervallo di caratteri del formato ch1-ch2. Aggiunge i caratteri rappresentati dai valori nell'intervallo [ch1, ch2] chiuso al set definito da expr.

    • Classe di caratteri del formato [:name:]. Aggiunge i caratteri nella classe denominata al set definito da expr.

    • Classe di equivalenza del formato [=elt=]. Aggiunge gli elementi di ordinamento equivalenti a elt al set definito da expr.

    • Simbolo di confronto del formato [.elt.]. Aggiunge l'elemento di ordinamento elt al set definito da expr.

  • Un ancoraggio. L'ancoraggio ^ corrisponde all'inizio della sequenza di destinazione. L'ancoraggio $ corrisponde alla fine della sequenza di destinazione.

Gruppo di acquisizione del modulo (sottoespressione) o \(subexpression\) in basic e grep, che corrisponde alla sequenza di caratteri nella sequenza di destinazione corrispondente al criterio tra i delimitatori.

  • Escape di identità del formato \k, che corrisponde al carattere k nella sequenza di destinazione.

Esempi:

  • a corrisponde alla sequenza "a" di destinazione, ma non corrisponde alle sequenze "B"di destinazione , "b"o "c".

  • . corrisponde a tutte le sequenze di "a"destinazione , "B", "b"e "c".

  • [b-z] corrisponde alle sequenze "b" di destinazione e "c" ma non corrisponde alle sequenze "a" di destinazione o "B".

  • [:lower:] corrisponde alle sequenze "a"di destinazione , "b"e ma "c" non corrisponde alla sequenza di "B"destinazione .

  • (a) corrisponde alla sequenza "a" di destinazione e associa il gruppo capture 1 alla sottosequenza "a", ma non corrisponde alle sequenze "B"di destinazione , "b"o "c".

In , e , un elemento può anche essere un riferimento indietro del formato \dd, dove dd rappresenta un valore decimale N che corrisponde a una sequenza di caratteri nella sequenza di destinazione che corrisponde alla sequenza di caratteri corrispondente al gruppo di acquisizione Nth.grepbasicECMAScript

Ad esempio, (a)\1 corrisponde alla sequenza di "aa" destinazione perché il primo gruppo di acquisizione (e solo) corrisponde alla sequenza "a" iniziale e quindi \1 corrisponde alla sequenza "a"finale.

In ECMAScriptun elemento può anche essere uno dei seguenti:

  • Gruppo non capture del modulo (?: sottoespressione). Corrisponde alla sequenza di caratteri nella sequenza di destinazione a cui corrisponde il modello racchiuso tra i delimitatori.

  • Escape di formato di file limitato nel formato \f , , \r\n, \to \v. Questi caratteri corrispondono rispettivamente a un avanzamento modulo, una nuova riga, un ritorno a capo, una tabulazione orizzontale e una tabulazione verticale nella sequenza di destinazione.

  • Asserzione positiva del formato (= sottoespressione). Trova la corrispondenza con la sequenza di caratteri nella sequenza di destinazione corrispondente al criterio tra i delimitatori, ma non modifica la posizione di corrispondenza nella sequenza di destinazione.

  • Asserzione negativa della forma (! sottoespressione). Trova la corrispondenza con qualsiasi sequenza di caratteri nella sequenza di destinazione che non corrisponde al criterio tra i delimitatori e non modifica la posizione di corrispondenza nella sequenza di destinazione.

  • Sequenza di escape esadecimale del formato \xhh. Corrisponde a un carattere nella sequenza di destinazione rappresentato da due cifre esadecimali hh.

  • Sequenza di escape Unicode del formato \uhhhh. Corrisponde a un carattere nella sequenza di destinazione rappresentato da quattro cifre esadecimali hhhh.

  • Sequenza di escape del controllo del formato \ck. Corrisponde a un carattere di controllo denominato dal carattere k.

  • Asserzione del limite di parola del form\b. Si verifica quando la posizione corrente nella sequenza di destinazione si trova subito dopo un confine di parola.

  • Asserzione del limite di parola negativa del formato \B. Corrisponde quando la posizione corrente nella sequenza di destinazione non si trova immediatamente dopo un limite di parola.

  • Carattere di escape di dsw del formato \d, , \s\D, \S, \w, \W. Fornisce un nome breve per una classe di caratteri.

Esempi:

  • (?:a) corrisponde alla sequenza "a"di destinazione , ma "(?:a)\1" non è valida perché non è presente alcun gruppo di acquisizione 1.

  • (=a)a corrisponde alla sequenza "a"di destinazione . L'asserzione positiva corrisponde alla sequenza iniziale nella sequenza "a" di destinazione e la finale "a" nell'espressione regolare corrisponde alla sequenza iniziale nella sequenza "a" di destinazione.

  • (!a)a non corrisponde alla sequenza "a"di destinazione .

  • a\b. corrisponde alla sequenza "a~"di destinazione , ma non corrisponde alla sequenza "ab"di destinazione .

  • a\B. corrisponde alla sequenza "ab"di destinazione , ma non corrisponde alla sequenza "a~"di destinazione .

In awkun elemento può anche essere uno dei seguenti:

  • Escape del formato di file nel formato \\ , , \b\a, \f, \n\r, \t, o \v. Questi caratteri corrispondono rispettivamente a una barra rovesciata, un avviso, una nuova riga, un ritorno a capo, una tabulazione orizzontale e una tabulazione verticale nella sequenza di destinazione.

  • Sequenza di escape ottale del formato \ooo. Corrisponde a un carattere nella sequenza di destinazione la cui rappresentazione è il valore rappresentato da uno, due o tre cifre ottali ooo.

Repetition

Qualsiasi elemento diverso da un'asserzione positiva, un'asserzione negativa o da un ancoraggio può essere seguito da un numero di ripetizioni. Il tipo più generale di conteggio delle ripetizioni assume il formato {min,max}, o \{min,max\} in basic e .grep Un elemento seguito da questa forma di conteggio ripetizioni corrisponde ad almeno min occorrenze successive e non più del numero massimo di occorrenze successive massime di una sequenza che corrisponde all'elemento.

Ad esempio, a{2,3} corrisponde alla sequenza "aa" di destinazione e alla sequenza "aaa"di destinazione , ma non alla sequenza "a" di destinazione o alla sequenza di "aaaa"destinazione .

Un numero di ripetizioni può inoltre assumere uno dei seguenti formati:

  • {min} o \{min} in basic e grep. Equivalente a {min,min}.

  • {min,} o \{min,\} in basic e grep. Equivalente a {min,unbounded}.

  • *equivale a {0,unbounded}.

Esempi:

  • a{2} corrisponde alla sequenza "aa" di destinazione, ma non alla sequenza "a" di destinazione o alla sequenza "aaa"di destinazione.

  • a{2,}corrisponde alla sequenza di destinazione , alla sequenza "aa""aaa"di destinazione e così via, ma non corrisponde alla sequenza di "a"destinazione .

  • a*corrisponde alla sequenza ""di destinazione , alla sequenza di destinazione , alla sequenza "a""aa"di destinazione e così via.

Per tutte le grammatiche tranne basic e grep, un numero di ripetizioni può inoltre assumere uno dei seguenti formati:

  • ? è pari a {0,1}.

  • +equivale a {1,unbounded}.

Esempi:

  • a? corrisponde alla sequenza "" di destinazione e alla sequenza "a"di destinazione , ma non alla sequenza di "aa"destinazione .

  • a+corrisponde alla sequenza di destinazione , alla sequenza "a""aa"di destinazione e così via, ma non alla sequenza di ""destinazione .

In ECMAScript, tutte le forme di conteggio delle ripetizioni possono essere seguite dal carattere ? che definisce una ripetizione non greedy.

Concatenation

Gli elementi delle espressioni regolari, con o senza numeri di ripetizioni, possono essere concatenati per formare espressioni regolari più lunghe. L'espressione risultante corrisponde a una sequenza di destinazione che è una concatenazione delle sequenze a cui corrispondono i singoli elementi.

Ad esempio, a{2,3}b corrisponde alla sequenza "aab" di destinazione e alla sequenza "aaab"di destinazione , ma non corrisponde alla sequenza "ab" di destinazione o alla sequenza "aaaab"di destinazione .

Alternanza

In tutte le grammatiche delle espressioni regolari tranne basic e grep, un'espressione regolare concatenata può essere seguita dal carattere | (pipe) e da un'altra espressione regolare concatenata. Qualsiasi numero di espressioni regolari concatenate può essere combinato in questo modo. L'espressione risultante corrisponde a qualsiasi sequenza di destinazione corrispondente a uno o più espressioni regolari concatenate.

Quando più espressioni regolari concatenate corrispondono alla sequenza di destinazione, ECMAScript sceglie la prima delle espressioni regolari concatenate che corrispondono alla sequenza come corrispondenza, che verrà definita la prima corrispondenza. Le altre grammatiche delle espressioni regolari scelgono quella che ottiene la corrispondenza più lunga.

Ad esempio, ab|cd corrisponde alla sequenza "ab" di destinazione e alla sequenza "cd"di destinazione , ma non corrisponde alla sequenza "abd" di destinazione o alla sequenza "acd"di destinazione .

In grep e egrepè possibile usare un carattere di nuova riga (\n) per separare le alternanze.

Sottoespressione

In basic e in grep una sottoespressione è una concatenazione. Nelle altre grammatiche dell'espressione regolare una sottoespressione è un'alternanza.

Riepilogo grammaticale

Nella tabella riportata di seguito vengono riepilogate le funzionalità disponibili nelle diverse grammatiche dell'espressione regolare:

Elemento basic extended ECMAScript grep egrep awk
alternanza con | + + + +
alternanza con \n + +
ancoraggio + + + + + +
backreference + + +
espressione tra parentesi quadre + + + + + +
gruppo di acquisizione con () + + + +
gruppo di acquisizione con \(\) + +
sequenza di escape di controllo +
carattere di escape dsw +
escape formato file + +
sequenza di escape esadecimale +
escape di identità + + + + + +
asserzione negativa +
asserzione confine di parola negativa +
gruppo non Capture +
ripetizione non-greedy +
sequenza di escape ottale +
carattere ordinario + + + + + +
asserzione positiva +
ripetizione con {} + + + +
ripetizione con \{\} + +
ripetizione con * + + + + + +
ripetizione utilizzando ? e + + + + +
sequenza di escape Unicode +
carattere jolly + + + + + +
asserzione confine di parola +

Dettagli semantici

Ancora

Un ancoraggio corrisponde a una posizione nella stringa di destinazione, non a un carattere. Un ^ oggetto corrisponde all'inizio della stringa di destinazione e corrisponde $ alla fine della stringa di destinazione.

Riferimento indietro

Un backreference è una barra rovesciata seguita da un valore decimale N. Corrisponde al contenuto dell'ennesimo gruppo Capture. Il valore di N non deve essere maggiore del numero di gruppi Capture che precedono il backreference. In basic e in grep il valore di N è determinato dalla cifra decimale che segue la barra rovesciata. In ECMAScript il valore di N è determinato da tutte le cifre decimali che seguono immediatamente la barra rovesciata. Pertanto, in basic e in grep il valore di N non è mai maggiore di 9, anche se l'espressione regolare include più di nove gruppi Capture. In ECMAScript il valore di N è illimitato.

Esempi:

  • ((a+)(b+))(c+)\3 corrisponde alla sequenza "aabbbcbbb"di destinazione . Il riferimento \3 indietro corrisponde al testo nel terzo gruppo di acquisizione, ovvero ."(b+)" Non corrisponde alla sequenza "aabbbcbb"di destinazione.

  • (a)\2 non è valido.

  • (b(((((((((a))))))))))\10 ha significati diversi in basic e in ECMAScript. In basicil riferimento indietro è \1. Il riferimento indietro corrisponde al contenuto del primo gruppo di acquisizione ( ovvero quello che inizia con (b e termina con l'ultimo ) e viene prima del riferimento indietro) e la finale 0 corrisponde al carattere 0ordinario . In ECMAScriptil riferimento indietro è \10. Corrisponde al decimo gruppo Capture, ovvero quello più interno.

Espressione tra parentesi quadre

Un'espressione tra parentesi quadre definisce un set di caratteri ed elementi di collazione. Quando l'espressione tra parentesi quadre inizia con il carattere ^ , la corrispondenza ha esito positivo se nessun elemento nel set corrisponde al carattere corrente nella sequenza di destinazione. In caso contrario, la corrispondenza ha esito positivo se uno degli elementi nel set corrisponde al carattere corrente nella sequenza di destinazione.

Il set di caratteri può essere definito elencando qualsiasi combinazione di caratteri singoli, intervalli di caratteri, classi di caratteri, classi di equivalenza e simboli di collazione.

Gruppo di acquisizione

Il gruppo Capture contrassegna il proprio contenuto come singola unità nella grammatica dell'espressione regolare ed etichetta il testo di destinazione che corrisponde a tale contenuto. L'etichetta associata a ogni gruppo Capture è un numero che viene determinato contando le parentesi di apertura con cui vengono contrassegnati i gruppi Capture fino alla parentesi di apertura compresa con cui viene contrassegnato il gruppo Capture corrente. In questa implementazione il numero massimo di gruppi Capture è 31.

Esempi:

  • ab+ corrisponde alla sequenza "abb"di destinazione , ma non corrisponde alla sequenza "abab"di destinazione .

  • (ab)+ non corrisponde alla sequenza "abb"di destinazione , ma corrisponde alla sequenza "abab"di destinazione .

  • ((a+)(b+))(c+) corrisponde alla sequenza "aabbbc" di destinazione e associa il gruppo capture 1 alla sottosequenza "aabbb", il gruppo di acquisizione 2 con la sottosequenza "aa", il gruppo capture 3 con "bbb"e il gruppo capture 4 con la sottosequenza "c".

Classe di caratteri

Una classe di caratteri in un'espressione tra parentesi quadre aggiunge tutti i caratteri nella classe denominata al set di caratteri definito dall'espressione tra parentesi quadre. Per creare una classe di caratteri, usare [: seguito dal nome della classe , seguito da :].

Internamente, i nomi delle classi di caratteri vengono riconosciuti chiamando id = traits.lookup_classname. Un carattere ch appartiene a tale classe se traits.isctype(ch, id) restituisce true. Il modello regex_traits predefinito supporta i nomi di classe della tabella seguente.

Nome della classe Descrizione
alnum lettere minuscole, lettere maiuscole e cifre
alpha lettere minuscole e lettere maiuscole
blank Spazio o tabulazione
cntrl caratteri di escape formato file
digit Cifre
graph lettere minuscole, lettere maiuscole, cifre e punteggiatura
lower lettere minuscole
print lettere minuscole, lettere maiuscole, cifre, punteggiatura e spazio
punct punteggiatura
space space
upper caratteri maiuscoli
xdigit digits, a, bc, , de, f, A, , CDEBF
d uguale a digit
s uguale a space
w uguale a alnum

Intervallo di caratteri

Un intervallo di caratteri in un'espressione tra parentesi quadre consente di aggiungere tutti i caratteri dell'intervallo al set di caratteri definito dall'espressione tra parentesi quadre. Per creare un intervallo di caratteri, inserire il carattere '-' tra il primo e l'ultimo carattere nell'intervallo. Un intervallo di caratteri inserisce tutti i caratteri con un valore numerico maggiore o uguale al valore numerico del primo carattere e minore o uguale al valore numerico dell'ultimo carattere nel set. Si noti che questo set di caratteri aggiunti dipende dalla rappresentazione di caratteri specifica della piattaforma. Se il carattere '-' si verifica all'inizio o alla fine di un'espressione tra parentesi quadre o come primo o ultimo carattere di un intervallo di caratteri, rappresenta se stesso.

Esempi:

  • [0-7]rappresenta il set di caratteri { 0, 12, , 34, 56, , 7 }. Corrisponde alle sequenze "0"di destinazione , "1"e così via, ma non "a".

  • Nei sistemi che usano la codifica dei caratteri ASCII, [h-k] rappresenta il set di caratteri { h, i, k j}. Corrisponde alle sequenze "h"di destinazione , "i"e così via, ma non "\x8A" o "0".

  • Nei sistemi che usano la codifica dei caratteri EBCDIC, [h-k] rappresenta il set di caratteri { h, i'\x8A', '\x8B', '\x8C', '\x8E''\x90'j'\x8D''\x8F'k } (h è codificato come 0x88 e k è codificato come ).0x92 Corrisponde alle sequenze "h"di destinazione , "i", "\x8A"e così via, ma non "0".

  • [-0-24]rappresenta il set di caratteri { -, 01, 2, 4 }.

  • [0-2-] rappresenta il set di caratteri { 0, 1, 2} - .

  • Nei sistemi che usano la codifica dei caratteri ASCII, [+--] rappresenta il set di caratteri { + , - }.

Tuttavia, quando vengono utilizzati intervalli sensibili alle impostazioni locali, i caratteri in un intervallo vengono determinati dalle regole di confronto relative alle impostazioni locali. I caratteri che si trovano dopo il primo carattere della definizione dell'intervallo e prima dell'ultimo carattere della definizione dell'intervallo si trovano nel set. I due caratteri finali si trovano anch'essi nel set.

Elemento di confronto

Un elemento di ordinamento è una sequenza di più caratteri considerata come un carattere singolo.

Simbolo di confronto

Un simbolo di collazione in un'espressione tra parentesi quadre consente di aggiungere un elemento di collazione al set definito dall'espressione tra parentesi quadre. Per creare un simbolo di confronto, usare [. seguito dall'elemento di confronto, seguito da .]

Sequenza di escape del controllo

Una sequenza di escape del controllo è una barra rovesciata seguita dalla lettera 'c' seguita da una delle lettere 'a' attraverso 'z' o 'A' tramite 'Z'. Corrisponde a un carattere di controllo ASCII denominato dalla lettera. Ad esempio, "\ci" corrisponde alla sequenza "\x09"di destinazione , perché CTRL+I ha il valore 0x09.

Escape carattere DSW

Un carattere di escape dsw è il nome breve di una classe di caratteri, come illustrato nella tabella seguente.

Sequenza di escape Classe denominata Equivalent Classe denominata Default
\d [[:d:]] [[:digit:]]
\D [^[:d:]] [^[:digit:]]
\s [[:s:]] [[:space:]]
\S [^[:s:]] [^[:space:]]
\w [[:w:]] [a-zA-Z0-9_]*
\W [^[:w:]] [^a-zA-Z0-9_]*

*ASCII character set

Classe di equivalenza

Una classe di equivalenza in un'espressione tra parentesi quadre consente di aggiungere tutti i caratteri e gli elementi di collazione equivalenti all'elemento di collazione nella definizione della classe di equivalenza al set definito dall'espressione tra parentesi quadre.

Per creare una classe di equivalenza, usare [= seguito da un elemento di confronto seguito da =]. Internamente, due elementi di ordinamento elt1 e elt2 sono equivalenti se traits.transform_primary(elt1.begin(), elt1.end()) == traits.transform_primary(elt2.begin(), elt2.end()).

Escape formato file

Un escape del formato di file è costituito dalle consuete sequenze di escape dei caratteri del linguaggio C, , \\. \v\a\b\f\n\r\t Questi hanno i significati consueti, ovvero barra rovesciata, avviso, backspace, feed di moduli, nuova riga, ritorno a capo, tabulazioni orizzontali e tabulazioni verticali, rispettivamente. \a In ECMAScripte \b non sono consentiti. (\\ è consentito, ma è un escape di identità, non un escape del formato di file).

Sequenza di escape esadecimale

Una sequenza di escape esadecimale è una barra rovesciata seguita dalla lettera x seguita da due cifre esadecimali (0-9a-fA-F). Corrisponde a un carattere nella sequenza di destinazione con il valore specificato da due cifre.

Ad esempio, "\x41" corrisponde alla sequenza "a" di destinazione quando viene usata la codifica dei caratteri ASCII.

Escape dell'identità

Un escape di identità è una barra rovesciata seguita da un singolo carattere. Corrisponde a tale carattere. È obbligatorio quando il carattere ha un significato speciale. L'uso dell'escape di identità rimuove il significato speciale. Ad esempio:

  • a* corrisponde alla sequenza "aaa"di destinazione , ma non corrisponde alla sequenza "a*"di destinazione .

  • a\* non corrisponde alla sequenza "aaa"di destinazione , ma corrisponde alla sequenza "a*"di destinazione .

Il set di caratteri consentito in un escape di identità dipende dalla grammatica dell'espressione regolare, come illustrato nella tabella seguente.

Grammatica Caratteri di escape di identità consentiti
basic, grep { ( $ ^ * [ } \ ) { . }
extended, egrep { ( | ? + $ ^ \ . * ) { [ }
awk, extended plus { " / }
ECMAScript Tutti i caratteri tranne quelli che possono far parte di un identificatore. In genere, sono incluse lettere, cifre, $, _e sequenze di escape Unicode. Per altre informazioni, vedere Specifica ECMAScript del linguaggio.

Carattere individuale

Un singolo carattere in un'espressione tra parentesi quadre aggiunge tale carattere al set di caratteri definito dall'espressione tra parentesi quadre. In un punto qualsiasi di un'espressione tra parentesi quadre tranne all'inizio, un ^ oggetto rappresenta se stesso.

Esempi:

  • [abc] corrisponde alle sequenze "a"di destinazione , "b"e "c", ma non alla sequenza "d".

  • [^abc] corrisponde alla sequenza "d"di destinazione , ma non alle sequenze "a"di destinazione , "b"o "c".

  • [a^bc] corrisponde alle sequenze "a"di destinazione , "b", "c"e "^", ma non alla sequenza di "d"destinazione .

In tutte le grammatiche delle espressioni regolari ad eccezione ECMAScriptdi , se è ] il primo carattere che segue l'apertura [ o è il primo carattere che segue un oggetto iniziale ^, rappresenta se stesso.

Esempi:

  • []a non è valido perché non ] è necessario terminare l'espressione tra parentesi quadre.

  • []abc] corrisponde alle sequenze "a"di destinazione , "b", "c"e "]", ma non alla sequenza di "d"destinazione .

  • [^]abc] corrisponde alla sequenza "d"di destinazione , ma non alle sequenze "a"di destinazione , "b", "c"o "]".

In ECMAScriptusare \] per rappresentare il carattere ] in un'espressione tra parentesi quadre.

Esempi:

  • []a corrisponde alla sequenza di "a" destinazione perché l'espressione tra parentesi quadre è vuota.

  • [\]abc] corrisponde alle sequenze "a"di destinazione , "b", "c"e "]" ma non alla sequenza "d"di destinazione .

Asserzione negativa

Un'asserzione negativa corrisponde solo al proprio contenuto. Non utilizza caratteri nella sequenza di destinazione.

Ad esempio, (!aa)(a*) corrisponde alla sequenza "a" di destinazione e associa il gruppo capture 1 alla sottosequenza "a". Non corrisponde alla sequenza di destinazione o alla sequenza "aa" "aaa"di destinazione.

Asserzione limite parola negativa

Un'asserzione del limite di parola negativa corrisponde se la posizione corrente nella stringa di destinazione non è immediatamente dopo un limite di parola.

Gruppo non di acquisizione

Un gruppo non capture contrassegna il contenuto come una singola unità nella grammatica delle espressioni regolari, ma non etichetta il testo di destinazione.

Ad esempio, (a)(?:b)*(c) corrisponde al testo di destinazione "abbc" e associa il gruppo capture 1 alla sottosequenza "a" e al gruppo di acquisizione 2 con la sottosequenza "c".

Ripetizione non greedy

In una ripetizione non-greedy viene utilizzata la sottosequenza più breve della sequenza di destinazione corrispondente al modello. In una ripetizione greedy viene utilizzata quella più lunga. Ad esempio, (a+)(a*b) corrisponde alla sequenza "aaab"di destinazione .

Quando viene usata una ripetizione non greedy, associa il gruppo capture 1 alla sottosequenza "a" all'inizio della sequenza di destinazione e al gruppo di acquisizione 2 alla sottosequenza "aab" alla fine della sequenza di destinazione.

Quando viene usata una corrispondenza greedy, associa il gruppo capture 1 alla sottosequenza "aaa" e al gruppo capture 2 con la sottosequenza "b".

Sequenza di escape ottale

Una sequenza di escape ottale è una barra rovesciata seguita da una, due o tre cifre ottali (0-7). Corrisponde a un carattere nella sequenza di destinazione con il valore specificato da tali cifre. Se tutte le cifre sono 0, la sequenza non è valida.

Ad esempio, \101 corrisponde alla sequenza "a" di destinazione quando viene usata la codifica dei caratteri ASCII.

Carattere ordinario

Un carattere ordinario è qualsiasi carattere valido che non ha un significato speciale nella grammatica corrente.

In ECMAScript i seguenti caratteri hanno significati speciali:

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

In basic e in grep i seguenti caratteri hanno significati speciali:

  • . [ \

Anche in basic e grep, i caratteri seguenti hanno significati speciali quando vengono usati in un contesto specifico:

  • * ha un significato speciale in tutti i casi tranne quando è il primo carattere in un'espressione regolare o il primo carattere che segue un'espressione ^ regolare o quando è il primo carattere di un gruppo di acquisizione o il primo carattere che segue un'iniziale ^ in un gruppo di acquisizione.

  • ^ ha un significato speciale quando è il primo carattere di un'espressione regolare.

  • $ ha un significato speciale quando è l'ultimo carattere di un'espressione regolare.

In extended, egrep e in awk i seguenti caratteri hanno significati speciali:

  • . [ \ ( * + ? { |

Anche in extended, egrepe awk, i caratteri seguenti hanno significati speciali quando vengono usati in un particolare contesto.

  • ) ha un significato speciale quando corrisponde a un precedente (

  • ^ ha un significato speciale quando è il primo carattere di un'espressione regolare.

  • $ ha un significato speciale quando è l'ultimo carattere di un'espressione regolare.

Un carattere ordinario corrisponde allo stesso carattere nella sequenza di destinazione. Per impostazione predefinita, significa che la corrispondenza ha esito positivo se i due caratteri sono rappresentati dallo stesso valore. In una corrispondenza senza distinzione tra maiuscole e minuscole ch0 e ch1 corrispondono se traits.translate_nocase(ch0) == traits.translate_nocase(ch1). In una corrispondenza sensibile alle impostazioni locali ch0 e ch1 corrispondono se traits.translate(ch0) == traits.translate(ch1).

Asserzione positiva

Un'asserzione positiva corrisponde al contenuto, ma non utilizza caratteri nella sequenza di destinazione.

Esempi:

  • (=aa)(a*) corrisponde alla sequenza "aaaa" di destinazione e associa il gruppo capture 1 alla sottosequenza "aaaa".

  • (aa)(a*) corrisponde alla sequenza "aaaa" di destinazione e associa il gruppo capture 1 alla sottosequenza "aa" all'inizio della sequenza di destinazione e al gruppo di acquisizione 2 con la sottosequenza "aa" alla fine della sequenza di destinazione.

  • (=aa)(a)|(a) corrisponde alla sequenza "a" di destinazione e associa il gruppo capture 1 a una sequenza vuota (perché l'asserzione positiva non è riuscita) e acquisisce il gruppo 2 con la sottosequenza "a". Corrisponde anche alla sequenza "aa" di destinazione e associa il gruppo capture 1 alla sottosequenza "aa" e al gruppo di acquisizione 2 con una sequenza vuota.

Sequenza di escape Unicode

Una sequenza di escape Unicode è una barra rovesciata seguita dalla lettera 'u' seguita da quattro cifre esadecimali (0-9a-fA-F). Corrisponde a un carattere nella sequenza di destinazione con il valore specificato da quattro cifre. Ad esempio, \u0041 corrisponde alla sequenza "a" di destinazione quando viene usata la codifica dei caratteri ASCII.

Carattere jolly

Un carattere jolly corrisponde a qualsiasi carattere nella sequenza di destinazione, escluso il carattere di nuova riga.

Limite di Parola

Un confine di parola si verifica nelle seguenti situazioni:

  • Il carattere corrente si trova all'inizio della sequenza di destinazione ed è uno dei caratteri alfanumerici A-Za-z0-9_

  • La posizione corrente del carattere è oltre la fine della sequenza di destinazione e l'ultimo carattere della sequenza di destinazione è uno dei caratteri alfanumerici.

  • Il carattere corrente è uno dei caratteri della parola e il carattere precedente non è.

  • Il carattere corrente non è uno dei caratteri della parola e il carattere precedente è.

Asserzione limite parola

Un'asserzione confine di parola si verifica quando la posizione corrente nella stringa di destinazione si trova subito dopo un confine di parola.

Corrispondenza e ricerca

Affinché un'espressione regolare corrisponda a una sequenza di destinazione, l'intera espressione regolare deve corrispondere all'intera sequenza di destinazione. Ad esempio, l'espressione bcd regolare corrisponde alla sequenza "bcd" di destinazione ma non corrisponde alla sequenza "abcd" di destinazione né alla sequenza di "bcde"destinazione .

Perché una ricerca di espressione regolare abbia esito positivo, è necessario che esista una sottosequenza in qualche punto della sequenza di destinazione corrispondente all'espressione regolare. La ricerca in genere trova la sottosequenza corrispondente più a sinistra.

Esempi:

  • Una ricerca dell'espressione bcd regolare nella sequenza "bcd" di destinazione ha esito positivo e corrisponde all'intera sequenza. La stessa ricerca nella sequenza "abcd" di destinazione ha esito positivo e corrisponde agli ultimi tre caratteri. La stessa ricerca nella sequenza "bcde" di destinazione ha esito positivo e corrisponde ai primi tre caratteri.

  • Una ricerca dell'espressione bcd regolare nella sequenza "bcdbcd" di destinazione ha esito positivo e corrisponde ai primi tre caratteri.

Se sono presenti più sottosequenze che corrispondono in una posizione nella sequenza di destinazione, esistono due modi per scegliere il criterio di corrispondenza.

Prima corrispondenza consente di scegliere la sottosequenza trovata per prima quando viene trovata la corrispondenza dell'espressione regolare.

Corrispondenza più lunga consente di scegliere la sottosequenza più lunga tra quelle che corrispondono in tale posizione. Se sono presenti più sottosequenze con lunghezza massima, la corrispondenza più lunga sceglie quella trovata per prima.

Ad esempio, quando viene usata la prima corrispondenza, una ricerca dell'espressione b|bc regolare nella sequenza "abcd" di destinazione corrisponde alla sottosequenza "b" perché il termine sinistro dell'alternanza corrisponde a tale sottosequenza, pertanto la prima corrispondenza non prova il termine di destra dell'alternanza. Quando viene usata la corrispondenza più lunga, la stessa ricerca corrisponde "bc" perché "bc" è più lunga di "b".

Una corrispondenza parziale ha esito positivo se la corrispondenza raggiunge la fine della sequenza di destinazione senza errori, anche se non ha raggiunto la fine dell'espressione regolare. Di conseguenza, dopo l'esito positivo di una corrispondenza parziale, l'aggiunta di caratteri alla sequenza di destinazione potrebbe causare l'esito negativo di una corrispondenza parziale successiva. Tuttavia, dopo che una corrispondenza parziale ha esito negativo, l'aggiunta di caratteri alla sequenza di destinazione non può causare un esito positivo di una corrispondenza parziale successiva. Ad esempio, con una corrispondenza parziale, ab corrisponde alla sequenza "a" di destinazione ma non "ac"a .

Flag di formato

ECMAScript Regole di formato Regole dei formati sed Testo di sostituzione
$& & Sequenza di caratteri corrispondente all'intera espressione regolare: [match[0].first, match[0].second)
$$ $
\& &
$`" (segno di dollaro seguito da virgolette indietro) Sequenza di caratteri che precede la sottosequenza corrispondente all'espressione regolare: [match.prefix().first, match.prefix().second)
$'" (segno di dollaro seguito da virgolette in avanti) Sequenza di caratteri che segue la sottosequenza corrispondente all'espressione regolare: [match.suffix().first, match.suffix().second)
$n \n Sequenza di caratteri che corrisponde al gruppo di acquisizione nella posizione n, dove n è un numero compreso tra 0 e 9: [match[n].first, match[n].second)
\\n \n
$nn Sequenza di caratteri che corrisponde al gruppo di acquisizione nella posizione nn, dove nn è un numero compreso tra 10 e 99: [match[nn].first, match[nn].second)

Vedi anche

Panoramica sulla libreria standard C++