स्वीकृत उत्तर को ध्यान में नहीं रखा गया एकल अंक हेक्साडेसिमल कोड को लौटाता है। इसे आसानी से समायोजित किया जाता है:
function numHex(s)
{
var a = s.toString(16);
if ((a.length % 2) > 0) {
a = "0" + a;
}
return a;
}
तथा
function strHex(s)
{
var a = "";
for (var i=0; i<s.length; i++) {
a = a + numHex(s.charCodeAt(i));
}
return a;
}
मेरा मानना है कि उपरोक्त उत्तर एक या दूसरे रूप में कई बार दूसरों द्वारा पोस्ट किए गए हैं। मैं इन्हें एक toHex () फ़ंक्शन में लपेटता हूं:
function toHex(s)
{
var re = new RegExp(/^\s*(\+|-)?((\d+(\.\d+)?)|(\.\d+))\s*$/);
if (re.test(s)) {
return '#' + strHex( s.toString());
}
else {
return 'A' + strHex(s);
}
}
ध्यान दें कि संख्यात्मक नियमित अभिव्यक्ति आपके वेब अनुप्रयोगों की दक्षता में सुधार के लिए 10+ उपयोगी जावास्क्रिप्ट नियमित अभिव्यक्ति कार्यों से आई है ।
अद्यतन: इस चीज़ का परीक्षण करने के बाद कई बार मुझे एक त्रुटि मिली (RegExp में दोहरे उद्धरण), इसलिए मैंने यह तय किया। तथापि! काफी परीक्षण के बाद और अल्माज द्वारा पोस्ट को पढ़ने के बाद - मुझे एहसास हुआ कि मुझे काम करने के लिए नकारात्मक संख्या नहीं मिल सकती है।
इसके अलावा - मैंने इस पर कुछ पढ़ना शुरू किया और चूंकि सभी जावास्क्रिप्ट संख्या 64 बिट शब्दों के रूप में संग्रहीत हैं, चाहे जो भी हो - मैंने 64 बिट शब्द प्राप्त करने के लिए संख्या कोड को संशोधित करने की कोशिश की। लेकिन यह पता चला है कि आप ऐसा नहीं कर सकते। यदि आप "3.14159265" को एक संख्या में एक चर के रूप में रखते हैं - तो आप केवल "3" प्राप्त कर पाएंगे, क्योंकि भिन्नात्मक भाग केवल संख्या को दस (IE: 10.0) से गुणा करके बार-बार पहुंचता है। या उस दूसरे तरीके को लगाने के लिए - 0xF के हेक्साडेसिमल मान के कारण एक पूर्णांक में अनूदित होने से पहले फ्लोटिंग पॉइंट वैल्यू का अनुवाद किया जाता है जो अवधि के पीछे सब कुछ हटा देता है। एक पूरे के रूप में मान लेने के बजाय (यानी: 3.14159265) और 0xF मान के खिलाफ फ्लोटिंग पॉइंट वैल्यू का अनुमान लगाना।
तो इस मामले में, सबसे अच्छी बात यह है कि 3.14159265 को एक स्ट्रिंग में बदलना है और फिर स्ट्रिंग को परिवर्तित करना है। उपरोक्त के कारण, ऋणात्मक संख्याओं को परिवर्तित करना भी आसान हो जाता है क्योंकि मान के मोर्चे पर ऋण चिह्न केवल 0x26 हो जाता है।
तो मैंने जो किया वह यह निर्धारित करने पर था कि चर में एक संख्या है - बस इसे एक स्ट्रिंग में परिवर्तित करें और स्ट्रिंग को परिवर्तित करें। इसका मतलब यह है कि सर्वर साइड पर आपको आने वाली स्ट्रिंग को खोलना होगा और फिर आने वाली जानकारी को निर्धारित करना होगा। आप आसानी से संख्याओं के सामने "#" जोड़कर और पीछे आने वाले वर्ण स्ट्रिंग के सामने "A" को आसानी से कर सकते हैं। ToHex () फ़ंक्शन देखें।
मज़े करो!
एक और साल और बहुत सोच-विचार के बाद, मैंने फैसला किया कि "toHex" फ़ंक्शन (और मेरे पास "fromHex" फ़ंक्शन भी है) को वास्तव में सुधार करने की आवश्यकता है। पूरा सवाल था "मैं इसे और अधिक कुशलता से कैसे कर सकता हूं?" मैंने फैसला किया कि हेक्साडेसिमल फ़ंक्शन से ए / टू की परवाह नहीं की जानी चाहिए अगर कुछ एक भिन्नात्मक भाग है, लेकिन साथ ही यह सुनिश्चित करना चाहिए कि भिन्नात्मक भागों को स्ट्रिंग में शामिल किया गया है।
तो फिर सवाल बन गया, "आप कैसे जानते हैं कि आप एक हेक्साडेसिमल स्ट्रिंग के साथ काम कर रहे हैं?"। उत्तर सीधा है। मानक पूर्व-स्ट्रिंग जानकारी का उपयोग करें जो पहले से ही दुनिया भर में मान्यता प्राप्त है।
दूसरे शब्दों में - "0x" का उपयोग करें। तो अब मेरा toHex फ़ंक्शन यह देखने के लिए दिखता है कि क्या यह पहले से ही है और यदि यह है - यह सिर्फ उस स्ट्रिंग को वापस करता है जिसे इसे भेजा गया था। अन्यथा, यह स्ट्रिंग, संख्या, जो भी हो, को रूपांतरित करता है। यहाँ संशोधित टॉक्स फ़ंक्शन है:
/////////////////////////////////////////////////////////////////////////////
// toHex(). Convert an ASCII string to hexadecimal.
/////////////////////////////////////////////////////////////////////////////
toHex(s)
{
if (s.substr(0,2).toLowerCase() == "0x") {
return s;
}
var l = "0123456789ABCDEF";
var o = "";
if (typeof s != "string") {
s = s.toString();
}
for (var i=0; i<s.length; i++) {
var c = s.charCodeAt(i);
o = o + l.substr((c>>4),1) + l.substr((c & 0x0f),1);
}
return "0x" + o;
}
यह एक बहुत तेज़ कार्य है जो एकल अंकों, फ़्लोटिंग पॉइंट नंबरों को ध्यान में रखता है, और यह देखने के लिए भी जांचता है कि क्या वह व्यक्ति फिर से हेक्स होने के लिए हेक्स मान भेज रहा है या नहीं। यह केवल चार फ़ंक्शन कॉल का उपयोग करता है और उनमें से केवल दो लूप में हैं। आपके द्वारा उपयोग किए जाने वाले मानों को अन-हेक्स करने के लिए:
/////////////////////////////////////////////////////////////////////////////
// fromHex(). Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
var start = 0;
var o = "";
if (s.substr(0,2).toLowerCase() == "0x") {
start = 2;
}
if (typeof s != "string") {
s = s.toString();
}
for (var i=start; i<s.length; i+=2) {
var c = s.substr(i, 2);
o = o + String.fromCharCode(parseInt(c, 16));
}
return o;
}
ToHex () फ़ंक्शन की तरह, fromHex () फ़ंक्शन पहले "0x" के लिए दिखता है और फिर यह आने वाली जानकारी को स्ट्रिंग में अनुवाद करता है यदि यह पहले से ही एक स्ट्रिंग नहीं है। मुझे नहीं पता कि यह कैसे एक स्ट्रिंग नहीं होगा - लेकिन सिर्फ मामले में - मैं जांच करता हूं। इसके बाद फ़ंक्शन दो वर्णों को पकड़कर और ASCII वर्णों में अनुवाद करता है। यदि आप चाहते हैं कि यह यूनिकोड का अनुवाद करे, तो आपको एक समय में लूप को चार (4) अक्षरों में बदलने की आवश्यकता होगी। लेकिन फिर आपको यह भी सुनिश्चित करना होगा कि स्ट्रिंग चार से विभाज्य नहीं है। यदि यह है - तो यह एक मानक हेक्साडेसिमल स्ट्रिंग है। (याद रखें कि स्ट्रिंग के सामने "0x" है।)
एक साधारण परीक्षण स्क्रिप्ट जो यह दर्शाती है कि -3.14159265, जब एक स्ट्रिंग में परिवर्तित की जाती है, अभी भी -3.14159265 है।
<?php
echo <<<EOD
<html>
<head><title>Test</title>
<script>
var a = -3.14159265;
alert( "A = " + a );
var b = a.toString();
alert( "B = " + b );
</script>
</head>
<body>
</body>
</html>
EOD;
?>
क्योंकि किस तरह जावास्क्रिप्ट कार्य (स्ट्रिंग) फ़ंक्शन के संबंध में है, उन सभी समस्याओं को समाप्त किया जा सकता है जो पहले समस्याएं पैदा कर रहे थे। अब सभी तार और संख्या आसानी से परिवर्तित की जा सकती है। इसके अलावा, ऑब्जेक्ट के रूप में ऐसी चीजें जावास्क्रिप्ट द्वारा स्वयं उत्पन्न होने में त्रुटि का कारण बनेंगी। मेरा मानना है कि यह जितना मिलता है उतना अच्छा है। केवल W3C के लिए बचा हुआ एकमात्र सुधार जावास्क्रिप्ट में एक toHex () और fromHex () फ़ंक्शन को शामिल करना है।