Comment convertir un décimal en hexadécimal en JavaScript
https://stackoverflow.com/questions/57803
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Comment convertir des valeurs décimales en leur équivalent hexadécimal en JavaScript ?
La solution
Convertissez un nombre en chaîne hexadécimale avec :
hexString = yourNumber.toString(16);
Et inversez le processus avec :
yourNumber = parseInt(hexString, 16);
Autres conseils
Si vous devez gérer des éléments tels que des champs de bits ou des couleurs 32 bits, vous devez alors gérer des nombres signés.La fonction Javascript toString(16) renverra un nombre hexadécimal négatif qui n'est généralement pas ce que vous souhaitez.Cette fonction effectue un ajout fou pour en faire un nombre positif.
function decimalToHexString(number)
{
if (number < 0)
{
number = 0xFFFFFFFF + number + 1;
}
return number.toString(16).toUpperCase();
}
console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));Le code ci-dessous convertira la valeur décimale d en hexadécimal.Il vous permet également d'ajouter un remplissage au résultat hexadécimal.Donc 0 deviendra 00 par défaut.
function decimalToHex(d, padding) {
var hex = Number(d).toString(16);
padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
while (hex.length < padding) {
hex = "0" + hex;
}
return hex;
}
function toHex(d) {
return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}
Avec rembourrage :
function dec2hex(i) {
return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
Pour compléter, si vous souhaitez le complément à deux représentation hexadécimale d'un nombre négatif, vous pouvez utiliser le décalage zéro-remplissage-droite >>> opérateur.Par exemple:
> (-1).toString(16)
"-1"
> ((-2)>>>0).toString(16)
"fffffffe"
Il y a cependant une limite : Les opérateurs JavaScript au niveau du bit traitent leurs opérandes comme une séquence de 32 bits, c'est-à-dire que vous obtenez le complément à deux de 32 bits.
Sans la boucle :
function decimalToHex(d) {
var hex = Number(d).toString(16);
hex = "000000".substr(0, 6 - hex.length) + hex;
return hex;
}
// Or "#000000".substr(0, 7 - hex.length) + hex;
// Or whatever
// *Thanks to MSDN
N'est-il pas non plus préférable de ne pas utiliser de tests de boucle qui doivent être évalués ?
Par exemple, au lieu de :
for (var i = 0; i < hex.length; i++){}
avoir
for (var i = 0, var j = hex.length; i < j; i++){}
En combinant certaines de ces bonnes idées pour une fonction de valeur RVB en hexadécimal (ajoutez le # ailleurs pour HTML/CSS) :
function rgb2hex(r,g,b) {
if (g !== undefined)
return Number(0x1000000 + r*0x10000 + g*0x100 + b).toString(16).substring(1);
else
return Number(0x1000000 + r[0]*0x10000 + r[1]*0x100 + r[2]).toString(16).substring(1);
}
La réponse acceptée ne tenait pas compte des codes hexadécimaux renvoyés à un chiffre.Ceci est facilement ajusté par :
function numHex(s)
{
var a = s.toString(16);
if ((a.length % 2) > 0) {
a = "0" + a;
}
return a;
}
et
function strHex(s)
{
var a = "";
for (var i=0; i<s.length; i++) {
a = a + numHex(s.charCodeAt(i));
}
return a;
}
Je crois que les réponses ci-dessus ont été publiées à plusieurs reprises par d'autres sous une forme ou une autre.Je les enveloppe dans une fonction toHex() comme ceci :
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);
}
}
Notez que l'expression régulière numérique provient de Plus de 10 fonctions d'expressions régulières JavaScript utiles pour améliorer l'efficacité de vos applications Web.
Mise à jour:Après avoir testé cette chose plusieurs fois, j'ai trouvé une erreur (guillemets doubles dans RegExp), j'ai donc corrigé cela.CEPENDANT!Après pas mal de tests et après avoir lu le message d'Almaz, j'ai réalisé que je ne pouvais pas faire fonctionner les nombres négatifs.
De plus - j'ai fait quelques lectures à ce sujet et comme tous les nombres JavaScript sont stockés sous forme de mots de 64 bits quoi qu'il arrive - j'ai essayé de modifier le code numHex pour obtenir le mot de 64 bits.Mais il s’avère que vous ne pouvez pas faire cela.Si vous mettez "3.14159265" COMME NUMÉRO dans une variable, tout ce que vous pourrez obtenir est le "3", car la partie fractionnaire n'est accessible qu'en multipliant le nombre par dix (IE: 10.0) à plusieurs reprises.Ou pour le dire autrement - le hexadécimal la valeur de 0xF provoque le point flottant valeur à traduire en entier avant qu'il ne soit ANDé, ce qui supprime tout ce qui se trouve derrière le point.Plutôt que de prendre la valeur dans son ensemble (c'est-à-dire :3.14159265) et ANDing le point flottant valeur par rapport à la valeur 0xF.
La meilleure chose à faire, dans ce cas, est donc de convertir le 3.14159265 en un chaîne puis convertissez simplement la chaîne.En raison de ce qui précède, cela facilite également la conversion de nombres négatifs, car le signe moins devient simplement 0x26 devant la valeur.
Donc, ce que j'ai fait, c'est de déterminer que la variable contient un nombre - il suffit de la convertir en chaîne et de convertir la chaîne.Cela signifie pour tout le monde que du côté du serveur, vous devrez déverrouiller la chaîne entrante, puis déterminer que les informations entrantes sont numériques.Vous pouvez le faire facilement en ajoutant simplement un "#" devant les chiffres et un "A" devant une chaîne de caractères qui revient.Voir la fonction toHex().
Amusez-vous!
Après encore un an et beaucoup de réflexion, j'ai décidé que la fonction "toHex" (et j'ai aussi une fonction "fromHex") avait vraiment besoin d'être remaniée.Toute la question était "Comment puis-je faire cela plus efficacement?" J'ai décidé qu'une fonction à / à partir de la fonction hexadécimale ne se soucie pas si quelque chose est une partie fractionnaire mais en même temps, il devrait garantir que les parties fractionnaires sont incluses dans la chaîne.
Alors la question est devenue : « Comment savez-vous que vous travaillez avec une chaîne hexadécimale ?La réponse est simple.Utilisez les informations standard de pré-chaîne déjà reconnues dans le monde entier.
En d'autres termes, utilisez "0x".Alors maintenant, ma fonction toHex regarde si cela est déjà là et si c'est le cas, elle renvoie simplement la chaîne qui lui a été envoyée.Sinon, il convertit la chaîne, le nombre, peu importe.Voici la fonction toHex révisée :////////////////////////////////////////////////////////////////////////// / //////////////////////////////////// // TOHEX ().Convertit une chaîne ASCII en hexadécimal.////////////////////////////////////////////////////////////////////////// / ////////////////////////////// Tohex (S) {if (S.Substr (0,2) .tolowerCase () == "0x ") { Retour;}
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;
}
Il s'agit d'une fonction très rapide qui prend en compte les chiffres simples, les nombres à virgule flottante et vérifie même si la personne envoie une valeur hexadécimale pour qu'elle soit à nouveau hexadécimale.Il n'utilise que quatre appels de fonction et seulement deux d'entre eux sont dans la boucle.Pour dé-hexadécimaliser les valeurs que vous utilisez :
/////////////////////////////////////////////////////////////////////////////
// fromHex(). Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
var start = 0;
var o = "";
if (s.substr(0,2) == "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;
}
Comme la fonction toHex(), la fonction fromHex() recherche d'abord le "0x", puis traduit les informations entrantes en chaîne si ce n'est pas déjà une chaîne.Je ne sais pas comment ce ne serait pas une chaîne - mais juste au cas où - je vérifie.La fonction s'exécute ensuite, récupère deux caractères et les traduit en caractères ASCII.Si vous souhaitez qu'il traduise Unicode, vous devrez modifier la boucle pour qu'elle passe par quatre (4) caractères à la fois.Mais vous devez également vous assurer que la chaîne n’est PAS divisible par quatre.Si c'est le cas, il s'agit d'une chaîne hexadécimale standard.(N'oubliez pas que la chaîne porte "0x" devant.)
Un simple script de test pour montrer que -3.14159265, une fois converti en chaîne, est toujours -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;
?>
En raison du fonctionnement de JavaScript par rapport à la fonction toString(), tous les problèmes qui causaient auparavant des problèmes peuvent être éliminés.Désormais, toutes les chaînes et tous les nombres peuvent être convertis facilement.De plus, des éléments tels que des objets entraîneront la génération d'une erreur par JavaScript lui-même.Je crois que c'est à peu près aussi bon que possible.La seule amélioration restante est que le W3C inclue simplement les fonctions toHex() et fromHex() en JavaScript.
var number = 3200;
var hexString = number.toString(16);
Le 16 est la base et il y a 16 valeurs dans un nombre hexadécimal :-)
Limité/rempli à un nombre défini de caractères :
function decimalToHex(decimal, chars) {
return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}
function dec2hex(i)
{
var result = "0000";
if (i >= 0 && i <= 15) { result = "000" + i.toString(16); }
else if (i >= 16 && i <= 255) { result = "00" + i.toString(16); }
else if (i >= 256 && i <= 4095) { result = "0" + i.toString(16); }
else if (i >= 4096 && i <= 65535) { result = i.toString(16); }
return result
}
Si vous souhaitez convertir un nombre en représentation hexadécimale d'une valeur de couleur RGBA, j'ai trouvé que c'était la combinaison la plus utile de plusieurs conseils d'ici :
function toHexString(n) {
if(n < 0) {
n = 0xFFFFFFFF + n + 1;
}
return "0x" + ("00000000" + n.toString(16).toUpperCase()).substr(-8);
}
Autant que je sache commentaire 57807 est faux et devrait ressembler à quelque chose comme :var hex = Number(d).toString(16);au lieu devar hex = parseInt(d, 16);
function decimalToHex(d, padding) {
var hex = Number(d).toString(16);
padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
while (hex.length < padding) {
hex = "0" + hex;
}
return hex;
}
Pour toute personne intéressée, voici un JSFiddle comparant la plupart des réponses données à cette question.
Et voici la méthode que j'ai finalement utilisée :
function decToHex(dec) {
return (dec + Math.pow(16, 6)).toString(16).substr(-6);
}
Gardez également à l'esprit que si vous souhaitez convertir du décimal en hexadécimal pour une utilisation en CSS en tant que type de données de couleur, vous préférerez peut-être extraire les valeurs RVB de la décimale et utiliser RVB().
Par exemple (JSFiddle):
var c = 4210330; // your color in decimal format
var rgb = [(c & 0xff0000) >> 16, (c & 0x00ff00) >> 8, (c & 0x0000ff)];
// assuming you're using jQuery...
$("#some-element").css("color", "rgb(" + rgb + ")");
Ceci définit #some-elementle CSS de color propriété à rgb(64, 62, 154).
Voici une version allégée d'ECMAScript 6 :
const convert = {
bin2dec : s => parseInt(s, 2).toString(10),
bin2hex : s => parseInt(s, 2).toString(16),
dec2bin : s => parseInt(s, 10).toString(2),
dec2hex : s => parseInt(s, 10).toString(16),
hex2bin : s => parseInt(s, 16).toString(2),
hex2dec : s => parseInt(s, 16).toString(10)
};
convert.bin2dec('111'); // '7'
convert.dec2hex('42'); // '2a'
convert.hex2bin('f8'); // '11111000'
convert.dec2bin('22'); // '10110'
Et si le nombre est négatif ?
Voici ma version.
function hexdec (hex_string) {
hex_string=((hex_string.charAt(1)!='X' && hex_string.charAt(1)!='x')?hex_string='0X'+hex_string : hex_string);
hex_string=(hex_string.charAt(2)<8 ? hex_string =hex_string-0x00000000 : hex_string=hex_string-0xFFFFFFFF-1);
return parseInt(hex_string, 10);
}
Vous pouvez vérifier ce qui suit Exemple JsFiddle ou un exemple de code JavaScript Stack Overflow.
'use strict';
var convertBase = function () {
function convertBase(baseFrom, baseTo) {
return function (num) {
return parseInt(num, baseFrom).toString(baseTo);
};
}
// Decimal to hexadecimal
convertBase.dec2hex = convertBase(10, 16);
return convertBase;
}();
alert(convertBase.dec2hex('42')); // '2a'Je fais une conversion en chaîne hexadécimale dans une boucle assez grande, j'ai donc essayé plusieurs techniques afin de trouver la plus rapide.Mes exigences étaient d'avoir une chaîne de longueur fixe et d'encoder correctement les valeurs négatives (-1 => ff..f).
Simple .toString(16) n'a pas fonctionné pour moi car j'avais besoin que les valeurs négatives soient correctement codées.Le code suivant est le plus rapide que j'ai testé jusqu'à présent sur des valeurs de 1 à 2 octets (notez que symbols définit le nombre de symboles de sortie que vous souhaitez obtenir, c'est-à-dire que pour un entier de 4 octets, il doit être égal à 8) :
var hex = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
function getHexRepresentation(num, symbols) {
var result = '';
while (symbols--) {
result = hex[num & 0xF] + result;
num >>= 4;
}
return result;
}
Il fonctionne plus vite que .toString(16) sur les nombres de 1 à 2 octets et plus lentement sur les nombres plus grands (lorsque symbols >= 6), mais devrait quand même surpasser les méthodes qui codent correctement les valeurs négatives.
Comme l'indique la réponse acceptée, le moyen le plus simple de convertir du décimal en hexadécimal est var hex = dec.toString(16).Cependant, vous préférerez peut-être ajouter une conversion de chaîne, car elle garantit que les représentations sous forme de chaîne telles que "12".toString(16) fonctionne correctement.
// Avoids a hard-to-track-down bug by returning `c` instead of `12`
(+"12").toString(16);
Pour inverser le processus, vous pouvez également utiliser la solution ci-dessous, car elle est encore plus courte.
var dec = +("0x" + hex);
Il semble être plus lent dans Google Chrome et Firefox, mais nettement plus rapide dans Opera.Voir http://jsperf.com/hex-to-dec.
Comment convertir un décimal en hexadécimal en JavaScript
Je n'ai pas pu trouver une conversion décimale en hexadécimal brutalement propre/simple qui n'impliquait pas un désordre de fonctions et de tableaux...donc j'ai dû le faire moi-même.
function DecToHex(decimal) { // Data (decimal)
length = -1; // Base string length
string = ''; // Source 'string'
characters = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ]; // character array
do { // Grab each nibble in reverse order because JavaScript has no unsigned left shift
string += characters[decimal & 0xF]; // Mask byte, get that character
++length; // Increment to length of string
} while (decimal >>>= 4); // For next character shift right 4 bits, or break on 0
decimal += 'x'; // Convert that 0 into a hex prefix string -> '0x'
do
decimal += string[length];
while (length--); // Flip string forwards, with the prefixed '0x'
return (decimal); // return (hexadecimal);
}
/* Original: */
D = 3678; // Data (decimal)
C = 0xF; // Check
A = D; // Accumulate
B = -1; // Base string length
S = ''; // Source 'string'
H = '0x'; // Destination 'string'
do {
++B;
A& = C;
switch(A) {
case 0xA: A='A'
break;
case 0xB: A='B'
break;
case 0xC: A='C'
break;
case 0xD: A='D'
break;
case 0xE: A='E'
break;
case 0xF: A='F'
break;
A = (A);
}
S += A;
D >>>= 0x04;
A = D;
} while(D)
do
H += S[B];
while (B--)
S = B = A = C = D; // Zero out variables
alert(H); // H: holds hexadecimal equivalent
Pour tout résumer;
function toHex(i, pad) {
if (typeof(pad) === 'undefined' || pad === null) {
pad = 2;
}
var strToParse = i.toString(16);
while (strToParse.length < pad) {
strToParse = "0" + strToParse;
}
var finalVal = parseInt(strToParse, 16);
if ( finalVal < 0 ) {
finalVal = 0xFFFFFFFF + finalVal + 1;
}
return finalVal;
}
Cependant, si vous n'avez pas besoin de le reconvertir en entier à la fin (c'est-à-direpour les couleurs), il suffit alors de s'assurer que les valeurs ne sont pas négatives.
Je n'ai pas trouvé de réponse claire, sans vérifier si elle est négative ou positive, qui utilise le complément à deux (nombres négatifs inclus).Pour cela, je montre ma solution à un octet :
((0xFF + number +1) & 0x0FF).toString(16);
Vous pouvez utiliser cette instruction pour n'importe quel nombre d'octets, il vous suffit d'ajouter FF aux endroits respectifs.Par exemple, sur deux octets :
((0xFFFF + number +1) & 0x0FFFF).toString(16);
Si vous souhaitez convertir un tableau entier en chaîne hexadécimale :
s = "";
for(var i = 0; i < arrayNumber.length; ++i) {
s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}
Si vous souhaitez convertir en une représentation JavaScript ou CSS « complète », vous pouvez utiliser quelque chose comme :
numToHex = function(num) {
var r=((0xff0000&num)>>16).toString(16),
g=((0x00ff00&num)>>8).toString(16),
b=(0x0000ff&num).toString(16);
if (r.length==1) { r = '0'+r; }
if (g.length==1) { g = '0'+g; }
if (b.length==1) { b = '0'+b; }
return '0x'+r+g+b; // ('#' instead of'0x' for CSS)
};
var dec = 5974678;
console.log( numToHex(dec) ); // 0x5b2a96
Vous pouvez faire quelque chose comme ça dans ECMAScript 6:
const toHex = num => (num).toString(16).toUpperCase();
Si vous cherchez à convertir de grands entiers, c'est-à-direNombres supérieurs à Number.MAX_SAFE_INTEGER -- 9007199254740991, vous pouvez alors utiliser le code suivant
const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)Voici ma solution :
hex = function(number) {
return '0x' + Math.abs(number).toString(16);
}
La question dit : "Comment convertir un nombre décimal en hexadécimal en JavaScript".Bien que la question ne précise pas que la chaîne hexadécimale doit commencer par un préfixe 0x, quiconque écrit du code doit savoir que 0x est ajouté aux codes hexadécimaux pour distinguer codes hexadécimaux depuis identifiants programmatiques et d'autres numéros (1234 peut être hexadécimal, décimal ou même octal).
Par conséquent, pour répondre correctement à cette question, dans le but d'écrire un script, vous devez ajouter le préfixe 0x.
La fonction Math.abs(N) convertit les négatifs en positifs et, en prime, il ne semble pas que quelqu'un l'ait passé dans une déchiqueteuse à bois.
La réponse que je voulais aurait eu un spécificateur de largeur de champ, afin que nous puissions par exemple afficher les valeurs 8/16/32/64 bits de la manière dont vous les verriez répertoriées dans une application d'édition hexadécimale.C’est la vraie et bonne réponse.
