Analisador de URL

O que é análise de URL?

Análise de URL é o processo de decompor um Localizador Uniforme de Recursos nos seus componentes individuais: protocolo (scheme), hostname, porta, caminho, parâmetros de consulta e identificador de fragmento. Toda URL segue uma estrutura definida pelo RFC 3986 e pelo WHATWG URL Standard. Um analisador de URL lê a string bruta, identifica cada segmento pelos seus caracteres delimitadores (://, :, /, ?, #, &, =) e os retorna como campos separados e acessíveis.

Os navegadores realizam análise de URL toda vez que você digita um endereço ou clica em um link. O construtor URL do JavaScript, o módulo urllib.parse do Python e o pacote net/url do Go implementam analisadores que seguem as mesmas regras estruturais. Analisar uma URL é o inverso da codificação de URL: em vez de transformar caracteres para transporte seguro, você decompõe uma URL já formada nas partes que a compõem.

Uma URL típica como https://api.example.com:8080/v1/users?page=2&limit=10#section contém seis componentes distintos. Os caracteres delimitadores — ://, :, /, ?, &, = e # — são o que torna a análise determinística: cada um sinaliza um limite e permite ao analisador extrair campos sem ambiguidade.

Por que usar um analisador de URL online?

Dividir uma URL manualmente é sujeito a erros, especialmente quando a string contém caracteres codificados, múltiplos parâmetros de consulta ou portas não padrão. Esta ferramenta analisa a URL usando o mesmo algoritmo compatível com WHATWG que os navegadores utilizam e exibe cada componente em uma tabela clara e copiável.

Casos de uso do analisador de URL

Referência de componentes de URL

A tabela abaixo mostra cada propriedade retornada pelo construtor URL do JavaScript ao analisar uma URL. Os mesmos componentes existem no resultado de urlparse do Python, na struct url.URL do Go e na saída de parse_url do PHP, embora os nomes das propriedades difiram entre linguagens.

WHATWG URL Standard vs RFC 3986

Duas especificações definem como as URLs devem ser analisadas. Elas concordam na estrutura básica, mas divergem em casos extremos — e essa divergência é geralmente a causa quando seu navegador trata uma URL de forma diferente do seu servidor.

Na prática, a maioria das diferenças aparece ao analisar URLs com nomes de domínio internacionais (IDN), schemes ausentes ou caracteres incomuns. O analisador WHATWG converte hostnames IDN para Punycode automaticamente, enquanto analisadores estritos do RFC 3986 podem rejeitá-los. Se você colar uma URL nesta ferramenta e ver resultados diferentes dos que seu código no servidor produz, a diferença entre WHATWG e RFC é a causa mais provável.

Exemplos de código

Toda linguagem popular tem um analisador de URL integrado. Os exemplos abaixo analisam a mesma URL e extraem seus componentes. Observe as pequenas diferenças de nomenclatura entre linguagens: Python usa scheme em vez de protocol, e Go expõe RawQuery em vez de search.

const url = new URL('https://api.example.com:8080/v1/users?page=2&limit=10#section')

url.protocol  // → "https:"
url.hostname  // → "api.example.com"
url.port      // → "8080"
url.pathname  // → "/v1/users"
url.search    // → "?page=2&limit=10"
url.hash      // → "#section"

// Iterate over query parameters
for (const [key, value] of url.searchParams) {
  console.log(`${key} = ${value}`)
}
// → "page = 2"
// → "limit = 10"

// Modify and re-serialize
url.searchParams.set('page', '3')
url.toString()
// → "https://api.example.com:8080/v1/users?page=3&limit=10#section"

from urllib.parse import urlparse, parse_qs

result = urlparse('https://api.example.com:8080/v1/users?page=2&limit=10#section')

result.scheme    # → 'https'
result.hostname  # → 'api.example.com'
result.port      # → 8080
result.path      # → '/v1/users'
result.query     # → 'page=2&limit=10'
result.fragment  # → 'section'

# Parse query string into a dict
params = parse_qs(result.query)
params['page']   # → ['2']
params['limit']  # → ['10']

# Reconstruct with modifications
from urllib.parse import urlencode, urlunparse
new_query = urlencode({'page': '3', 'limit': '10'})
urlunparse(result._replace(query=new_query))
# → 'https://api.example.com:8080/v1/users?page=3&limit=10#section'

package main

import (
	"fmt"
	"net/url"
)

func main() {
	u, err := url.Parse("https://api.example.com:8080/v1/users?page=2&limit=10#section")
	if err != nil {
		panic(err)
	}

	fmt.Println(u.Scheme)   // → "https"
	fmt.Println(u.Hostname()) // → "api.example.com"
	fmt.Println(u.Port())     // → "8080"
	fmt.Println(u.Path)       // → "/v1/users"
	fmt.Println(u.RawQuery)   // → "page=2&limit=10"
	fmt.Println(u.Fragment)   // → "section"

	// Query params as map
	q := u.Query()
	fmt.Println(q.Get("page"))  // → "2"
	fmt.Println(q.Get("limit")) // → "10"
}

<?php
$url = 'https://api.example.com:8080/v1/users?page=2&limit=10#section';
$parts = parse_url($url);

$parts['scheme'];   // → "https"
$parts['host'];     // → "api.example.com"
$parts['port'];     // → 8080
$parts['path'];     // → "/v1/users"
$parts['query'];    // → "page=2&limit=10"
$parts['fragment']; // → "section"

// Parse query string into an array
parse_str($parts['query'], $params);
$params['page'];    // → "2"
$params['limit'];   // → "10"

Perguntas frequentes