Regular Expressions
Vetrina Regex utile

Bash C# Language Java Language JavaScript jQuery Perl Language PHP Python Language R Language Ruby Language
Ricerca…


Abbina una data

Dovresti ricordare che la regex è stata progettata per abbinare una data (o meno). Dire che una data è valida è una lotta molto più complicata, dal momento che richiederà un sacco di gestione delle eccezioni (vedere le condizioni dell'anno bisestile ).

Iniziamo abbinando il mese (1 - 12) con uno 0 iniziale opzionale: 

0?[1-9]|1[0-2]

Per abbinare il giorno, anche con uno 0 iniziale opzionale: 

0?[1-9]|[12][0-9]|3[01]

E per abbinare l'anno (assumiamo solo l'intervallo 1900 - 2999): 

(?:19|20)[0-9]{2}

Il separatore può essere uno spazio, un trattino, una barra, vuoto, ecc. Sentiti libero di aggiungere qualcosa che ritieni possa essere usato come separatore: 

[-\\/ ]?

Ora concateni tutto e ottieni: 

(0?[1-9]|1[0-2])[-\\/ ]?(0?[1-9]|[12][0-9]|3[01])[-/ ]?(?:19|20)[0-9]{2} // MMDDYYYY
(0?[1-9]|[12][0-9]|3[01])[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Se vuoi essere un po 'più pedante, puoi usare un riferimento a ritroso per essere sicuro che i due separatori saranno gli stessi: 

(0?[1-9]|1[0-2])([-\\/ ]?)(0?[1-9]|[12][0-9]|3[01])\2(?:19|20)[0-9]{2} // MMDDYYYY
                                                 ^ refer to [-/ ]
(0?[1-9]|[12][0-9]|3[01])([-\\/ ]?)(0?[1-9]|1[0-2])\2(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}([-\\/ ]?)(0?[1-9]|1[0-2])\2(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Abbina un indirizzo email

La corrispondenza di un indirizzo e-mail all'interno di una stringa è un compito difficile, poiché la specifica che la definisce, la RFC2822 , è complessa e rende difficile l'esecuzione come un'espressione regolare . Per maggiori dettagli, perché non è una buona idea abbinare un'e-mail con un'espressione regolare, fai riferimento all'esempio antipattern quando non usi una regex: per la corrispondenza delle e-mail . Il miglior consiglio da notare da quella pagina è di usare una peer review e una vasta libreria nella tua lingua preferita per implementarla.

Convalida un formato di indirizzo email

Quando è necessario convalidare rapidamente una voce per assicurarsi che assomigli ad un'e-mail, l'opzione migliore è di mantenerla semplice: 

^\S{1,}@\S{2,}\.\S{2,}$

L'espressione regolare controllerà che l'indirizzo di posta sia una sequenza non separata da spazi di caratteri di lunghezza maggiore di uno, seguita da una @ , seguita da due sequenze di caratteri non spazi di lunghezza due o più separati da a . . Non è perfetto e potrebbe convalidare indirizzi non validi (in base al formato), ma, soprattutto, non sta invalidando gli indirizzi validi.

Controlla che l'indirizzo esista

L'unico modo affidabile per verificare che un'e-mail sia valida è controllare la sua esistenza. C'era il comando SMTP VRFY che è stato progettato per questo scopo, ma purtroppo, dopo essere stato abusato dagli spammer, non è più disponibile .

Quindi l'unico modo che ti rimane per controllare che la posta sia valida ed esiste è di mandare effettivamente una e-mail a quell'indirizzo.

Enormi alternative Regex

Tuttavia, non è impossibile convalidare un indirizzo email usando un'espressione regolare. L'unico problema è che più si avvicinano alla specifica quelle regex saranno, più grandi saranno e come conseguenza sono impossibilmente difficili da leggere e mantenere. Di seguito, troverai esempi di espressioni regolari più accurate che vengono utilizzate in alcune librerie.

⚠️ Le seguenti espressioni regolari sono fornite a scopo di documentazione e di apprendimento, copiare le copie nel codice è una cattiva idea. Invece, usa direttamente quella libreria, così puoi contare sul codice upstream e sugli sviluppatori peer per mantenere aggiornato e aggiornato il tuo codice di analisi delle email.

Modulo di corrispondenza indirizzo Perl

I migliori esempi di tale regex sono in alcune librerie standard di alcune lingue. Ad esempio, ce n'è uno dal modulo RFC::RFC822::Address nella libreria Perl che cerca di essere il più accurato possibile secondo la RFC. Per tua curiosità puoi trovare una versione di quella regex a questo URL , che è stata generata dalla grammatica, e se sei tentato di copiarlo incollalo, ecco la citazione dell'autore delle regex:

" Non mantengo l'espressione regolare [collegata]. Potrebbero esserci dei bug che sono già stati corretti nel modulo Perl. "

. Modulo di corrispondenza indirizzi

Un'altra variante più breve è quella utilizzata dalla libreria standard .Net nel modulo EmailAddressAttribute : 

^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$

Ma anche se è più breve è ancora troppo grande per essere leggibile e facilmente mantenibile.

Modulo di corrispondenza Ruby Address

Nel ruby ​​viene utilizzata una composizione di regex nel modulo rfc822 per abbinare un indirizzo. Questa è una buona idea, poiché nel caso in cui vengano rilevati dei bug, sarà più facile individuare la parte regex per modificarla e correggerla.

Modulo di corrispondenza indirizzo Python

Come esempio contrario, il modulo di analisi email di python non sta usando un'espressione regolare, ma invece lo implementa utilizzando un parser.

Abbina un numero di telefono

Ecco come abbinare un codice prefisso (a + o (00), quindi un numero da 1 a 1939, con uno spazio opzionale):
Questo non cerca un prefisso valido ma qualcosa che potrebbe essere un prefisso. Vedi l' elenco completo dei prefissi 

(?:00|\+)?[0-9]{4}

Quindi, dato che l'intera lunghezza del numero di telefono è, al massimo, 15, possiamo cercare fino a 14 cifre:
Almeno 1 cifra è speso per il prefisso 

[0-9]{1,14}

I numeri possono contenere spazi, punti o trattini e possono essere raggruppati per 2 o 3. 

(?:[ .-][0-9]{3}){1,5}

Con il prefisso opzionale: 

(?:(?:00|\+)?[0-9]{4})?(?:[ .-][0-9]{3}){1,5}

Se si desidera abbinare un formato di paese specifico, è possibile utilizzare questa query di ricerca e aggiungere il paese, la domanda è sicuramente già stata posta.

Abbina un indirizzo IP

IPv4

Per abbinare il formato dell'indirizzo IPv4, è necessario verificare i numeri [0-9]{1,3} tre volte {3} separati da punti \. e termina con un altro numero. 

^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$

Questa espressione regolare è troppo semplice - se vuoi che sia accurata, devi controllare che i numeri siano compresi tra 0 e 255 , con la regex sopra accettando 444 in qualsiasi posizione. Si desidera verificare 250-255 con 25[0-5] o qualsiasi altro valore 200 2[0-4][0-9] o qualsiasi valore 100 o inferiore con [01]?[0-9][0-9] . Volete controllare che sia seguito da un punto \. tre volte {3} e poi una volta senza un punto. 

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

IPv6

Indirizzi IPv6 assumono la forma di 8 parole esadecimali a 16 bit delimitati con i due punti ( : carattere). In questo caso, controlliamo 7 parole seguite da due punti, seguite da una che non lo è. Se una parola ha zero iniziali, possono essere troncati, nel senso che ogni parola può contenere da 1 a 4 cifre esadecimali. 

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Questo, tuttavia, è insufficiente. Poiché gli indirizzi IPv6 possono diventare abbastanza "verbosi", lo standard specifica che le parole zero-zero possono essere sostituite da :: . Questo può essere fatto solo una volta in un indirizzo (per qualsiasi tra 1 e 7 parole consecutive), altrimenti sarebbe indeterminato. Questo produce una serie di variazioni (piuttosto sgradevoli): 

^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Ora, mettendo tutto insieme (usando l'alternanza) produce: 

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|
^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Assicurati di scriverlo in modalità multilinea e con una pila di commenti, quindi chi ha inevitabilmente il compito di capire cosa significa non arriva dopo di te con un oggetto contundente.

Convalida una stringa temporale di 12 ore e 24 ore

Per un formato orario di 12 ore è possibile utilizzare: 

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9]\s*[ap]m$

Dove

  • (?:0?[0-9]|1[0-2]) è l'ora
  • [-:] è il separatore, che può essere regolato in base alle tue esigenze
  • [0-5][0-9] è il minuto
  • \s*[ap]m seguito un numero qualsiasi di caratteri spazi bianchi e am o pm

Se hai bisogno dei secondi: 

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9][-:][0-5][0-9]\s*[ap]m$

Per un formato orario di 24 ore: 

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9]$

Dove:

  • (?:[01][0-9]|2[0-3]) è l'ora
  • [-:h] il separatore, che può essere regolato in base alle proprie esigenze
  • [0-5][0-9] è il minuto

Con i secondi: 

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9][-:m][0-5][0-9]$

Dove [-:m] è un secondo separatore, sostituendo h per ore con m per minuti e [0-5][0-9] è il secondo.

Abbina il codice postale del Regno Unito

Regex per abbinare i codici postali nel Regno Unito

Il formato è il seguente, dove A indica una lettera e 9 una cifra:

Formato Copertura Esempio
Cellula Cellula
AA9A 9AA WC codice postale; EC1-EC4, NW1W, SE1P, SW1 EC1A 1BB
A9A 9AA E1W, N1C, N1P W1A 0AX
A9 9AA, A99 9AA B, E, G, L, M, N, S, W M1 1AE, B33 8TH
AA9 9AA, AA99 9AA Tutti gli altri codici postali CR2 6XH, DN55 1PT 
(GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY])))) [0-9][A-Z-[CIKMOV]]{2})

Dove prima parte: 

 (GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY]))))

Secondo: 

[0-9][A-Z-[CIKMOV]]{2})


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow