La programmazione ha reso facile gestire dati testuali strutturati e non strutturati. Strumenti come espressioni regolari e librerie esterne rendono queste attività molto più semplici.

Puoi utilizzare la maggior parte dei linguaggi, inclusi Python e JavaScript, per convalidare gli URL utilizzando un'espressione regolare. Questa espressione regolare di esempio non è perfetta, ma puoi usarla per controllare gli URL per casi d'uso semplici.

Un'espressione regolare per convalidare un URL

La regex per convalidare un URL presentato in questo articolo non è perfetta. Potrebbero esserci più esempi di URL validi che potrebbero non riuscire questa convalida regex. Ciò include URL che coinvolgono indirizzi IP, caratteri non ASCII e protocolli come FTP. La seguente espressione regolare convalida solo gli URL più comuni.

La regex considererà un URL valido se soddisfa le seguenti condizioni:

  1. La stringa dovrebbe iniziare con entrambi http O https seguito da ://.
  2. La lunghezza combinata del sottodominio e del dominio deve essere compresa tra 2 e 256. Deve contenere solo caratteri alfanumerici e/o caratteri speciali.
    instagram viewer
  3. Il TLD (Top-Level Domain) dovrebbe contenere solo caratteri alfabetici e dovrebbe avere una lunghezza compresa tra due e sei caratteri.
  4. La fine della stringa dell'URL potrebbe contenere caratteri alfanumerici e/o caratteri speciali. E potrebbe ripetersi zero o più volte.

Puoi convalidare un URL in JavaScript utilizzando la seguente espressione regolare:

^(http (s):\/\/.)[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)$

Allo stesso modo, puoi utilizzare la seguente espressione regolare per convalidare un URL in Python:

^((http|https)://)[-a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)$

Dove:

  • (http|https)://) assicura che la stringa inizi con http o https seguito da ://.
  • [-a-zA-Z0-9@:%._\\+~#?&//=] indica caratteri alfanumerici e/o caratteri speciali. La prima istanza di questo set rappresenta il set di caratteri da consentire nella parte del sottodominio e del dominio. Mentre la seconda istanza di questo set rappresenta il set di caratteri da consentire nella stringa di query o nella parte della sottodirectory.
  • {2,256} rappresenta l'indicatore di occorrenza da 2 a 256 (entrambi inclusi). Ciò indica che la lunghezza combinata del sottodominio e del dominio deve essere compresa tra due e 256.
  • \. rappresenta il carattere punto.
  • [a-z]{2,6} indica qualsiasi lettera minuscola dalla a alla z con una lunghezza compresa tra due e sei. Questo rappresenta il set di caratteri da consentire nella parte del dominio di primo livello.
  • \B rappresenta il confine di una parola, cioè l'inizio di una parola o la fine di una.
  • * è un operatore di ripetizione che indica zero o più copie della stringa di query, dei parametri o delle sottodirectory.
  • ^ E $ indicano rispettivamente l'inizio e la fine della stringa.

Se ti senti a disagio con l'espressione sopra, dai un'occhiata una guida per principianti alle espressioni regolari Primo. Le espressioni regolari richiedono un po' di tempo per abituarsi. Esplorando alcuni esempi come convalidare i dettagli dell'account utente utilizzando espressioni regolari dovrebbe aiutare.

La regex precedente soddisfa i seguenti tipi di URL:

  • https://www.something.com/
  • http://www.something.com/
  • https://www.something.edu.co.in
  • http://www.url-with-path.com/path
  • https://www.url-with-querystring.com/?url=has-querystring
  • http://url-without-www-subdomain.com/
  • https://mail.google.com

Utilizzo dell'espressione regolare in un programma

Il codice utilizzato in questo progetto è disponibile in a Deposito GitHub ed è gratuito per l'uso con la licenza MIT.

Questo è un approccio Python alla convalida di un URL:

importare Rif
defvalidateURL(URL):
 regex = "^((http|https)://)[-a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%._\\+~#?&//=]*)$"
 r = ricompilare (regex)


Se (Rif.ricerca(R, URL)):
 stampa("Valido")
altro:
 stampa("Non valido")
URL1 = "https://www.linkedin.com/"
convalidaURL(url1)
URL2 = "http://apple"
convalidaURL(url2)
URL3 = "iywegfuykegf"
validateURL(url3)
URL4 = "https://w"
convalidaURL(url4)

Questo codice utilizza Python ri.compilare() metodo per compilare il modello di espressione regolare. Questo metodo accetta il modello regex come parametro stringa e restituisce un oggetto modello regex. Questo oggetto modello regex viene ulteriormente utilizzato per cercare le occorrenze del modello regex all'interno della stringa di destinazione utilizzando il ricerca() metodo.

Se trova almeno una corrispondenza, il file ricerca() metodo restituisce la prima corrispondenza. Si noti che se si desidera cercare tutte le corrispondenze del modello dalla stringa di destinazione, è necessario utilizzare il file re.trovall() metodo.

L'esecuzione del codice precedente confermerà che il primo URL è valido ma il resto no.

Allo stesso modo, puoi convalidare un URL in JavaScript utilizzando il seguente codice:

funzionevalidateURL(URL) {
Se(/^(http (s):\/\/.)[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)$/g.test (URL)) {
 console.log('Valido');
 } altro {
 console.log('Non valido');
 }
}
validateURL("https://www.linkedin.com/");
validateURL("http://apple");
validateURL("iywegfuykegf");
validateURL("https://w");

Ancora una volta, l'esecuzione di questo codice confermerà che il primo URL è valido e il resto non lo è. Utilizza JavaScript incontro() metodo per confrontare la stringa di destinazione con un modello di espressione regolare.

Convalida dati importanti utilizzando espressioni regolari

Puoi utilizzare le espressioni regolari per cercare, abbinare o analizzare il testo. Sono anche usati per l'elaborazione del linguaggio naturale, il pattern matching e l'analisi lessicale.

Puoi utilizzare questo potente strumento per convalidare tipi importanti di dati come numeri di carte di credito, dettagli dell'account utente, indirizzi IP e altro.