I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione. Per saperne di più.

Gli URL (Uniform Resource Locator) sono una delle infrastrutture più critiche di Internet. Mentre crei applicazioni web, dovrai manipolare gli URL per individuare e recuperare le risorse.

Quando crei app Web più sofisticate, dovrai lavorare con gli URL a un livello più granulare. Potrebbe essere necessario identificare lo schema, il nome host, il percorso e i parametri della query. Dovrai anche sapere come codificare e decodificare gli URL in modo da poter gestire i caratteri speciali e proteggere la tua applicazione web.

La libreria standard di Go fornisce il pacchetto net/url per gestire URL e componenti URL.

Il pacchetto URL

IL URL pacchetto fornisce funzioni e caratteristiche complete con cui lavorare URL e le loro parti separate. Fornisce funzioni per l'analisi, la costruzione, la codifica e la decodifica degli URL, rendendo il pacchetto utile per lo sviluppo web.

instagram viewer

Alcune delle caratteristiche principali di URL package sono la capacità di analizzare gli URL in singoli componenti per la manipolazione e la costruzione di URL per le richieste HTTP. IL URL pacchetto fornisce anche a URL struttura con a Analizza metodo per analizzare le stringhe in URL.

Ecco il URL. URL modello struct:

pacchetto principale
tipo URL struct {
// Scheme è lo schema del protocollo dell'URL,
// come "http" o "https"
 schema corda


// Opaque viene utilizzato per contenere dati opachi
// che dovrebbe essere codificato nell'URL
 Opaco corda


// L'utente contiene informazioni sull'utente che effettua la richiesta,
// come nome utente e password
 Utente *Informazioni utente


// Host è il nome host o l'indirizzo IP
// del server che ospita l'URL
 Ospite corda


// Path è il percorso dell'URL sul server
 Sentiero corda


// RawPath è l'originale,
// percorso codificato dell'URL
 RawPath corda


// ForceQuery indica se l'URL deve includere una stringa di query
// anche se è vuoto
 ForzaQuery bool


// RawQuery è l'originale,
//stringa di query codificata dell'URL
 RawQuery corda


// Fragment è l'identificatore di frammento dell'URL, 
// utilizzato per il collegamento a un elemento specifico in una pagina
 Frammento corda
// RawFragment è l'originale,
// identificatore di frammento codificato dell'URL
 Frammento grezzo corda
}

Saper accedere a varie parti del file URL struct può essere utile per attività come la convalida.

Analisi degli URL utilizzando la funzione Parse

IL Analizza funzione del URL Il pacchetto fornisce la funzionalità per l'analisi delle stringhe URL nei singoli componenti. IL Analizza La funzione prende un singolo URL come argomento e restituisce un puntatore al URL. URL struct contenente i dati analizzati dell'URL e un tipo di errore.

Ecco come puoi usare il Analizza funzione per recuperare gli elementi di un URL.

importare (
"fmt"
"rete/URL"
)
funzprincipale() {
// L'URL che desideri analizzare
 esempioURL := " https://www.example.com/path? param1=valore1&param2=valore2"


// Analizza l'URL
 parsedURL, err := url. Analizza (URL di esempio)


Se errare!= zero {
 fmt. Stampaln (err)
ritorno
 }
// Stampa tutti i campi dell'URL
 fmt. Stampaln("Schema:", parsedURL.Scheme)
 fmt. Stampaln("Opaco:", parsedURL.Opaque)
 fmt. Stampaln("Utente:", parsedURL.Utente)
 fmt. Stampaln("Ospite:", parsedURL.Host)
 fmt. Stampaln("Sentiero:", parsedURL.Path)
 fmt. Stampaln("RawPath:", parsedURL.RawPath)
 fmt. Stampaln("Forza query:", parsedURL.ForceQuery)
 fmt. Stampaln("RawQuery:", parsedURL.RawQuery)
 fmt. Stampaln("Frammento:", parsedURL.Fragment)
 fmt. Stampaln("Frammento grezzo:", parsedURL.RawFragment)
}

IL esempioURL la variabile contiene l'URL completo e non analizzato e il file Analizza funzione analizza il contenuto del file esempioURL variabile e restituisce l'URL analizzato. Il programma si conclude con una serie di chiamate a Stampaln per dimostrare i singoli campi del URL struct.

La funzione di analisi non controlla se un URL è reale e realmente esistente, analizza solo l'URL sintatticamente. Puoi usare il http pacchetto per fare una richiesta GET all'URL e controllare la risposta:

importare (
"fmt"
"rete/http"
)
funzprincipale() {
// L'URL che vuoi controllare
 esempioURL := " https://www.example.com"


// Effettua una richiesta HTTP GET all'URL
 risposta, err := http. Ottieni (URL di esempio)


Se errare!= zero {
 fmt. Stampaln (err)
ritorno
 }
differire risposta. Corpo. Vicino()

// Controlla il codice di stato della risposta
Se risposta. Codice di stato == http. Stato OK {
 fmt. Stampaln("L'URL esiste.")
 } altro {
 fmt. Stampaln("L'URL non esiste.")
 }
}

IL principale la funzione rende a OTTENERE richiesta al esempioURL usando il Ottenere funzione del http pacchetto. Quella funzione restituisce un'istanza di risposta e un tipo di errore. Il programma termina con un Se dichiarazione per convalidare l'esistenza del sito web controllando il Codice di stato HTTP contro il StatoOk costante da http pacchetto.

Questo approccio consente di intraprendere azioni in base all'esito del controllo, ad esempio reindirizzare il file utente a una pagina diversa, visualizzando un messaggio di errore o ritentando la richiesta dopo un certo periodo.

Codifica e decodifica dei parametri URL

IL URL pacchetto fornisce il Codificare metodo per la codifica dei parametri URL. IL Codificare la funzione percentuale codifica i caratteri speciali e gli spazi nei parametri URL.

importare (
"fmt"
"rete/URL"
)
funzprincipale() {
// crea un nuovo URL. Struttura dei valori
 parametri := url. Valori{}


// aggiunge valori alla struttura
 parametri. Aggiungere("nome", "John Smith")
 parametri. Aggiungere("età", "30")
 parametri. Aggiungere("genere", "maschio")


// codifica la struttura in una stringa
 encoderedParams := parametri. Codificare()
 fmt. Println (parametri codificati)
// Output: "età=30&sesso=maschio&nome=John+Smith"
}

IL principale la funzione crea un nuovo Valori struct istanza di URL pacchetto e il Aggiungere Il metodo dell'istanza struct aggiunge coppie di dati chiave-valore all'istanza struct.

IL Codificare Il metodo converte la coppia chiave-valore nel formato della stringa dell'URL "key1=value1&key2=value2&key3=value3".

Puoi decodificare una stringa URL codificata con l'estensione AnalizzaQuery funzione del URL pacchetto.

importare (
"fmt"
"rete/URL"
)
funzprincipale() {
// stringa codificata di parametri URL
 parametri codificati := "età=30&sesso=maschio&nome=John+Smith"


// analizza la stringa codificata in un URL. Struttura dei valori
 params, err := url. ParseQuery (parametri codificati)


Se errare!= zero {
 fmt. Stampaln (err)
 }


// stampa la struttura
 fmt. Println (parametri)


// Output: map[età:[30] genere:[maschio] nome:[John Smith]]
}

IL parametro codificato variabile è una stringa URL codificata. IL AnalizzaQuery funzione prende in parametro codificato variabile e restituisce la stringa URL decodificata e un errore.

Questi pacchetti Go possono portare il tuo gioco di Web Routing al livello successivo

Gli URL che utilizzi per le pagine della tua applicazione web contribuiscono alla sua performance e visibilità sui motori di ricerca. Il routing Web è il processo di indirizzamento delle richieste in entrata alla funzione di gestione appropriata in base all'URL.

Puoi instradare utilizzando il pacchetto http o popolari pacchetti di terze parti come Gorilla Mux, Chi, Pat o Httprouter. Questi pacchetti rendono l'instradamento più semplice rispetto al pacchetto http astraendo alcune delle sue complessità.