URL Parser

Vad är URL-parsning?

URL-parsning är processen att dela upp en Uniform Resource Locator i dess enskilda komponenter: protokoll (schema), värdnamn, port, sökväg, frågeparametrar och fragmentidentifierare. Varje URL följer en struktur definierad av RFC 3986 och WHATWG URL Standard. En URL-parser läser rå-strängen, identifierar varje segment utifrån avgränsningstecken (://, :, /, ?, #, &, =) och returnerar dem som separata, åtkomliga fält.

Webbläsare utför URL-parsning varje gång du skriver in en adress eller klickar på en länk. JavaScripts URL-konstruktor, Pythons urllib.parse-modul och Gos net/url-paket implementerar alla parsers som följer samma strukturregler. Att parsa en URL är det omvända mot URL-kodning: istället för att transformera tecken för säker transport delar du upp en redan sammansatt URL i de delar som bygger upp den.

En typisk URL som https://api.example.com:8080/v1/users?page=2&limit=10#section innehåller sex distinkta komponenter. Avgränsningstecknen — ://, :, /, ?, &, = och # — gör parsningen deterministisk: vart och ett signalerar en gräns och låter en parser extrahera fält utan tvetydighet.

Varför använda en URL-parser online?

Att manuellt dela upp en URL för hand är felkänsligt, särskilt när strängen innehåller kodade tecken, flera frågeparametrar eller icke-standardiserade portar. Det här verktyget parsar URL:en med samma WHATWG-kompatibla algoritm som webbläsare använder och visar varje komponent i en tydlig tabell som enkelt kan kopieras.

Användningsfall för URL Parser

Referens för URL-komponenter

Tabellen nedan visar alla egenskaper som returneras av JavaScripts URL-konstruktor vid parsning av en URL. Samma komponenter finns i Pythons urlparse-resultat, Gos url.URL-struct och PHPs parse_url-utdata, även om egenskapsnamnen skiljer sig åt mellan språken.

WHATWG URL Standard vs RFC 3986

Två specifikationer definierar hur URL:er ska parsas. De är överens om den grundläggande strukturen men skiljer sig i gränsfall — och den skillnaden är oftast orsaken till att din webbläsare hanterar en URL annorlunda än din server gör.

I praktiken uppstår de flesta skillnaderna vid parsning av URL:er med internationella domännamn (IDN), saknade scheman eller ovanliga tecken. WHATWG-parsern konverterar IDN-värdnamn till Punycode automatiskt, medan strikta RFC 3986-parsers kan avvisa dem. Om du klistrar in en URL i det här verktyget och ser andra resultat än din server-side-kod producerar är WHATWG vs RFC-skillnaden den troligaste orsaken.

Kodexempel

Alla större programspråk har en inbyggd URL-parser. Exemplen nedan parsar samma URL och extraherar dess komponenter. Notera de mindre namngivningsskillnaderna mellan språken: Python använder scheme istället för protocol, och Go exponerar RawQuery istället för 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"

Vanliga frågor