URL-parser (Komponentuppdelare)

Dela upp valfri URL eller URI lokalt i webbläsaren i protokoll, värd, TLD, port, sökväg, parametrar och hash med direkt redigering enligt RFC 3986.

Inga uppladdningarIngen registreringOmedelbara resultat
RFC 3986 / WHATWG URL-inspektörLiveredigerare för värd · sökväg · fråga · hash100% Lokalt • Noll Uppladdningar
Tolka & redigera URL
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis URL-parser (Komponentuppdelare)?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Komponentuppdelning enligt WHATWG & RFC 3986

Delar upp schema (scheme), autentiseringsuppgifter (userinfo), origin, värdnamn, subdomän, registrerbar domän, toppdomän (TLD), explicit eller standardport, indexerade sökvägssegment, query-par och hash-fragment.

Dubbelriktad URL-rekonstruktion i realtid

Redigera enskilda fält – som att byta värdnamn, ändra portar, uppdatera sökvägssegment eller modifiera query-värden – och bygg omedelbart ihop en normaliserad URL.

Stöd för IDN, IPv6 & anpassade URI-scheman

Hanterar internationaliserade Punycode-domäner (xn--), IPv6-adresser inom hakparenteser ([::1]:8080), icke-HTTP-scheman för djuplänkar (myapp://) och interna endpoints med explicita portar.

100 % klientbaserad inspektion utan dataläckage

Körs helt i webbläsarens minne så att OAuth-omdirigeringslänkar, försignerade AWS S3-URL:er, webhook-tokens och inloggningsuppgifter aldrig skickas till någon server.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Komponentuppdelning enligt WHATWG & RFC 3986 Delar upp schema (scheme), autentiseringsuppgifter (userinfo), origin, värdnamn, subdomän, registrerbar domän, toppdomän (TLD), explicit eller standardport, indexerade sökvägssegment, query-par och hash-fragment. Begränsade alternativ utan avancerad anpassning
Dubbelriktad URL-rekonstruktion i realtid Redigera enskilda fält – som att byta värdnamn, ändra portar, uppdatera sökvägssegment eller modifiera query-värden – och bygg omedelbart ihop en normaliserad URL. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder URL-parser (Komponentuppdelare) i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Klistra in eller ladda upp en URL

Ange en HTTP(S)-adress, ett anpassat URI-schema, en IPv6-endpoint eller en signerad callback-länk i inmatningsfältet, eller släpp en ren textfil.

2

Inspektera uppdelade URI-fält

Granska tolkad origin, autentiseringsuppgifter, uppdelning av subdomän/domän/TLD, avkodad lista över sökvägssegment, nyckel-värde-parametrar i frågesträngen och fragmentidentifierare.

3

Redigera komponenter och kopiera resultat

Ändra valfri komponent separat – byt staging-värdar, justera portnummer eller uppdatera parametrar – och kopiera den ombyggda URL:en eller strukturerad JSON-data.

Hur komponenttolkning och realtidsrekonstruktion av URL:er fungerar

Snabbsvar: En URL-parser tokeniserar en Uniform Resource Identifier längs strukturella avgränsare enligt RFC 3986 (://, @, :, /, ?, #), vilket isolerar authority, hierarkiska sökvägssegment, query-parametrar och fragment så att varje fält kan inspekteras eller ändras utan manuell stränghantering.

Manuella reguljära uttryck och naiva split('/')-funktioner går ofta sönder när de stöter på basic-auth-uppgifter, explicita portar, procentkodade snedstreck (%2F), flerdelade publika suffix som .co.uk eller frågetecken inbäddade i hash-fragment. En specifikationsmedveten parser skannar avgränsare i strikt syntaktisk ordning innan enskilda komponenter avkodas.

Betrakta en komplex webhook-URL som innehåller inloggningsuppgifter, en subdomän i flera nivåer, en icke-standardiserad TLS-port, ett kodat sökvägssegment, query-parametrar och ett fragmentankare:

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

När denna URI bryts ned skapas separata, individuellt redigerbara egenskaper:

{
  "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"
}

Ändra komponenter utan att förstöra kodade tecken

Vid felsökning mellan miljöer behöver man ofta peka om en infångad callback-URL från produktion eller staging till en lokal tjänst, samtidigt som exakt sökvägskodning och signerade query-nyttolaster bevaras. Om du ändrar scheme till http, hostname till localhost, port till 3000 och rensar username/password rekonstrueras följande felfritt:

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

Observera att det tredje sökvägssegmentet (acme corp) automatiskt behåller sin procentkodning (%20) i pathname, vilket förhindrar att blanksteg klipper av länken i HTTP-anropsrader eller Markdown-loggar.

Generisk URI-syntax i RFC 3986 jämfört med WHATWG URL-standarden

Snabbsvar: RFC 3986 definierar tillståndslösa ABNF-grammatikregler för generiska URI:er, medan moderna webbläsare, Node.js, Deno och Cloudflare Workers implementerar WHATWG URL Living Standard, som tvingar fram normalisering av specialscheman, borttagning av standardportar, konvertering av omvända snedstreck och Punycode IDNA-kodning enligt UTS #46.

Att förstå de subtila skillnaderna mellan RFC 3986 och WHATWG URL-standarden förebygger routningsfel, trasig signaturverifiering och sårbarheter som Server-Side Request Forgery (SSRF).

Kanonisk strukturell grammatik (RFC 3986 avsnitt 3)

RFC 3986 delar in varje generisk URI i fem primära komponenter med fast prioritet från vänster till höger:

  foo://user:pass@example.com:8042/over/there?name=ferret#nose
  \_/   \_______________________/ \_________/ \_________/ \__/
   |                |                  |           |        |
scheme          authority             path       query   fragment
  • Scheme (Schema): Måste börja med en ASCII-bokstav följt av bokstäver, siffror, +, - eller . (ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )). Normaliseras till gemener.
  • Authority: Föregås av // och avslutas vid nästa /, ?, # eller slutet av strängen. Delas in i valfri userinfo@, host (registrerat namn, IPv4-adress eller [IPv6]-literal inom hakparenteser) samt valfri :port.
  • Path (Sökväg): Hierarkisk sekvens av /-segment. Punktsegment (. och ..) löses upp via algoritmen remove_dot_segments (RFC 3986 avsnitt 5.2.4).
  • Query (Frågesträng): Inleds med det första ? efter sökvägen och avslutas vid # eller slutet av strängen.
  • Fragment: Inleds med # och konsumerar alla återstående tecken till slutet av URI:n, inklusive eventuella efterföljande ?- eller /-tecken.

WHATWG-specialscheman jämfört med opaka sökvägar

Tillståndsmaskinen i WHATWG URL utser sex scheman som speciella: http, https, ws, wss, ftp och file. Speciella URL:er genomgår strikt normalisering som icke-speciella scheman (mailto:, urn:, data:, myapp://) hoppar över:

  1. Borttagning av standardport: https://example.com:443/api serialiseras som https://example.com/api med port satt till "" eftersom 443 matchar standardporten för https (80 för http/ws, 443 för https/wss, 21 för ftp). Anpassade scheman som redis://cache.internal:6379 behåller :6379.
  2. Normalisering av omvända snedstreck: I specialscheman normaliseras omvända snedstreck (\) inuti authority och sökvägssegment till vanliga snedstreck (/), medan icke-speciella scheman behandlar \ som ett opakt sökvägstecken.
  3. Rot-snedstreck vid tom sökväg: https://example.com serialiseras med ett avslutande rotsnedstreck (pathname = "/"), medan custom://host kan ha en tom pathname.
  4. IDNA Punycode-konvertering: Unicode-domänetiketter som https://münchen.example/path konverteras via UTS #46 till ASCII Compatible Encoding (https://xn--mnchen-3ya.example/path) i egenskapen hostname.

IPv6-literaler och publika suffix med flera etiketter

IPv6-adresser innehåller kolon som skulle krocka med :port-avgränsaren om de inte omsluts av hakparenteser enligt RFC 2732, som i http://[2001:db8:85a3::8a2e:370:7334]:8080/health. Att bryta ned ett värdnamn i subdomän, registrerbar domän och TLD kan dessutom inte förlita sig på att dela vid sista punkten: landsspecifika andranivådomäner (example.co.uk, app.com.au) och plattformssuffix kräver kännedom om flerdelade suffix så att co.uk identifieras som effektiv TLD i stället för bara uk.

Säkerhetsnotis: Skillnader mellan tolkar och SSRF

Säkerhetslistor (allowlists) fallerar när en proxy validerar en URL med ett tillåtande RFC 3986-regex medan den bakomliggande HTTP-klienten hämtar den med en WHATWG-parser. Indata som innehåller flera @-avgränsare (https://allowed.example@169.254.169.254/latest/meta-data/) eller omvända snedstreck (https://attacker.example\@allowed.example/) kan få en parser att läsa allowed.example som värd medan HTTP-klienten ansluter till 169.254.169.254 eller attacker.example. Validera alltid origin och hostname efter tolkning med exakt samma WHATWG-normalisering som din HTTP-klient använder, och ta bort eller avvisa oväntade username/password-fält.

URL-parser, Frågesträngstolkare eller URL-kodare: Vilket verktyg behöver du?

Snabbsvar: Använd URL-parser (Komponentuppdelare) för att inspektera och bygga om hela URI-strukturen över schema, authority, värd, port, sökväg, query och hash. Använd Frågesträngstolkare för djupgående redigering av nästlade query-parametrar och dubbelriktad JSON-konvertering, eller URL-kodare & Avkodare för att koda råa teckensträngar.

Uppgifter kring URL-hantering delas in i tydliga syntaktiska lager. Genom att välja det verktyg som är byggt för exakt det lager du arbetar med undviker du dubbelkodning av avgränsare eller att datatyper i nästlade parametrar går förlorade.

Funktion URL-parser (Detta verktyg) Frågesträngstolkare URL-kodare & Avkodare Procentkodare
Primär indata Komplett URL eller anpassad URI ?a=1&b=2, formulärdata eller JSON Rå sträng eller kodad URL-komponent Rå text som kräver strikt RFC 3986 %XX-kodning
Uppdelning av Authority, Värd, Port & TLD Fullständig uppdelning + direktedigering Tar bort icke-query-relaterade URL-delar Ingen strukturell tolkning Ingen strukturell tolkning
Inspektion av sökvägssegment Indexerad array med avkodade segment Ej tillämpligt Ingen strukturell tolkning Ingen strukturell tolkning
Nästlade Query-arrayer & Hakparenteser Platt nyckel-värde-inspektion av query Fullt stöd för tag[]=a, filter[k]=v & JSON-synk Ej tillämpligt Ej tillämpligt
Kontroll över blankstegskodning (+ vs %20) Standardregler för URI-komponenter Konfigurerbar +- eller %20-serialisering Stöder komponent- och formulärkodning Strikt RFC 3986 %20-bytekodning

När du bör byta till ett syskonverktyg

  • Redigera djupt nästlade API-filter eller konvertera query-parametrar till JSON: Öppna Frågesträngstolkare när du arbetar med upprepade array-nycklar (?id=1&id=2), qs-liknande hakparentesnotation (filter[status]=open), application/x-www-form-urlencoded POST-nyttolaster eller JSON-testfixtures.
  • Koda eller avkoda ett enskilt parametervärde: Använd URL-kodare & Avkodare när du har en rå sträng som innehåller &, =, + eller Unicode-tecken som måste kodas säkert via encodeURIComponent-semantik innan den infogas.
  • Strikt RFC 3986-kodning på bytenivå för OAuth / AWS SigV4: Använd Procentkodare när du signerar kanoniska anrop där tecken som !, ', (, ) och * måste hex-kodas.
  • Generera rena SEO-sökvägssegment från rubriker: Använd Rensa URL & Sökvägar (Slugify) för att translitterera rubriker till gemena, bindestrecksseparerade URL-sluggar.
FAQ

URL-parser (Komponentuppdelare) FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis url parser online.

Vad är skillnaden mellan host, hostname och origin i en tolkad URL?

I WHATWG URL-specifikationen innehåller hostname enbart domännamnet eller en IPv6-literal inom hakparenteser (api.example.com eller [::1]). host lägger till :port endast när en explicit icke-standardport anges (api.example.com:8443, eller api.example.com om port 443 används över https). origin lägger till schemat och ://-avgränsaren framför host (https://api.example.com:8443), vilket representerar webbsäkerhetsgränsen som används av CORS och postMessage.

Varför stannar en frågesträng efter en hash (#) kvar i fragmentet i stället för i queryParams?

Enligt RFC 3986 avsnitt 3.5 avslutar den första #-avgränsaren sökvägs- eller query-komponenten och påbörjar fragmentidentifieraren, som sträcker sig hela vägen till slutet av URI:n. I hash-routade SPA-länkar (Single-Page Applications) som https://app.example.com/#/orders?status=paid är ?status=paid en del av klientsidans hash (#/orders?status=paid) och skickas aldrig till HTTP-servern. För att tolka parametrar inbäddade i en hash-rutt, kopiera delsträngen som börjar vid ? till vår Frågesträngstolkare.

Varför försvinner standardportar som :80 och :443 när man bygger om en HTTP- eller HTTPS-URL?

Specialscheman i WHATWG URL-standarden definierar standardportar (80 för http och ws, 443 för https och wss, 21 för ftp). När en URL explicit anger sitt schemas standardport – exempelvis https://example.com:443/v1 – utelämnar standardiserade normaliserare :443 vid kanonisk serialisering så att likvärdiga origins jämförs identiskt. Icke-standardportar som :8443 eller :3000 bevaras alltid.

Hur hanteras procentkodade snedstreck (%2F) inuti sökvägssegment?

Strukturella /-avgränsare delas upp innan procentavkodning sker. I /repos/acme%2Fcore/commits skapar uppdelningen först tre segment (["repos", "acme%2Fcore", "commits"]), och avkodning på segmentnivå ger sedan acme/core som en enda identifierare. Att avkoda %2F före sökvägsuppdelning skulle felaktigt skapa fyra sökvägssegment och förstöra REST-routning.

Är det säkert att inspektera OAuth callback-URL:er eller försignerade AWS S3-länkar här?

Ja. All URL-tolkning, komponentredigering och JSON-serialisering körs till 100 % lokalt i webbläsarens JavaScript-miljö. Inga nätverksanrop, analys-beacons eller serverloggar rör någonsin dina inklistrade URL:er, X-Amz-Signature-parametrar, code-tokens eller userinfo-inloggningsuppgifter.