Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado. Consulte Mais informação.

URLs (Uniform Resource Locators) são uma das peças mais críticas da infraestrutura da Internet. Ao criar aplicativos da Web, você 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 url pacote 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.

Algumas das principais características do url pacote são a capacidade de analisar URLs em componentes individuais para manipulação e construção de URL para solicitações HTTP. O url pacote também fornece um URL estrutura com um Analisar método para analisar strings em URLs.

Aqui está o url. URL modelo de estrutura:

pacote principal
tipo URL estrutura {
// Esquema é o esquema de protocolo da URL,
// como "http" ou "https"
 Esquema corda


// Opaque é usado para manter quaisquer dados opacos
// que deve ser codificado na URL
 Opaco corda


// O usuário contém informações sobre o usuário que está fazendo a solicitação,
// como um nome de usuário e senha
 Usuário *Informações do usuário


// Host é o nome do host ou endereço IP
// do servidor que hospeda a URL
 Hospedar corda


// Path é o caminho da URL no servidor
 Caminho corda


// RawPath é o original,
// caminho codificado da URL
 RawPath corda


// ForceQuery indica se a URL deve incluir uma query string
// mesmo que esteja vazio
 ForceQuery bool


// RawQuery é o original,
// string de consulta codificada da URL
 RawQuery corda


// Fragmento é o identificador de fragmento da URL, 
// usado para vincular a um elemento específico em uma página
 Fragmento corda
// RawFragment é o original,
// identificador de fragmento codificado da URL
 RawFragment corda
}

Saber como acessar várias partes do URL struct pode ser útil para tarefas como validação.

Analisando URLs usando a função Parse

O Analisar função do url O pacote fornece a funcionalidade para analisar strings de URL em componentes individuais. O Analisar A função usa um único URL como argumento e retorna um ponteiro para o url. URL struct contendo os dados analisados ​​da URL e um tipo de erro.

Veja como você pode usar o Analisar função para recuperar os elementos de um URL.

importar (
"fmt"
"rede/url"
)
funçãoprincipal() {
// A URL que você deseja analisar
 url de exemplo := " https://www.example.com/path? param1=valor1&param2=valor2"


// Analisa a URL
 parsedURL, erro := url. Analisar (exampleURL)


se erro != nada {
 fmt. Println (err)
retornar
 }
// Imprime todos os campos da URL
 fmt. Imprimirln("Esquema:", parsedURL.Scheme)
 fmt. Imprimirln("Opaco:", parsedURL.Opaco)
 fmt. Imprimirln("Do utilizador:", parsedURL.User)
 fmt. Imprimirln("Hospedar:", parsedURL.Host)
 fmt. Imprimirln("Caminho:", parsedURL.Path)
 fmt. Imprimirln("RawPath:", parsedURL.RawPath)
 fmt. Imprimirln("ForçarConsulta:", parsedURL.ForceQuery)
 fmt. Imprimirln("RawQuery:", parsedURL.RawQuery)
 fmt. Imprimirln("Fragmento:", parsedURL.Fragment)
 fmt. Imprimirln("RawFragment:", parsedURL.RawFragment)
}

O url de exemplo variável contém o URL completo e não analisado e o Analisar função analisa o conteúdo do url de exemplo variável e retorna a URL analisada. O programa termina com uma série de chamadas para Println para demonstrar os campos individuais do URL struct.

A função parse não verifica se uma URL é real e realmente existe, apenas analisa a URL sintaticamente. Você pode usar o http pacote para fazer uma solicitação GET para a URL e verificar a resposta:

importar (
"fmt"
"rede/http"
)
funçãoprincipal() {
// A URL que você deseja verificar
 url de exemplo := " https://www.example.com"


// Faça uma solicitação HTTP GET para a URL
 resposta, erro := http. Obter (exampleURL)


se erro != nada {
 fmt. Println (err)
retornar
 }
adiar resposta. Corpo. Fechar()

// Verifica o código de status da resposta
se resposta. StatusCode == http. Estado OK {
 fmt. Imprimirln("URL existe.")
 } outro {
 fmt. Imprimirln("A URL não existe.")
 }
}

O principal função faz um PEGAR pedido ao url de exemplo usando o Pegar função do http pacote. Essa função retorna uma instância de resposta e um tipo de erro. O programa termina com uma se declaração para validar a existência do site, verificando o Código de status HTTP contra o StatusOk constante do http pacote.

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, exibindo uma mensagem de erro ou repetindo a solicitação após um determinado período.

Codificação e decodificação de parâmetros de URL

O url pacote fornece o Codificar método para codificar parâmetros de URL. O Codificar função codifica caracteres especiais e espaços em parâmetros de URL.

importar (
"fmt"
"rede/url"
)
funçãoprincipal() {
// cria uma nova url. Estrutura de valores
 parâmetros := url. Valores{}


// adiciona valores ao struct
 parâmetros Adicionar("nome", "João Smith")
 parâmetros Adicionar("idade", "30")
 parâmetros Adicionar("gênero", "macho")


// codifica a estrutura em uma string
 encodedParams := params. Codificar()
 fmt. Println (encodedParams)
// Output: "age=30&gender=male&name=John+Smith"
}

O principal função cria um novo valores instância de estrutura do url pacote, e o Adicionar O método da instância struct adiciona pares de dados chave-valor à instância struct.

O Codificar O método 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 o ParseQuery função do url pacote.

importar (
"fmt"
"rede/url"
)
funçãoprincipal() {
// string codificada de parâmetros de URL
 parâmetros codificados := "idade=30&gênero=masculino&nome=John+Smith"


// analisa a string codificada em um url. Estrutura de valores
 parametros, erro := url. ParseQuery (encodedParams)


se erro != nada {
 fmt. Println (err)
 }


// imprime a estrutura
 fmt. Println (parâmetros)


// Output: map[age:[30] gender:[male] name:[John Smith]]
}

O parâmetro codificado variável é uma string de URL codificada. O ParseQuery função leva em parâmetro codificado variável 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.