URL குறியாக்கம் மற்றும் பகாப்புக் கருவி
அடிக்கடி கேட்கப்படும் கேள்விகள்
URL குறியாக்கம் என்றால் என்ன?
URL குறியாக்கம் என்பது எழுத்துகளை இணையத்தில் அனுப்பக்கூடிய வடிவத்திற்கு மாற்றும் முறையாகும். URL-கள் ASCII எழுத்துக்களைக் கொண்டு மட்டுமே இணையத்தில் அனுப்பப்படலாம். URL-கள் பெரும்பாலும் ASCII தொகுப்புக்கு வெளியே உள்ள எழுத்துகளைக் கொண்டிருப்பதால், அவற்றை மாற்ற வேண்டும். URL குறியாக்கம் பாதுகாப்பற்ற ASCII எழுத்துகளை '%' என்பதுடன் அதைத் தொடர்ந்து இரண்டு பதினாறு எண் இலக்கங்களால் மாற்றுகிறது.
URL குறியாக்கம் எவ்வாறு செயல்படுகிறது?
URL குறியாக்கம் பாதுகாப்பற்ற எழுத்துகளை '%' மற்றும் அதைத் தொடர்ந்து அந்த எழுத்தின் UTF-8 குறியாக்கத்தை குறிக்கும் இரண்டு பதினாறு எண் இலக்கங்களால் மாற்றுகிறது. உதாரணமாக, இடைவெளி எழுத்து %20 என குறியாக்கம் செய்யப்படுகிறது. URL-களில் இடைவெளிகள் இருக்க முடியாது, எனவே அவை ஒரு பிளஸ் (+) குறியீடு அல்லது %20 ஆக மாற்றப்படுகின்றன. மற்ற சிறப்பு எழுத்துகள் அவற்றின் தொடர்புடைய %xx குறியீட்டால் மாற்றப்படுகின்றன.
URL குறியாக்கம் தேவைப்படும் பொதுவான எழுத்துகள்
URL-களில் பயன்படுத்தும்போது பின்வரும் எழுத்துகள் URL குறியாக்கம் தேவைப்படுகின்றன:
எழுத்து | URL குறியாக்கம் | விளக்கம் |
---|---|---|
Space | %20 | URL குறியாக்கம் தேவைப்படும் மிகவும் பொதுவான எழுத்து |
! | %21 | ஆச்சரியக் குறி |
" | %22 | இரட்டை மேற்கோள் |
# | %23 | ஹாஷ் குறியீடு (URL துண்டுகளுக்குப் பயன்படுத்தப்படுகிறது) |
$ | %24 | டாலர் குறி |
% | %25 | சதவீத குறி (URL குறியாக்க தப்பிக்கும் எழுத்து) |
& | %26 | அம்பர்சாண்ட் (URL அளவுருக்களை பிரிப்பதற்குப் பயன்படுகிறது) |
' | %27 | ஒற்றை மேற்கோள் |
( | %28 | திறக்கும் அடைப்புக்குறி |
) | %29 | மூடும் அடைப்புக்குறி |
+ | %2B | கூட்டல் குறி |
, | %2C | காற்புள்ளி |
/ | %2F | சாய்வு கோடு (URL பாதை பிரிப்பான்) |
= | %3D | சமக் குறியீடு (URL அளவுரு நியமனம்) |
? | %3F | கேள்விக் குறி (URL வினவல் சரம் தொடக்கம்) |
பல்வேறு நிரலாக்க மொழிகளில் URL குறியாக்க செயல்படுத்துதல்
இங்கே பல்வேறு நிரலாக்க மொழிகளில் URL குறியாக்கம் மற்றும் குறியாக்க நீக்கத்திற்கான எடுத்துக்காட்டுகள் உள்ளன:
Go
package main
import (
"fmt"
"net/url"
)
func main() {
// Encode a URL
text := "Hello World! Special chars: &?=/";
encoded := url.QueryEscape(text)
fmt.Println("Encoded:", encoded)
// Decode a URL
decoded, err := url.QueryUnescape(encoded)
if err == nil {
fmt.Println("Decoded:", decoded)
}
}
C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
// Function to URL-encode a string
char *url_encode(char *str) {
char *encoded = malloc(strlen(str) * 3 + 1);
char *pstr = str;
char *pbuf = encoded;
while (*pstr) {
if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~') {
*pbuf++ = *pstr;
} else if (*pstr == ' ') {
*pbuf++ = '+';
} else {
sprintf(pbuf, "%%%.2X", *pstr);
pbuf += 3;
}
pstr++;
}
*pbuf = '\\0';
return encoded;
}
int main() {
char *text = "Hello World! Special chars: &?=/";
char *encoded = url_encode(text);
printf("Original: %s\\n", text);
printf("Encoded: %s\\n", encoded);
free(encoded);
return 0;
}
PHP
<?php
// URL encoding
$text = "Hello World! Special chars: &?=/";
$encoded = urlencode($text);
echo "Encoded: " . $encoded . "\\n";
// URL decoding
$decoded = urldecode($encoded);
echo "Decoded: " . $decoded . "\\n";
?>
Python
import urllib.parse
# URL encoding
text = "Hello World! Special chars: &?=/"
encoded = urllib.parse.quote(text)
print(f"Encoded: {encoded}")
# URL decoding
decoded = urllib.parse.unquote(encoded)
print(f"Decoded: {decoded}")
JavaScript
// URL encoding
const text = "Hello World! Special chars: &?=/";
const encoded = encodeURIComponent(text);
console.log("Encoded:", encoded);
// URL decoding
const decoded = decodeURIComponent(encoded);
console.log("Decoded:", decoded);
TypeScript
// URL encoding
const text: string = "Hello World! Special chars: &?=/";
const encoded: string = encodeURIComponent(text);
console.log("Encoded:", encoded);
// URL decoding
const decoded: string = decodeURIComponent(encoded);
console.log("Decoded:", decoded);
encodeURI மற்றும் encodeURIComponent க்கு இடையே உள்ள வேறுபாடு என்ன?
encodeURI() ஒரு முழு URI ஐ குறியாக்கம் செய்ய வடிவமைக்கப்பட்டுள்ளது, எனவே இது URL இல் சிறப்பு அர்த்தம் கொண்ட எழுத்துகளை குறியாக்கம் செய்யாது, அதாவது /, ?, :, @, &, =, +, $ மற்றும் # போன்றவை. இதற்கு மாறாக, encodeURIComponent() அனைத்து சிறப்பு எழுத்துகளையும் குறியாக்கம் செய்கிறது, இது URL இன் பகுதிகளை குறியாக்கம் செய்ய பொருத்தமானதாக்குகிறது, உதாரணமாக வினவல் சரத்தின் அளவுருக்கள். வினவல் அளவுருக்களை குறியாக்கம் செய்யும் போது, எப்போதும் encodeURIComponent() ஐப் பயன்படுத்தவும், இது அனைத்து சிறப்பு எழுத்துகளும் சரியாக குறியாக்கம் செய்யப்படுவதை உறுதி செய்கிறது.