Question Comment convertir décimal en hexadécimal en JavaScript?


Comment convertir les valeurs décimales en leur équivalent hexadécimal en JavaScript?


1184
2017-09-11 22:26


origine


Réponses:


Convertir un nombre en une chaîne hexadécimale avec:

hexString = yourNumber.toString(16);

et inversez le processus avec:

yourNumber = parseInt(hexString, 16);

1988
2017-09-11 22:28



Si vous devez gérer des éléments tels que les champs de bits ou les couleurs 32 bits, vous devez traiter les 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 voulez. Cette fonction fait une addition folle 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));


119
2018-03-30 16:05



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;
}

68
2017-09-11 22:29



function toHex(d) {
    return  ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}

44
2017-11-05 21:08



Avec rembourrage:

function dec2hex(i) {
   return (i+0x10000).toString(16).substr(-4).toUpperCase();
}

30
2017-07-13 14:29



Pour l'achèvement, si vous voulez le complément à deux représentation hexadécimale d'un nombre négatif, vous pouvez utiliser la décalage zéro-remplissage-droite >>> opérateur. Par exemple:

> (-1).toString(16)
"-1"

> ((-2)>>>0).toString(16)
"fffffffe"

Il y a cependant une limitation: opérateurs bitwise javascript traitent leurs opérandes comme une séquence de 32 bitsc'est-à-dire que vous obtenez le complément à deux bits de 32 bits.


25
2018-06-14 10:59



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

Aussi n'est-il pas préférable de ne pas utiliser des tests en 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++){}

16
2017-09-11 03:05



Combiner certaines de ces bonnes idées pour une fonction rgb 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);
}

13
2017-11-15 12:44



La réponse acceptée n'a pas pris en compte les codes hexadécimaux retourné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é postées plusieurs fois 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 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 le RegExp) donc j'ai corrigé ça. TOUTEFOIS! Après un peu de test et après avoir lu le post par almaz - je me suis rendu compte que je ne pouvais pas obtenir des nombres négatifs à travailler. En outre - j'ai fait quelques lectures sur ceci et puisque tous les nombres de Javascript sont stockés en tant que 64 mots peu importe quoi - j'ai essayé de modifier le code de 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 un nombre dans une variable - tout ce que vous pourrez obtenir est le "3" parce que la partie fractionnaire est seulement accessible en multipliant le nombre par dix (IE: 10.0) à plusieurs reprises. Ou pour le dire autrement - la valeur HEX de 0xf provoque la traduction de la valeur FLOATING POINT en INTEGER avant qu'elle ne soit ANDed ce qui supprime tout derrière la période. Plutôt que de prendre la valeur dans son ensemble (par exemple: 3.14159265) et d'appliquer la valeur FLOATING POINT à la valeur 0xf. Donc, la meilleure chose à faire, dans ce cas, est de convertir le 3.14159265 en une chaîne, puis simplement convertir la chaîne. En raison de ce qui précède, il est également facile de convertir des nombres négatifs parce que le signe moins devient juste 0x26 sur le devant de la valeur. Donc ce que j'ai fait était de déterminer que la variable contient un nombre - juste le convertir en une chaîne et convertir la chaîne. Qu'est-ce que cela signifie pour tout le monde, c'est que sur le côté serveur, vous devrez débloquer la chaîne entrante, puis de déterminer l'information entrante est numérique. Vous pouvez le faire facilement en ajoutant simplement un "#" au début des chiffres et "A" au début d'une chaîne de caractères revenant. Voir la fonction toHex ().

S'amuser!

Après une autre année 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 réorganisée. Toute la question était "Comment puis-je faire cela plus efficacement?" J'ai décidé que la fonction hexadécimale ne devrait pas se préoccuper de savoir si quelque chose est une partie fractionnaire mais en même temps elle devrait s'assurer 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 de pré-chaîne standard déjà reconnues dans le monde entier. En d'autres termes, utilisez "0x". Alors maintenant, ma fonction toHex cherche à voir si elle est déjà là et si elle l'est, elle renvoie juste 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().  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;
}

C'est une fonction très rapide qui prend en compte des chiffres uniques, des nombres à virgule flottante et même des vérifications pour voir si la personne envoie une valeur hexadécimale pour être à nouveau hexadécimée. Il utilise seulement quatre appels de fonction et seulement deux d'entre eux sont dans la boucle. Pour décocher 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 l'information entrante en une chaîne si elle n'est pas déjà une chaîne. Je ne sais pas comment ça ne serait pas une ficelle - mais juste au cas où - je vérifie. La fonction passe ensuite à travers, en saisissant deux caractères et en traduisant ceux en caractères ascii. Si vous voulez traduire unicode, vous devrez changer la boucle en passant par quatre (4) caractères à la fois. Mais alors vous devez également vous assurer que la chaîne n'est pas divisible par quatre. Si c'est le cas, alors c'est une chaîne hexagonale standard. (Rappelez-vous que la chaîne a "0x" sur le devant de celle-ci.)

Un script de test simple pour montrer que -3.14159265, lorsqu'il est converti en une 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 de la façon dont Javascript fonctionne par rapport à la fonction toString (), tous ces problèmes peuvent être éliminés, ce qui auparavant causait des problèmes. Maintenant, toutes les chaînes et les nombres peuvent être convertis facilement. En outre, des choses telles que des objets provoqueront une erreur générée par Javascript lui-même. Je crois que c'est à peu près aussi bon que ça. La seule amélioration qui reste est que W3C inclue juste une fonction toHex () et fromHex () en Javascript.


11
2017-11-06 16:21



var number = 3200;
var hexString = number.toString(16);

Le 16 est la base et il y a 16 valeurs dans un nombre hexadécimal :-)


10
2017-09-11 22:32