URL Parser

URL पार्सिंग क्या है?

URL पार्सिंग एक Uniform Resource Locator को उसके अलग-अलग घटकों में विभाजित करने की प्रक्रिया है: प्रोटोकॉल (स्कीम), होस्टनेम, पोर्ट, पाथनेम, क्वेरी पैरामीटर और फ्रैगमेंट पहचानकर्ता। प्रत्येक URL RFC 3986 और WHATWG URL Standard द्वारा परिभाषित संरचना का पालन करता है। एक URL पार्सर कच्ची स्ट्रिंग पढ़ता है, प्रत्येक खंड को उसके सीमांकक वर्णों (://, :, /, ?, #, &, =) द्वारा पहचानता है, और उन्हें अलग-अलग, सुलभ क्षेत्रों के रूप में लौटाता है।

ब्राउज़र हर बार URL पार्सिंग करते हैं जब आप कोई पता टाइप करते हैं या किसी लिंक पर क्लिक करते हैं। JavaScript का URL कंस्ट्रक्टर, Python का urllib.parse मॉड्यूल और Go का net/url पैकेज — सभी ऐसे पार्सर लागू करते हैं जो समान संरचनात्मक नियमों का पालन करते हैं। URL पार्सिंग, URL एन्कोडिंग के विपरीत है: सुरक्षित परिवहन के लिए वर्णों को परिवर्तित करने के बजाय, आप एक पहले से बने URL को उन भागों में तोड़ते हैं जो उसे बनाते हैं।

https://api.example.com:8080/v1/users?page=2&limit=10#section जैसे एक सामान्य URL में छह अलग-अलग घटक होते हैं। सीमांकक वर्ण — ://, :, /, ?, &, = और # — पार्सिंग को निश्चित बनाते हैं: प्रत्येक एक सीमा का संकेत देता है और पार्सर को बिना किसी अस्पष्टता के क्षेत्र निकालने में सक्षम बनाता है।

ऑनलाइन URL Parser का उपयोग क्यों करें?

आँखों से किसी URL को मैन्युअल रूप से विभाजित करना त्रुटिपूर्ण होता है, विशेष रूप से जब स्ट्रिंग में एन्कोडेड वर्ण, एकाधिक क्वेरी पैरामीटर या गैर-मानक पोर्ट हों। यह टूल उसी WHATWG-compliant एल्गोरिदम का उपयोग करके URL को पार्स करता है जो ब्राउज़र उपयोग करते हैं और प्रत्येक घटक को एक स्पष्ट, कॉपी करने योग्य तालिका में प्रदर्शित करता है।

URL Parser के उपयोग के मामले

URL घटक संदर्भ

नीचे दी गई तालिका JavaScript URL कंस्ट्रक्टर द्वारा किसी URL को पार्स करते समय लौटाई गई प्रत्येक प्रॉपर्टी दिखाती है। Python के urlparse परिणाम, Go के url.URL स्ट्रक्चर और PHP के parse_url आउटपुट में भी यही घटक मौजूद हैं, हालाँकि भाषाओं में प्रॉपर्टी के नाम अलग-अलग होते हैं।

WHATWG URL Standard बनाम RFC 3986

दो विनिर्देश परिभाषित करते हैं कि URL को कैसे पार्स किया जाना चाहिए। वे मूल संरचना पर सहमत हैं लेकिन विशेष मामलों में भिन्न हैं — और यह भिन्नता आमतौर पर वह कारण होती है जब आपका ब्राउज़र किसी URL को आपके सर्वर से अलग तरीके से संभालता है।

व्यवहार में, अधिकांश अंतर अंतर्राष्ट्रीय डोमेन नाम (IDN), लापता स्कीम या असामान्य वर्णों वाले URL पार्स करते समय सामने आते हैं। WHATWG पार्सर IDN होस्टनेम को स्वचालित रूप से Punycode में परिवर्तित करता है, जबकि कठोर RFC 3986 पार्सर उन्हें अस्वीकार कर सकते हैं। यदि आप इस टूल में कोई URL चिपकाते हैं और आपके सर्वर-साइड कोड से अलग परिणाम देखते हैं, तो WHATWG बनाम RFC अंतर सबसे संभावित कारण है।

कोड उदाहरण

प्रत्येक प्रमुख भाषा में एक अंतर्निर्मित URL पार्सर है। नीचे दिए गए उदाहरण समान URL पार्स करते हैं और उसके घटक निकालते हैं। भाषाओं में नामकरण के छोटे अंतरों पर ध्यान दें: Python, protocol के बजाय scheme का उपयोग करता है, और Go, search के बजाय RawQuery उजागर करता है।

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"

अक्सर पूछे जाने वाले प्रश्न