Utilisation des URL à l’aide du package net/url de Go
Les URL (Uniform Resource Locators) sont l’un des éléments d’infrastructure les plus critiques d’Internet. Lorsque vous créez des applications Web, vous devez manipuler des URL pour localiser et récupérer des ressources.
Lorsque vous créez des applications Web plus sophistiquées, vous devez travailler avec des URL à un niveau plus fin. Vous devrez peut-être identifier les paramètres de schéma, de nom d’hôte, de chemin et de requête. Vous devrez également savoir comment encoder et décoder les URL afin de pouvoir gérer les caractères spéciaux et assurer la sécurité de votre application Web.
La bibliothèque standard de Go fournit le package net/url pour gérer les URL et les composants d’URL.
Le paquet d’URL
Le package url fournit des fonctions et des fonctionnalités complètes pour travailler avec les URL et leurs parties distinctes. Il fournit des fonctions d’analyse, de construction, d’encodage et de décodage d’URL, ce qui rend le package utile pour le développement Web.
Certaines des fonctionnalités clés du package d’ URL sont la possibilité d’analyser les URL en composants individuels pour la manipulation et la construction d’URL pour les requêtes HTTP. Le package url fournit également une structure d’ URL avec une méthode Parse pour analyser les chaînes dans les URL.
Voici le modèle de structure 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
}
Savoir comment accéder aux différentes parties de la structure de l’ URL peut être utile pour des tâches telles que la validation.
Analyser des URL à l’aide de la fonction d’analyse
La fonction Parse du package url fournit la fonctionnalité d’analyse des chaînes d’URL dans les composants individuels. La fonction Parse prend une seule URL comme argument et renvoie un pointeur vers la structure url.URL contenant les données analysées de l’URL et un type d’erreur.
Voici comment vous pouvez utiliser la fonction Parse pour récupérer les éléments d’une 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 variable exampleURL contient l’URL complète non analysée et la fonction Parse analyse le contenu de la variable exampleURL et renvoie l’URL analysée. Le programme se termine par une série d’appels à Println pour démontrer les champs individuels de la structure URL .
La fonction d’analyse ne vérifie pas si une URL est réelle et existe réellement, elle analyse uniquement l’URL de manière syntaxique. Vous pouvez utiliser le package http pour envoyer une requête GET à l’URL et vérifier la réponse :
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 fonction main envoie une requête GET à exampleURL à l’aide de la fonction Get du package http . Cette fonction renvoie une instance de réponse et un type d’erreur. Le programme se termine par une instruction if pour valider l’existence du site Web en vérifiant le code d’état HTTP par rapport à la constante StatusOk du package http .
Cette approche vous permet de prendre des mesures en fonction du résultat de la vérification, comme rediriger l’utilisateur vers une autre page, afficher un message d’erreur ou réessayer la demande après un certain délai.
Paramètres d’encodage et de décodage d’URL
Le package url fournit la méthode Encode pour encoder les paramètres d’URL. La fonction Encode encode en pourcentage les caractères spéciaux et les espaces dans les paramètres d’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 fonction main crée une nouvelle instance de structure Values du package url et la méthode Add de l’instance de structure ajoute des paires clé-valeur de données à l’instance de structure.
La méthode Encode convertit la paire clé-valeur au format de chaîne d’URL « clé1=valeur1&clé2=valeur2&clé3=valeur3 ».
Vous pouvez décoder une chaîne d’URL codée avec la fonction ParseQuery du package d’ 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 variable encodedParameter est une chaîne d’URL codée. La fonction ParseQuery prend la variable encodedParameter et renvoie la chaîne d’URL décodée et une erreur.
Ces packages Go peuvent faire passer votre jeu de routage Web au niveau supérieur
Les URL que vous utilisez pour les pages de votre application web contribuent à ses performances et à sa visibilité sur les moteurs de recherche. Le routage Web est le processus consistant à diriger les demandes entrantes vers la fonction de gestionnaire appropriée en fonction de l’URL.
Vous pouvez router à l’aide du package http ou de packages tiers populaires tels que Gorilla Mux, Chi, Pat ou Httprouter. Ces packages rendent le routage plus facile que le package http en éliminant certaines de ses complexités.
Laisser un commentaire