Trabalhando com URLs usando o pacote net/url do Go
URLs (Uniform Resource Locators) são uma das peças mais críticas da infraestrutura da Internet. À medida que você cria aplicativos da Web, precisará manipular URLs para localizar e recuperar recursos.
Ao criar aplicativos da Web mais sofisticados, você precisará trabalhar com URLs em um nível mais refinado. Pode ser necessário identificar o esquema, o nome do host, o caminho e os parâmetros de consulta. Você também precisará saber como codificar e decodificar URLs para poder lidar com caracteres especiais e manter seu aplicativo da Web seguro.
A biblioteca padrão do Go fornece o pacote net/url para lidar com URLs e componentes de URL.
O pacote de URLs
O pacote url fornece funções e recursos abrangentes para trabalhar com URLs e suas partes separadas. Ele fornece funções para analisar, construir, codificar e decodificar URLs, tornando o pacote útil para desenvolvimento web.
Alguns dos principais recursos do pacote url são a capacidade de analisar URLs em componentes individuais para manipulação e construção de URL para solicitações HTTP. O pacote url também fornece uma estrutura de URL com um método Parse para analisar strings em URLs.
Aqui está o modelo de estrutura 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
}
Saber como acessar várias partes da estrutura do URL pode ser útil para tarefas como validação.
Analisando URLs usando a função Parse
A função Parse do pacote url fornece a funcionalidade para analisar strings de URL em componentes individuais. A função Parse usa uma única URL como argumento e retorna um ponteiro para a estrutura url.URL contendo os dados analisados da URL e um tipo de erro.
Veja como você pode usar a função Parse para recuperar os elementos de uma 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)
}
A variável exampleURL contém o URL completo não analisado e a função Parse analisa o conteúdo da variável exampleURL e retorna o URL analisado. O programa termina com uma série de chamadas para Println para demonstrar os campos individuais da estrutura de URL .
A função parse não verifica se uma URL é real e realmente existe, ela apenas analisa a URL sintaticamente. Você pode usar o pacote http para fazer uma solicitação GET para a URL e verificar a resposta:
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.")
}
}
A função principal faz uma solicitação GET para exampleURL usando a função Get do pacote http . Essa função retorna uma instância de resposta e um tipo de erro. O programa termina com uma instrução if para validar a existência do site verificando o código de status HTTP em relação à constante StatusOk do pacote http .
Essa abordagem permite que você execute ações com base no resultado da verificação, como redirecionar o usuário para uma página diferente, exibir uma mensagem de erro ou repetir a solicitação após um determinado período.
Codificação e decodificação de parâmetros de URL
O pacote url fornece o método Encode para codificar parâmetros de URL. A função Encode codifica caracteres especiais e espaços em parâmetros de 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"
}
A função main cria uma nova instância Values struct do pacote url , e o método Add da instância struct adiciona pares chave-valor de dados à instância struct.
O método Encode converte o par chave-valor no formato de string de URL “key1=value1&key2=value2&key3=value3”.
Você pode decodificar uma string de URL codificada com a função ParseQuery do pacote 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]]
}
A variável encodedParameter é uma string de URL codificada. A função ParseQuery recebe a variável encodedParameter e retorna a string de URL decodificada e um erro.
Esses pacotes Go podem levar seu jogo de roteamento da Web para o próximo nível
As URLs que você usa para as páginas do seu aplicativo da web contribuem para seu desempenho e visibilidade nos mecanismos de pesquisa. O roteamento da Web é o processo de direcionar solicitações de entrada para a função de manipulador apropriada com base na URL.
Você pode rotear usando o pacote http ou pacotes populares de terceiros, como Gorilla Mux, Chi, Pat ou Httprouter. Esses pacotes tornam o roteamento mais fácil do que o pacote http, abstraindo algumas de suas complexidades.
Deixe um comentário