පිළිගත් පිළිතුර තනි ඉලක්කම් ආපසු ලබා දුන් ෂඩාස්රාකාර කේත සැලකිල්ලට නොගත්තේය. මෙය පහසුවෙන් සකස් කළ හැක්කේ:
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 හි ද්විත්ව උපුටා දැක්වීම්), එබැවින් මම එය නිවැරදි කළෙමි. කෙසේවෙතත්! තරමක් පරික්ෂා කිරීමෙන් පසුව සහ අල්මාස් විසින් ලිපිය කියවීමෙන් පසුව - මට වැඩ කිරීමට negative ණ සංඛ්යා ලබා ගත නොහැකි බව මට වැටහුණි.
තව දුරටත් - මම මේ පිළිබඳව යම් කියවීමක් කළ අතර සියලු ජාවාස්ක්‍රිප්ට් අංක 64 බිට් වචන 64 ක් ලෙස ගබඩා කර ඇති හෙයින් කුමක් වුවත් - බිට් 64 වචනය ලබා ගැනීම සඳහා මම අංකහෙක්ස් කේතය වෙනස් කිරීමට උත්සාහ කළෙමි. නමුත් ඔබට එය කළ නොහැකි බව පෙනේ. ඔබ "3.14159265" අංකයක් ලෙස විචල්‍යයකට දැමුවහොත් - ඔබට ලබා ගත හැක්කේ "3" පමණි, මන්දයත් භාගික කොටස ප්‍රවේශ විය හැක්කේ සංඛ්යා දහයෙන් ගුණ කිරීමෙන් පමණි (IE: 10.0) නැවත නැවත. හෝ වෙනත් අයුරකින් කිරීමට - ෂඩ් දශම 0xF වටිනාකම ද හේතු ඉපිලුම් ලක්ෂ්ය අගය යනු පරිවර්තනය කිරීම පූර්ණ සංඛ්යාමය එය කාලය පිටුපස සියල්ල ඉවත් කරන ANDed පෙර. සමස්තයක් ලෙස අගය ගැනීම වෙනුවට (එනම්: 3.14159265) සහ 0xF අගයට සාපේක්ෂව පාවෙන ලක්ෂ්ය අගය ANDing කිරීම.
එබැවින් කළ හැකි හොඳම දෙය නම්, මේ අවස්ථාවේ දී, 3.14159265 නූලක් බවට පරිවර්තනය කර නූල් පරිවර්තනය කිරීමයි. ඉහත නිසා, negative ණ සංඛ්යා පරිවර්තනය කිරීමද පහසු කරයි, මන්ද the ණ ලකුණ අගයේ ඉදිරිපස 0x26 බවට පත්වේ.
ඉතින් මම කළේ විචල්‍යයේ අංකයක් ඇති බව තීරණය කිරීමයි - එය නූලකට පරිවර්තනය කර නූල පරිවර්තනය කරන්න. මෙයින් අදහස් කරන්නේ සේවාදායකයාගේ පැත්තේ ඔබට එන නූල ඉවත් කිරීමට අවශ්‍ය වන අතර ඉන් පසුව ලැබෙන තොරතුරු සංඛ්‍යාත්මක බව තීරණය කිරීමයි. අංකවල ඉදිරිපසට "#" සහ නැවත එන අක්ෂර මාලාවක ඉදිරිපස "A" එකතු කිරීමෙන් ඔබට එය පහසුවෙන් කළ හැකිය. ToHex () ශ්‍රිතය බලන්න.
විනෝද වන්න!
තවත් වසරක් සහ බොහෝ සිතුවිලි වලින් පසුව, "toHex" ශ්‍රිතය (සහ මට "fromHex" ශ්‍රිතයක්ද ඇත) සැබවින්ම නවීකරණය කිරීමට අවශ්‍ය බව මම තීරණය කළෙමි. සමස්ත ප්රශ්නය වූයේ "මෙය වඩාත් කාර්යක්ෂමව කරන්නේ කෙසේද?" ෂඩාස්රාකාර ශ්‍රිතයක් සිට / දක්වා යම් දෙයක් භාගික කොටසක් දැයි සැලකිලිමත් නොවිය යුතු බව මම තීරණය කළෙමි.
ඉතින් ප්රශ්නය වූයේ, "ඔබ ෂඩාස්රාකාර නූලක් සමඟ වැඩ කරන බව ඔබ දන්නේ කෙසේද?". පිළිතුර සරල ය. ලොව පුරා දැනටමත් හඳුනාගෙන ඇති සම්මත පෙර-තොරතුරු භාවිතා කරන්න.
වෙනත් වචන වලින් කිවහොත් - "0x" භාවිතා කරන්න. ඉතින් දැන් මගේ toHex ශ්‍රිතය පෙනෙන්නේ එය දැනටමත් තිබේද යන්න සහ එය තිබේ නම් - එය එයට යවන ලද නූල යවයි. එසේ නොමැති නම්, එය නූල්, අංකය, ඕනෑම දෙයක් පරිවර්තනය කරයි. සංශෝධිත 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;
?>
ToString () ශ්‍රිතයට අදාළව ජාවාස්ක්‍රිප්ට් ක්‍රියා කරන ආකාරය නිසා, මීට පෙර ගැටළු ඇති කළ එම සියලු ගැටලු ඉවත් කළ හැකිය. දැන් සියලු නූල් සහ අංක පහසුවෙන් පරිවර්තනය කළ හැකිය. තවද, වස්තූන් වැනි දෑ ජාවාස්ක්‍රිප්ට් විසින්ම දෝෂයක් ජනනය කිරීමට හේතු වේ. මම විශ්වාස කරනවා මේක ලැබෙන තරමට හොඳයි කියලා. ජාවාස්ක්‍රිප්ට් හි toHex () සහ fromHex () ශ්‍රිතයක් ඇතුළත් කිරීම W3C සඳහා ඉතිරිව ඇති එකම දියුණුවයි.