Sintassi delle espressioni regolari 2 (RE2.h)

  • Articolo

Le espressioni regolari sono una notazione per la descrizione dei set di stringhe di caratteri. Quando una stringa si trova nel set descritto da un'espressione regolare, si dice che l'espressione regolare corrisponde alla stringa.

L'espressione regolare più semplice è un carattere letterale singolo. Fatta eccezione per i metacaratteri, come *+?()|, i caratteri corrispondono a se stessi. Per trovare una corrispondenza con un metacarattere, eseguirne l'escape con una barra rovesciata. Ad esempio, \+ corrisponde al valore letterale più carattere.

Due espressioni regolari possono essere modificate o concatenate per formare una nuova espressione regolare: se e1 corrisponde a s ed e2 corrisponde a t, e1 | e2 corrisponde a s o t e e1e2 corrisponde a st.

I metacaratteri *, +e ? sono operatori di ripetizione: e1* corrisponde a una sequenza di zero o più stringhe (possibilmente diverse), ognuna delle quali corrisponde a e1; e1+ corrisponde a uno o più elementi; e1? corrisponde a zero o uno.

La precedenza dell'operatore, dall'associazione più debole a quella più forte, è la seguente:

  • Alternanza
  • Concatenazione
  • operatori di ripetizione

Le parentesi esplicite possono essere usate per forzare significati diversi, come nelle espressioni aritmetiche. Alcuni esempi: ab|cd equivale a (ab)|(cd) ; ab\ equivale a a(b\).

La sintassi descritta finora è in gran parte presa dalla tradizionale sintassi delle espressioni regolari egrep di Unix. Questo subset è sufficiente per descrivere tutti i linguaggi regolari. Un linguaggio normale è un set di stringhe che possono essere confrontate in un singolo passaggio del testo usando solo una quantità fissa di memoria. Le più recenti strutture di espressioni regolari (in particolare Perl e i linguaggi che lo hanno copiato) hanno aggiunto molti nuovi operatori e sequenze di escape. Queste modifiche rendono le espressioni regolari più concise e talvolta più criptiche, ma non più potenti.

Questa pagina elenca la sintassi delle espressioni regolari accettate da RE2.

Elenca anche una sintassi accettata da PCRE, PERL e VIM.

Tabelle della sintassi

Tipi di espressioni a caratteri singoli Esempi
qualsiasi carattere, eventualmente includendo newline (s=true) .
classe di caratteri [xyz]
classe di carattere negativa [^xyz]
classe di caratteri di Perl (collegamento) \d
classe di carattere di Perl negati \D
classe di caratteri ASCII (collegamento) [[:alpha:]]
classe di carattere ASCII negati [[:^alpha:]]
classe di caratteri Unicode (nome di una lettera) \pN
classe di carattere Unicode negati \p{Greek}
classe di caratteri Unicode negati (nome di una lettera) \PN
classe di caratteri Unicode negati \P{Greek}
  Costrutti
xy x seguito da y
x|y x o y (x preferibile)
  Ripetizioni
x* zero o più x, più è preferibile
x+ una o più x, più è preferibile
x? zero o una x, una è preferibile
x{n,m} n o n+1 o ... o m x, più è preferibile
x{n,} n o più x, più è preferibile
x{n} esattamente n x
X*? zero o più x, meno è preferibile
x+? una o più x, meno è preferibile
x?? zero o una x, zero è preferibile
x{n,m}? n o n+1 o ... o m x, meno è preferibile
x{n,}? n o più x, meno è preferibile
x{n}? esattamente n x
x{} (≡ x*) (NON SUPPORTATO) VIM
x{-} (≡ x*?) (NON SUPPORTATO) VIM
x{-n} (≡ x{n}?) (NON SUPPORTATO) VIM
x= (≡ x?) (NON SUPPORTATO) VIM

Restrizione di implementazione: i moduli x{n,m}di conteggio , x{n,}e x{n} rifiutano i moduli che creano un numero di ripetizioni minimo o massimo superiore a 1000. Le ripetizioni illimitate non sono soggete a questa limitazione.

  Ripetizioni possessive
x*+ zero o più x, possessiva (NON SUPPORTATO)
x++ una o più x, possessiva (NON SUPPORTATO)
x?+ zero o una x, possessiva (NON SUPPORTATO)
x{n,m}+ n or ... o m x, possessivo (NON SUPPORTATO)
x{n,}+ n o più x, possessiva (NON SUPPORTATO)
x{n}+ esattamente n x, possessiva (NON SUPPORTATO)
  Raggruppamento
(re) gruppo di cattura numerato (sottocorrispondenza)
(?P<nome>re) denominato & gruppo di acquisizione numerato (sottomatch)
(?<nome>re) denominato & gruppo di acquisizione numerato (sottomatch) (NON SUPPORTATO)
(?' name're) denominato & gruppo di acquisizione numerato (sottomatch) (NON SUPPORTATO)
(?:re) gruppo non di cattura
(?flags) imposta contrassegni nel gruppo corrente; non catturante
(?flags:re) imposta contrassegni durante re; non catturante
(?#text) commento (NON SUPPORTATO)
(?|x|y|z) reimpostazione numerazione ramo (NON SUPPORTATO)
(?>re) corrispondenza possessiva di re (NON SUPPORTATO)
re@> corrispondenza possessiva di re (NON SUPPORTATO) VIM
%(re) gruppo non di cattura (NON SUPPORTATO) VIM
  Flag
i non sensibile alle maiuscole (false è predefinito)
m modalità multiriga: ^ e $ corrispondono alla riga di inizio/fine oltre al testo di inizio/fine (false è predefinito)
s lascia . corrispondenza \n (false è predefinito)
U ungreedy: swap meaning of x* and x*?, x+ and x+?, etc (default false)

La sintassi del flag è xyz (set) o -xyz (clear) o xy-z (set xy, clear z).

  Stringhe vuote
^ all'inizio del testo o della riga (m=true)
$ alla fine del testo (come \z non \Z) o della riga (m=true)
\A all'inizio del testo
\b al confine parola ASCII (\w su un lato e \W, \A, o \z sull'altro)
\B non al confine parola ASCII
\g all'inizio del sottotesto cercato (NON SUPPORTATO) PCRE
\G alla fine dell'ultima corrispondenza (NON SUPPORTATO) PERL
\Z alla fine del testo o prima di una nuova riga alla fine del testo (NON SUPPORTATO)
\z alla fine del testo
(?=re) prima del testo che corrisponde a re (NON SUPPORTATO)
(?!re) prima del testo che non corrisponde a re (NON SUPPORTATO)
(?<=re) dopo il testo che corrisponde a re (NON SUPPORTATO)
(?<!re) dopo il testo che non corrisponde a re (NON SUPPORTATO)
re& prima del testo che corrisponde a re (NON SUPPORTATO) VIM
re@= prima del testo che corrisponde a re (NON SUPPORTATO) VIM
re@! prima del testo che non corrisponde a re (NON SUPPORTATO) VIM
<re@= dopo il testo che corrisponde a re (NON SUPPORTATO) VIM
re@<! dopo il testo che non corrisponde a re (NON SUPPORTATO) VIM
\zs imposta inizio della corrispondenza (= \K) (NON SUPPORTATO) VIM
\ze imposta fine della corrispondenza (= \K) (NON SUPPORTATO) VIM
\%^ inizio del file (NON SUPPORTATO) VIM
\%$ fine del file (NON SUPPORTATO) VIM
\%V sullo schermo (NON SUPPORTATO) VIM
\%# posizione cursore (NON SUPPORTATO) VIM
\%'m segna posizione m (NON SUPPORTATO) VIM
\%23l nella riga 23 (NON SUPPORTATO) VIM
\%23c nella colonna 23 (NON SUPPORTATO) VIM
\%23v nella colonna virtuale 23 (NON SUPPORTATO) VIM
  Sequenze di escape
\a campanello (≡ \007)
\f feed modulo (≡ \014)
\t scheda orizzontale (≡ \011)
\n nuova riga (≡ \012)
\r ritorno a capo (≡ \015)
\v carattere scheda verticale (≡ \013)
* letterale *, per qualsiasi carattere di punteggiatura *
\123 codice di carattere ottale (fino a 3 cifre)
\x7F codice carattere esadecimale (esattamente due cifre)
\x{10FFFF} codice carattere esadecimale
\C corrispondenza per un singolo byte anche nella modalità UTF-8
\Q...\E testo letterale ... anche se ... ha la punteggiatura
\1 backreference (NON SUPPORTATO)
\b cancelletto (NOT SUPPORTED) (usare \010)
\cK carattere di controllo ^K (NON SUPPORTATO) (usare \001 ecc.)
\e escape (NON SUPPORTATO) (usare \033)
\g1 backreference (NON SUPPORTATO)
\g{1} backreference (NON SUPPORTATO)
\g{+1} backreference (NON SUPPORTATO)
\g{-1} backreference (NON SUPPORTATO)
\g{name} backreference nominato (NON SUPPORTATO)
\g<nome> invoca sottoroutine (NON SUPPORTATO)
\g'name' invoca sottoroutine (NON SUPPORTATO)
\k<nome> backreference nominato (NON SUPPORTATO)
\k'name' backreference nominato (NON SUPPORTATO)
\lX X minuscola (NON SUPPORTATO)
\ux X maiuscola (NON SUPPORTATO)
\L...\E testo minuscolo ... (NON SUPPORTATO)
\K reimposta inizio di $0 (NON SUPPORTATO)
\N{nome} carattere Unicode nominato (NON SUPPORTATO)
\R interruzione di riga (NON SUPPORTATO)
\U...\E testo maiuscolo ... (NON SUPPORTATO)
\X sequenza Unicode estesa (NON SUPPORTATO)
%d123 carattere decimale 123 (NON SUPPORTATO) VIM
%xFF carattere esadecimale FF (NON SUPPORTATO) VIM
%o123 carattere ottale 123 (NON SUPPORTATO) VIM
%u1234 carattere Unicode 0x1234 (NON SUPPORTATO) VIM
%U12345678 carattere Unicode 0x12345678 (NON SUPPORTATO) VIM
  Elementi delle classi di caratteri
x carattere singolo
A-Z intervallo di caratteri (inclusivo)
\d Classe di caratteri di Perl
[:foo:] foo classe di caratteri ASCII
\p{Foo} foo classe di caratteri Unicode
\pF classe di caratteri Unicode F (nome di una lettera)
  Classi di caratteri nominati come elementi di classi di caratteri
[\d] cifre (≡ \d)
[^\d] non cifre (≡ \D)
[\D] non cifre (≡ \D)
[^\D] non non cifre (≡ \d)
[[:nome:]] classe ASCII nominati inclusa in una classe di caratteri (≡ [:nome:])
[^[:nome:]] classe ASCII nominata inclusa in una classe negata (≡ [:^nome:])
[\p{Name}] proprietà Unicode nominata inclusa in una classe di caratteri (≡ \p{Name})
[^\p{Name}] proprietà Unicode nominata inclusa in un carattere negato (≡ \P{Nome})
Classi di caratteri di Perl (tutti solo ASCII)
\d cifre (≡ [0-9])
\D non cifre (≡ [^0-9])
\s spazio (≡ [\t\n\f\r])
\S non spazio (≡ [^\t\n\f\r])
\w caratteri di parola (≡ [0-9A-Za-z_])
\W non caratteri di parola (≡ [^0-9A-Za-z_])
\h spazio orizzontale (NON SUPPORTATO)
\H non spazio orizzontale (NON SUPPORTATO)
\v spazio verticale (NON SUPPORTATO)
\V non spazio verticale (NON SUPPORTATO)
Classe di caratteri di ASCII
[[:alnum:]] alfanumerico (≡ [0-9A-Za-z])
[[:alpha:]] alfabetico (≡ [A-Za-z])
[[:ascii:]] ASCII (≡ [\x00-\x7F])
[[:blank:]] vuoto (≡ [\t])
[[:cntrl:]] controllo (≡ [\x00-\x1F\x7F])
[[:digit:]] cifre (≡ [0-9])
[[:graph:]] grafici (≡ [!-~] ≡ [A-Za-z0-9!&quot;#$%&amp;&#39;()\*+,\-./:;&lt;=&gt;?@[\\\]^_` {\|}~])
[[:lower:]] lettere minuscole (≡ [a-z])
[[:print:]] stampabili (≡ [-~] ≡ [[:graph:]])
[[:punct:]] punteggiatura (≡ [!-/:-@[-`{-~])
[[:space:]] spazio (≡ [\t\n\v\f\r])
[[:upper:]] lettere maiuscole (≡ [A-Z])
[[:word:]] caratteri di parola (≡ [0-9A-Za-z_])
[[:xdigit:]] cifre esadecimali (≡ [0-9A-Fa-f])
  Nomi di classi di caratteri di Unicode - categoria generale
C altro
Cc control
Cf format
CN punti di codice non assegnati (NON SUPPORTATO)
Co uso privato
Cs surrogato
L lettera
LC lettera con maiuscole/minuscole (NON SUPPORTATO)
L& lettera con maiuscole/minuscole (NON SUPPORTATO)
Ll lettera minuscola
Lm lettera modificatore
Lo altra lettera
Lt lettera del titolo
Lu lettera maiuscola
M segno
Mc segno di spaziatura
Me segno di chiusura
Mn segno non di spaziatura
N number
Nd numero decimale
Nl numero lettera
No altro numero
P punteggiatura
Pc punteggiatura connettore
Pd punteggiatura trattino
Pe punteggiatura di chiusura
Pf punteggiatura finale
Pi punteggiatura iniziale
Po altra punteggiatura
Ps punteggiatura aperta
S symbol
Sc simbolo attuale
Sk simbolo modificatore
Sm simbolo matematico
So altro simbolo
Z separatore
Zl separatore riga
Zp separatore paragrafo
Zs separatore spazio
Nomi di classi di caratteri di Unicode -- sistemi di scrittura
Adlam
Ahom
Anatolian_Hieroglyphs
Arabo
Armeno
Avestico
Balinese
Bamum
Bassa_Vah
Batak
Bengali
Bhaiksuki
Bopomofo
Brahmi
Braille
Buginese
Buhid
Canadian_Aboriginal
Cario
Caucasian_Albanian
Chakma
Cham
Cherokee
Chorasmian
Comune
Copto
Cuneiforme
Cipriota
Cirillico
Deseret
Devanagari
Dives_Akuru
Dogra
Duployan
Egyptian_Hieroglyphs
Elbasano
Elimaico
Etiopico
Georgiano
Glagolitico
Gotico
Grantha
Greco
Gujarati
Gunjala_Gondi
Gurmukhi
Han
Hangul
Hanifi_Rohingya
Hanunoo
Hatran
Ebraico
Hiragana
Imperial_Aramaic
Ereditato
Inscriptional_Pahlavi
Inscriptional_Parthian
Giavanese
Kaithi
Kannada
Katakana
Kayah_Li
Kharoshthi
Khitan_Small_Script
Khmer
Khojki
Khudawadi
Lao
Latino
Lepcha
Limbu
Linear_A
Linear_B
Lisu
Liciano
Lidio
Mahajani
Makasar
Malayalam
Mandaico
Manicheo
Marchen
Masaram_Gondi
Medefaidrin
Meetei_Mayek
Mende_Kikakui
Meroitic_Cursive
Meroitic_Hieroglyphs
Miao
Modi
Mongolo
Mro
Multani
Myanmar
Nabateo
Nandinagari
New_Tai_Lue
Newa
Nko
Nushu
Nyiakeng_Puachue_Hmong
Ogham
Ol_Chiki
Old_Hungarian
Old_Italic
Old_North_Arabian
Old_Permic
Old_Persian
Old_Sogdian
Old_South_Arabian
Old_Turkic
Oriya
Osage
Osmanya
Pahawh_Hmong
Palmireno
Pau_Cin_Hau
Phags_Pa
Fenicio
Psalter_Pahlavi
Rejang
Runico
Samaritano
Saurashtra
Sharada
L'shaviano
Siddham
Linguaggio dei segni
Singalese
Sogdiano
Sora_Sompeng
Soyombo
Sundanese
Syloti_Nagri
Siriano
Tagalog
Tagbanwa
Tai_Le
Tai_Tham
Tai_Viet
Takri
Tamil
Tangut
Telugu
Thaana
Thai
Tibetano
Tifinagh
Tirhuta
Ugaritico
Vai
Wancho
Warang_Citi
Yezidi
Yi
Zanabazar_Square
  Classi di caratteri di VIM
\i carattere identificatore (NON SUPPORTATO) VIM
\I \i tranne i numeri (NON SUPPORTATO) VIM
\k carattere tastiera (NON SUPPORTATO) VIM
\K \k tranne numeri (NON SUPPORTATO) VIM
\f carattere nome di file (NON SUPPORTATO) VIM
\F \f tranne numeri (NON SUPPORTATO) VIM
\p caratteri stampabili (NON SUPPORTATO) VIM
\P \p tranne caratteri (NON SUPPORTATO) VIM
\s carattere spazio (≡ [\t]) (NON SUPPORTATO) VIM
\S carattere non spazio (≡ [^ \t]) (NON SUPPORTATO) VIM
\d cifre (≡ [0-9]) VIM
\D non \d VIM
\x cifre esadecimali (≡ [0-9A-Fa-f]) (NON SUPPORTATO) VIM
\X non \x (NON SUPPORTATO) VIM
\o cifre ottali (≡ [0-7]) (NON SUPPORTATO) VIM
\O non \o (NON SUPPORTATO) VIM
\w carattere di parola VIM
\W non \w VIM
\h inizio carattere di parola (NON SUPPORTATO) VIM
\H non \h (NON SUPPORTATO) VIM
\a alfabetico (NON SUPPORTATO) VIM
\A non \a (NOT SUPPORTED) VIM
\l minuscola (NON SUPPORTATO) VIM
\L non minuscola (NON SUPPORTATO) VIM
\u maiuscola (NON SUPPORTATO) VIM
\U non maiuscola (NON SUPPORTATO) VIM
_X \x più newline, per qualsiasi x (NON SUPPORTATO) VIM
\c ignora maiuscola/minuscola (NON SUPPORTATO) VIM
\C corrispondenza maiuscola/minuscola (NON SUPPORTATO) VIM
\m magic (NON SUPPORTATO) VIM
\M no magic (NON SUPPORTATO) VIM
\v very magic (NON SUPPORTATO) VIM
\V very no magic (NON SUPPORTATO) VIM
\Z ignora differenze nei caratteri di combinazione di Unicode (NON SUPPORTATO) VIM
  Magic
(?{code}) codice Perl arbitrario (NON SUPPORTATO) PERL
(??{code}) codice Perl arbitrario posticipato (NON SUPPORTATO) PERL
(?n) invocazione ricorsiva gruppo n di cattura regexp (NON SUPPORTATO)
(?+n) invocazione ricorsiva per gruppo relativo +n (NON SUPPORTATO)
(?-n) invocazione ricorsiva per gruppo relativo -n (NON SUPPORTATO)
(?C) Invocazione PCRE (NON SUPPORTATO) CPRE
(?R) invocazione ricorsiva intero regexp (≡ (?0)) (NON SUPPORTATO)
(?&nome) invocazionericorsiva per gruppo nominato (NON SUPPORTATO)
(?P=nome) backreference nominato (NON SUPPORTATO)
(?P>nome) invocazione ricorsiva per gruppo nominato (NON SUPPORTATO)
(? (cond)true|false) ramo condizionale (NON SUPPORTATO)
(?(cond)true) ramo condizionale (NON SUPPORTATO)
(*ACCETTA) rende i regexps simili a Prolog (NON SUPPORTATO)
(*COMMIT) (NON SUPPORTATO)
(*F) (NON SUPPORTATO)
(*FAIL) (NON SUPPORTATO)
(*MARK) (NON SUPPORTATO)
(*PRUNE) (NON SUPPORTATO)
(*SKIP) (NON SUPPORTATO)
(*THEN) (NON SUPPORTATO)
(*ANY) imposta convenzione newline (NON SUPPORTATO)
(*ANYCRLF) (NON SUPPORTATO)
(*CR) (NON SUPPORTATO)
(*CRLF) (NON SUPPORTATO)
(*LF) (NON SUPPORTATO)
(*BSR_ANYCRLF) imposta convenzione \R (NON SUPPORTATO) PCRE
(*BSR_UNICODE) (NON SUPPORTATO) PCRE

Licenza dei contenuti

Nota

Parti di questa pagina sono modifiche basate sul lavoro creato e condiviso da Chromium.org e usate in base ai termini descritti nella licenza Creative Commons Attribution 4.0 International. La pagina originale è disponibile qui.

Licenza Creative Commons
Questo lavoro è concesso in licenza in base a una licenza Creative Commons Attribution 4.0 International.

Vedere anche