Lavorare con gli URL usando il pacchetto net/url di Go
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 pacchetto url fornisce funzioni e caratteristiche complete per lavorare con gli 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.
Alcune delle caratteristiche chiave del pacchetto url sono la capacità di analizzare gli URL in singoli componenti per la manipolazione e la costruzione di URL per le richieste HTTP. Il pacchetto url fornisce anche una struttura URL con un metodo Parse per analizzare le stringhe in URL.
Ecco il modello struct url.URL :
package main
type URL struct {
// Scheme is the protocol scheme of the URL,
// such as "http"or "https"
Scheme string
// Opaque is used to hold any opaque data
// that should be encoded in the URL
Opaque string
// User holds information about the user making the request,
// such as a username and password
User *Userinfo
// Host is the hostname or IP address
// of the server hosting the URL
Host string
// Path is the path of the URL on the server
Path string
// RawPath is the original,
// encoded path of the URL
RawPath string
// ForceQuery indicates whether the URL should include a query string
// even if it is empty
ForceQuery bool
// RawQuery is the original,
//encoded query string of the URL
RawQuery string
// Fragment is the fragment identifier of the URL,
// used for linking to a specific element on a page
Fragment string
// RawFragment is the original,
// encoded fragment identifier of the URL
RawFragment string
}
Sapere come accedere a varie parti della struttura dell’URL può essere utile per attività come la convalida.
Analisi degli URL utilizzando la funzione Parse
La funzione Parse del pacchetto url fornisce la funzionalità per l’analisi delle stringhe URL nei singoli componenti. La funzione Parse accetta un singolo URL come argomento e restituisce un puntatore alla struttura url.URL contenente i dati analizzati dell’URL e un tipo di errore.
Ecco come utilizzare la funzione Parse per recuperare gli elementi di un URL.
import (
"fmt"
"net/url"
)
func main() {
// The URL you want to parse
exampleURL: = "https://www.example.com/path?param1=value1¶m2=value2"
// Parse the URL
parsedURL, err: = url.Parse(exampleURL)
if err! = nil {
fmt.Println(err)
return
}
// Print all the fields of the URL
fmt.Println("Scheme:", parsedURL.Scheme)
fmt.Println("Opaque:", parsedURL.Opaque)
fmt.Println("User:", parsedURL.User)
fmt.Println("Host:", parsedURL.Host)
fmt.Println("Path:", parsedURL.Path)
fmt.Println("RawPath:", parsedURL.RawPath)
fmt.Println("ForceQuery:", parsedURL.ForceQuery)
fmt.Println("RawQuery:", parsedURL.RawQuery)
fmt.Println("Fragment:", parsedURL.Fragment)
fmt.Println("RawFragment:", parsedURL.RawFragment)
}
La variabile exampleURL contiene l’URL completo e non analizzato e la funzione Parse analizza il contenuto della variabile exampleURL e restituisce l’URL analizzato. Il programma termina con una serie di chiamate a Println per dimostrare i singoli campi della struttura URL .
La funzione parse non controlla se un URL è reale e realmente esistente, analizza solo l’URL sintatticamente. Puoi utilizzare il pacchetto http per effettuare una richiesta GET all’URL e controllare la risposta:
import (
"fmt"
"net/http"
)
func main() {
// The URL you want to check
exampleURL: = "https://www.example.com"
// Make an HTTP GET request to the URL
response, err: = http.Get(exampleURL)
if err! = nil {
fmt.Println(err)
return
}
defer response.Body.Close()
// Check the response status code
if response.StatusCode == http.StatusOK {
fmt.Println("URL exists.")
} else {
fmt.Println("URL does not exist.")
}
}
La funzione principale effettua una richiesta GET all’URL di esempio utilizzando la funzione Get del pacchetto http . Quella funzione restituisce un’istanza di risposta e un tipo di errore. Il programma termina con un’istruzione if per convalidare l’esistenza del sito Web confrontando il codice di stato HTTP con la costante StatusOk del pacchetto http .
Questo approccio consente di intraprendere azioni in base all’esito del controllo, come reindirizzare l’utente a una pagina diversa, visualizzare un messaggio di errore o ritentare la richiesta dopo un certo periodo.
Codifica e decodifica dei parametri URL
Il pacchetto url fornisce il metodo Encode per la codifica dei parametri URL. La funzione Encode codifica in percentuale i caratteri speciali e gli spazi nei parametri URL.
import (
"fmt"
"net/url"
)
func main() {
// create a new url.Values struct
params: = url.Values{}
// add values to the struct
params.Add("name", "John Smith")
params.Add("age", "30")
params.Add("gender", "male")
// encode the struct into a string
encodedParams: = params.Encode()
fmt.Println(encodedParams)
// Output: "age=30&gender=male&name=John+Smith"
}
La funzione main crea una nuova istanza Values struct del pacchetto url e il metodo Add dell’istanza struct aggiunge coppie chiave-valore di dati all’istanza struct.
Il metodo Encode converte la coppia chiave-valore nel formato della stringa URL “key1=value1&key2=value2&key3=value3”.
Puoi decodificare una stringa URL codificata con la funzione ParseQuery del pacchetto url .
import (
"fmt"
"net/url"
)
func main() {
// encoded string of URL parameters
encodedParams: = "age=30&gender=male&name=John+Smith"
// parse the encoded string into a url.Values struct
params, err: = url.ParseQuery(encodedParams)
if err! = nil {
fmt.Println(err)
}
// print the struct
fmt.Println(params)
// Output: map[age:[30] gender:[male] name:[John Smith]]
}
La variabilecodingParameter è una stringa URL codificata. La funzione ParseQuery accetta la variabilecodingParameter 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 semplificano l’instradamento rispetto al pacchetto http astraendo alcune delle sue complessità.
Lascia un commento