Les URL (localisateurs de ressources uniformes) 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 les URL à un niveau plus fin. Vous devrez peut-être identifier le schéma, le nom d’hôte, le chemin et les paramètres d’interrogation. Vous devrez également savoir comment coder 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 leurs composants.
Le paquetage URL
Le site url Le paquet url fournit des fonctions et des caractéristiques complètes pour travailler avec les URL et leurs parties séparées. Il fournit des fonctions d’analyse syntaxique, de construction, d’encodage et de décodage des URL, ce qui le rend utile pour le développement Web.
Certaines des caractéristiques clés du paquetage url sont la capacité d’analyser les URL en composants individuels pour la manipulation et la construction d’URL pour les demandes HTTP. Le paquet url Le paquet fournit également un URL struct avec un Analyser Méthode d’analyse syntaxique des chaînes de caractères en URL.
Voici le url.URL modèle struct :
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 du URL struct peut être utile pour des tâches comme la validation.
Analyse des URL à l’aide de la fonction Parse
Le site Parse fonction de la url fournit la fonctionnalité permettant d’analyser les chaînes d’URL en composants individuels. L’adresse Analyser prend une URL unique comme argument et renvoie un pointeur vers le fichier de données de l’URL. url.URL struct contenant les données analysées de l’URL et un type d’erreur.
Voici comment vous pouvez utiliser la méthode 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)
}
Le site exempleURL contient l’URL complète, non analysée, et la variable Analyser La fonction Parse analyse le contenu du fichier exempleURL et renvoie l’URL analysée. Le programme se termine par une série d’appels à Println pour démontrer les différents champs de l URL struct.
La fonction parse ne vérifie pas si une URL est une URL réelle qui existe réellement, elle analyse seulement la syntaxe de l’URL. Vous pouvez utiliser la fonction http pour effectuer une requête GET vers 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.")
}
}
Le site principal La fonction GET demande au exempleURL en utilisant le Obtenez fonction de la http paquet. Cette fonction renvoie une instance de réponse et un type d’erreur. Le programme se termine par un si pour valider l’existence du site Web en vérifiant le code d’état HTTP par rapport à l’indicateur d’état du site Web. StatusOk constante de la http paquet.
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 temps.
Codage et décodage des paramètres d’URL
Le site url fournit le paquet Encoder pour le codage des paramètres d’URL. L’adresse Encoder fonction pour cent-encode les caractères spéciaux et les espaces dans les paramètres 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"
}
Le site principal La fonction crée une nouvelle Valeurs instance structurée de la url et le paquet Ajouter de l’instance struct ajoute des paires clé-valeur de données à l’instance struct.
Le site Encoder convertit la paire clé-valeur au format de chaîne URL « key1=value1&key2=value2&key3=value3 ».
Vous pouvez décoder une chaîne URL encodée avec la méthode ParseQuery fonction de la url paquet.
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]]
}
Le site encodedParameter est une chaîne URL codée. L’adresse ParseQuery prend en compte la fonction Paramètre codé et renvoie la chaîne URL décodée et une erreur.
Ces paquets Go peuvent faire passer votre jeu de routage Web au niveau supérieur
Les URLs que vous utilisez pour les pages de votre application web contribuent à sa performance et à sa visibilité sur les moteurs de recherche. Le routage Web est le processus qui consiste à diriger les demandes entrantes vers la fonction de traitement appropriée en fonction de l’URL.
Vous pouvez router en utilisant le paquet http ou des paquets tiers populaires comme Gorilla Mux, Chi, Pat ou Httprouter. Ces paquets rendent le routage plus facile que le paquet http en faisant abstraction de certaines de ses complexités.