Parser di Componenti URL

Analizza qualsiasi URL o URI localmente nel browser dividendolo in schema, credenziali, host, TLD, porta, segmenti di percorso, parametri query e hash secondo.

Nessun caricamentoNessuna registrazioneRisultati istantanei
Ispettore URL RFC 3986 / WHATWGEditor dal vivo Host · Percorso · Query · Hash100% Locale • Zero Upload
Analizza e modifica URL
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Parser di Componenti URL gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Scomposizione Componenti WHATWG e RFC 3986

Isola schema, credenziali userinfo, origin, hostname, sottodominio, dominio registrabile, TLD, porta esplicita o predefinita, segmenti di path indicizzati, coppie query e frammento hash.

Ricostruzione Bidirezionale Live dell'URL

Modifica i singoli campi — cambiando hostname, porte, segmenti del percorso o valori dei parametri query — e riassembla istantaneamente un URL normalizzato.

Supporto IDN, IPv6 e Schemi URI Personalizzati

Gestisce domini internazionalizzati Punycode (xn--), letterali IPv6 tra parentesi quadre ([::1]:8080), schemi deep-link non HTTP (myapp://) ed endpoint interni con porta esplicita.

Ispezione 100% Client-Side Senza Invio Dati

Viene eseguito interamente nella memoria del browser: URL di redirect OAuth, link pre-firmati AWS S3, token webhook e credenziali basic-auth non vengono mai trasmessi a nessun server.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Scomposizione Componenti WHATWG e RFC 3986 Isola schema, credenziali userinfo, origin, hostname, sottodominio, dominio registrabile, TLD, porta esplicita o predefinita, segmenti di path indicizzati, coppie query e frammento hash. Opzioni limitate senza personalizzazione avanzata
Ricostruzione Bidirezionale Live dell'URL Modifica i singoli campi — cambiando hostname, porte, segmenti del percorso o valori dei parametri query — e riassembla istantaneamente un URL normalizzato. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Parser di Componenti URL in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Incolla o Carica un URL

Inserisci un indirizzo HTTP(S), uno schema URI personalizzato, un endpoint di servizio IPv6 o un link di callback firmato nel campo di input, oppure trascina un file di testo.

2

Ispeziona i Campi URI Scomposti

Esamina origin analizzato, credenziali di authority, suddivisione sottodominio/dominio/TLD, elenco decodificato dei segmenti di path, parametri chiave-valore della query e identificatore di frammento.

3

Modifica i Componenti e Copia il Risultato

Modifica qualsiasi componente in modo indipendente — sostituisci gli host di staging, cambia i numeri di porta o aggiorna i parametri — e copia l'URL ricostruito o la struttura JSON.

Come Funzionano il Parsing dei Componenti URL e la Ricostruzione Live

Risposta Rapida: Un parser URL tokenizza un Uniform Resource Identifier lungo i delimitatori strutturali RFC 3986 (://, @, :, /, ?, #), isolando authority, segmenti gerarchici del percorso, parametri query e stato del frammento in modo che ogni campo possa essere ispezionato o modificato senza tagliare manualmente le stringhe.

Le espressioni regolari manuali e i semplici helper basati su split('/') falliscono spesso quando incontrano credenziali basic-auth, porte esplicite, barre codificate in percentuale (%2F), suffissi pubblici multi-parte come .co.uk o punti interrogativi incorporati all'interno dei frammenti hash. Un parser conforme alle specifiche analizza i delimitatori in rigoroso ordine sintattico prima di decodificare i singoli componenti.

Consideriamo un complesso URL di consegna webhook contenente credenziali, un sottodominio multilivello, una porta TLS non predefinita, un segmento di percorso codificato, parametri query e un'ancora di frammento:

https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

La scomposizione di questo URI produce proprietà distinte e modificabili singolarmente:

{
  "href": "https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log",
  "protocol": "https:",
  "scheme": "https",
  "username": "deploy",
  "password": "tok_9f8a",
  "origin": "https://staging.api.example.co.uk:8443",
  "host": "staging.api.example.co.uk:8443",
  "hostname": "staging.api.example.co.uk",
  "subdomain": "staging.api",
  "domain": "example.co.uk",
  "tld": "co.uk",
  "port": "8443",
  "pathname": "/v2/orgs/acme%20corp/webhooks",
  "pathSegments": ["v2", "orgs", "acme corp", "webhooks"],
  "search": "?event=push&active=true",
  "queryParams": {
    "event": "push",
    "active": "true"
  },
  "hash": "#delivery-log"
}

Modificare i Componenti Senza Corrompere le Sequenze di Escape

Durante il debug tra ambienti diversi, capita spesso di dover reindirizzare un URL di callback di produzione o di staging verso un servizio locale mantenendo intatti la codifica esatta del percorso e i payload firmati della query. Cambiando scheme in http, hostname in localhost, port in 3000 e rimuovendo username/password, si ricostruisce in modo pulito:

http://localhost:3000/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

Si noti che il terzo segmento del percorso (acme corp) mantiene automaticamente la sua codifica percentuale %20 all'interno di pathname, prevenendo il troncamento degli spazi bianchi nelle righe di richiesta HTTP o nei log Markdown.

Sintassi URI Generica RFC 3986 vs lo Standard WHATWG URL

Risposta Rapida: L'RFC 3986 definisce regole grammaticali ABNF stateless per gli URI generici, mentre i browser moderni, Node.js, Deno e Cloudflare Workers implementano il WHATWG URL Living Standard, che applica la normalizzazione degli schemi speciali, l'omissione della porta predefinita, la conversione dei backslash e la codifica IDNA Punycode UTS #46.

Comprendere le sottili divergenze tra l'RFC 3986 e lo standard WHATWG URL previene bug di routing, errori nella verifica delle firme e vulnerabilità Server-Side Request Forgery (SSRF).

Grammatica Strutturale Canonica (RFC 3986 Sezione 3)

L'RFC 3986 suddivide ogni URI generico in cinque componenti principali con precedenza fissa da sinistra a destra:

  foo://user:pass@example.com:8042/over/there?name=ferret#nose
  \_/   \_______________________/ \_________/ \_________/ \__/
   |                |                  |           |        |
scheme          authority             path       query   fragment
  • Scheme (Schema): Deve iniziare con una lettera ASCII seguita da lettere, cifre, +, - o . (ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )). Viene normalizzato in minuscolo.
  • Authority (Autorità): Preceduta da // e terminata dal successivo /, ?, # o dalla fine della stringa. Si suddivide in userinfo@ opzionale, host (nome registrato, indirizzo IPv4 o letterale [IPv6] tra parentesi quadre) e :port opzionale.
  • Path (Percorso): Sequenza gerarchica di segmenti separati da /. I segmenti punto (. e ..) vengono risolti tramite l'algoritmo remove_dot_segments (RFC 3986 Sezione 5.2.4).
  • Query: Introdotta dal primo ? dopo il percorso e terminata da # o dalla fine della stringa.
  • Fragment (Frammento): Introdotto da #, consuma tutti i caratteri rimanenti fino alla fine dell'URI, inclusi eventuali caratteri ? o / successivi.

Schemi Speciali WHATWG vs Percorsi Opachi

La macchina a stati WHATWG URL designa sei schemi come speciali: http, https, ws, wss, ftp e file. Gli URL speciali subiscono una rigorosa normalizzazione che gli schemi non speciali (mailto:, urn:, data:, myapp://) ignorano:

  1. Omissione della Porta Predefinita: https://example.com:443/api viene serializzato come https://example.com/api con port impostato su "" perché 443 corrisponde alla porta predefinita per https (80 per http/ws, 443 per https/wss, 21 per ftp). Gli schemi personalizzati come redis://cache.internal:6379 mantengono :6379.
  2. Normalizzazione dei Backslash: Negli schemi speciali, le barre rovesciate (\) all'interno dell'authority e dei segmenti di percorso vengono normalizzate in barre normali (/), mentre gli schemi non speciali trattano \ come un carattere di percorso opaco.
  3. Slash del Percorso Vuoto: https://example.com viene serializzato con uno slash finale di root (pathname = "/"), mentre custom://host può avere un pathname vuoto.
  4. Conversione Punycode IDNA: Le etichette di dominio Unicode come https://münchen.example/path vengono convertite tramite UTS #46 in ASCII Compatible Encoding (https://xn--mnchen-3ya.example/path) nella proprietà hostname.

Letterali IPv6 e Suffissi Pubblici Multi-Etichetta

Gli indirizzi IPv6 contengono due punti che entrerebbero in conflitto con il delimitatore :port se non fossero racchiusi tra parentesi quadre secondo l'RFC 2732, come in http://[2001:db8:85a3::8a2e:370:7334]:8080/health. Inoltre, la scomposizione di un hostname in sottodominio, dominio registrabile e TLD non può basarsi sulla semplice divisione all'ultimo punto: i domini di secondo livello nazionali (example.co.uk, app.com.au) e i suffissi di piattaforma richiedono il riconoscimento dei suffissi multi-etichetta affinché co.uk venga identificato come TLD effettivo anziché solo uk.

Nota sulla Sicurezza: Differenziali di Parsing e SSRF

Le allowlist di sicurezza falliscono quando un proxy convalida un URL utilizzando una regex RFC 3986 permissiva mentre il client HTTP a monte effettua la richiesta usando un parser WHATWG. Gli input contenenti più delimitatori @ (https://allowed.example@169.254.169.254/latest/meta-data/) o barre rovesciate (https://attacker.example\@allowed.example/) possono indurre un parser a leggere allowed.example come host mentre il client HTTP si connette a 169.254.169.254 o attacker.example. Convalida sempre origin e hostname dopo il parsing utilizzando l'esatta normalizzazione WHATWG impiegata dal tuo client HTTP, e rimuovi o rifiuta campi authority username/password inattesi.

Parser di Componenti URL vs Parser di Query String vs Codificatore URL: Quale Strumento Scegliere?

Risposta Rapida: Usa il Parser di Componenti URL per ispezionare e ricostruire l'intera struttura URI tra schema, authority, host, porta, percorso, query e hash. Usa il Parser di Query String per modificare query annidate complesse e convertirle in JSON, oppure il Codificatore e Decodificatore URL per eseguire l'escape di stringhe grezze.

Le operazioni di manipolazione degli URL si dividono in livelli sintattici distinti. Scegliere lo strumento progettato per il livello esatto su cui stai lavorando evita la doppia codifica dei delimitatori o la perdita dei tipi nei parametri annidati.

Funzionalità Parser di Componenti URL (Questo Strumento) Parser di Query String Codificatore e Decodificatore URL Codificatore Percentuale
Input Principale URL completo o URI personalizzato ?a=1&b=2, body di form o JSON Stringa grezza o componente URL codificato Testo grezzo che richiede escape RFC 3986 %XX rigoroso
Suddivisione Authority, Host, Porta e TLD Analisi completa + modifica live Rimuove le parti dell'URL esterne alla query Nessun parsing strutturale Nessun parsing strutturale
Ispezione Segmenti del Percorso Array indicizzato dei segmenti decodificati Non applicabile Nessun parsing strutturale Nessun parsing strutturale
Array Query Annidati e Parentesi Ispezione piatta chiave-valore della query Supporto completo tag[]=a, filter[k]=v e sync JSON Non applicabile Non applicabile
Controllo Codifica Spazi (+ vs %20) Regole standard dei componenti URI Serializzazione + o %20 configurabile Supporta escape di componenti e form Codifica byte RFC 3986 %20 rigorosa

Quando Passare a uno Strumento Correlato

  • Modificare filtri API profondamente annidati o convertire i parametri query in JSON: Apri il Parser di Query String quando lavori con chiavi di array ripetute (?id=1&id=2), notazione tra parentesi quadre in stile qs (filter[status]=open), payload POST application/x-www-form-urlencoded o fixture di test JSON.
  • Codificare o decodificare il valore isolato di un parametro: Usa il Codificatore e Decodificatore URL quando hai una stringa grezza contenente &, =, + o caratteri Unicode che devono essere sottoposti a escape sicuro secondo la semantica encodeURIComponent prima dell'inserimento.
  • Escape rigoroso a livello di byte RFC 3986 per OAuth / AWS SigV4: Usa il Codificatore Percentuale durante la firma di richieste canoniche in cui caratteri come !, ', (, ) e * devono essere codificati in esadecimale.
  • Generare segmenti di percorso SEO puliti a partire dai titoli: Usa Pulisci URL e Percorsi (Slugify) per traslitterare titoli leggibili in slug di percorso minuscoli separati da trattini.
Domande frequenti

FAQ e Guida Tecnica su Parser di Componenti URL

Tutto ciò che devi sapere sull'uso di parser url online e gratuito di Utiliome.

Qual è la differenza tra host, hostname e origin in un URL analizzato?

Nella specifica WHATWG URL, hostname contiene solo il nome di dominio o il letterale IPv6 tra parentesi quadre (api.example.com o [::1]). host aggiunge :port solo quando è presente una porta esplicita non predefinita (api.example.com:8443, oppure api.example.com se si utilizza la porta 443 su https). origin antepone lo schema e il delimitatore :// a host (https://api.example.com:8443), rappresentando il perimetro di sicurezza Web utilizzato da CORS e postMessage.

Perché una query string dopo un hash (#) rimane dentro il frammento invece che in queryParams?

Secondo l'RFC 3986 Sezione 3.5, il primo delimitatore # termina il componente path o query e avvia l'identificatore di frammento, che si estende fino alla fine dell'URI. Nei link delle Single-Page Application basate su hash routing come https://app.example.com/#/orders?status=paid, ?status=paid fa parte dell'hash lato client (#/orders?status=paid) e non viene mai inviato al server HTTP. Per analizzare i parametri incorporati in una rotta hash, copia la sottostringa che inizia con ? nel Parser di Query String.

Perché le porte predefinite come :80 e :443 scompaiono quando si ricostruisce un URL HTTP o HTTPS?

Gli schemi speciali nello standard WHATWG URL definiscono porte predefinite (80 per http e ws, 443 per https e wss, 21 per ftp). Quando un URL specifica esplicitamente la porta predefinita del suo schema — come https://example.com:443/v1 — i normalizzatori conformi omettono :443 durante la serializzazione canonica in modo che gli origin equivalenti vengano confrontati in modo identico. Le porte non predefinite come :8443 o :3000 vengono invece sempre mantenute.

Come vengono gestite le barre codificate in percentuale (%2F) all'interno dei segmenti del percorso?

I delimitatori strutturali / vengono suddivisi prima che avvenga la decodifica percentuale. In /repos/acme%2Fcore/commits, la suddivisione iniziale produce tre segmenti (["repos", "acme%2Fcore", "commits"]) e la successiva decodifica a livello di singolo segmento restituisce acme/core come identificatore unico. Decodificare %2F prima della divisione del percorso creerebbe erroneamente quattro segmenti e comprometterebbe il matching delle rotte REST.

È sicuro ispezionare qui URL di callback OAuth o URL pre-firmati AWS S3?

Sì. Tutte le operazioni di parsing dell'URL, modifica dei componenti e serializzazione JSON vengono eseguite al 100% localmente all'interno del runtime JavaScript del tuo browser. Nessuna richiesta di rete, beacon di analisi o log lato server entra mai in contatto con gli URL incollati, i parametri X-Amz-Signature, i codici di autorizzazione code o le credenziali userinfo.