Как преобразовать десятичное число в шестнадцатеричное в JavaScript

https://stackoverflow.com/questions/57803

09-06-2019
|

Вопрос

Как преобразовать десятичные значения в их шестнадцатеричный эквивалент в JavaScript?

Решение

Преобразуйте число в шестнадцатеричную строку с помощью:

hexString = yourNumber.toString(16);

И обратный процесс с помощью:

yourNumber = parseInt(hexString, 16);

Другие советы

Если вам нужно обрабатывать такие вещи, как битовые поля или 32-битные цвета, вам придется иметь дело со знаковыми числами.Функция JavaScript toString(16) вернет отрицательное шестнадцатеричное число, что обычно не то, что вам нужно.Эта функция делает какое-то безумное сложение, чтобы сделать число положительным.

function decimalToHexString(number)
{
  if (number < 0)
  {
    number = 0xFFFFFFFF + number + 1;
  }

  return number.toString(16).toUpperCase();
}

console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));

Код ниже преобразует десятичное значение d в шестнадцатеричное.Это также позволяет вам добавлять дополнения к шестнадцатеричному результату.Таким образом, 0 по умолчанию станет 00.

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()
}

С прокладкой:

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

Для завершения, если вы хотите дополнение до двух шестнадцатеричное представление отрицательного числа, вы можете использовать сдвиг вправо с заполнением нулями >>> оператор.Например:

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

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

Однако есть одно ограничение: Побитовые операторы JavaScript рассматривают свои операнды как последовательность из 32 битов., то есть вы получаете 32-битное дополнение до двух.

Без цикла:

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

Также не лучше ли не использовать циклические тесты, которые необходимо оценить?

Например, вместо:

for (var i = 0; i < hex.length; i++){}

иметь

for (var i = 0, var j = hex.length; i < j; i++){}

Объединив некоторые из этих хороших идей для функции преобразования значения RGB в шестнадцатеричный код (добавьте # в другом месте для 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);
}

Принятый ответ не учитывал однозначные возвращаемые шестнадцатеричные коды.Это легко корректируется:

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+ полезных функций регулярных выражений JavaScript для повышения эффективности ваших веб-приложений.

Обновлять:Протестировав эту штуку несколько раз, я обнаружил ошибку (двойные кавычки в RegExp), поэтому исправил ее.ОДНАКО!После небольшого тестирования и прочтения сообщения almaz я понял, что не могу заставить работать отрицательные числа.

Далее - я немного почитал об этом, и, поскольку все числа JavaScript сохраняются как 64-битные слова, несмотря ни на что, я попытался изменить код numHex, чтобы получить 64-битное слово.Но оказывается, этого сделать нельзя.Если вы поместите «3,14159265» КАК ЧИСЛО в переменную, все, что вы сможете получить, это «3», потому что дробная часть доступна только путем многократного умножения числа на десять (IE: 10.0).Или, говоря по-другому – шестнадцатеричный значение 0xF вызывает плавающая запятая значение, которое необходимо перевести в целое число перед тем, как будет выполнен оператор AND, который удалит все, что находится за точкой.Вместо того, чтобы брать значение в целом (т.е.:3.14159265) и операцию AND плавающая запятая значение против значения 0xF.

Поэтому лучшее, что можно сделать в этом случае, — это преобразовать 3,14159265 в нить а затем просто преобразуйте строку.Из-за вышесказанного также упрощается преобразование отрицательных чисел, поскольку знак минус просто становится 0x26 в начале значения.

Итак, я определил, что переменная содержит число — просто преобразую ее в строку и преобразую строку.Для всех это означает, что на стороне сервера вам нужно будет расшифровать входящую строку, а затем определить, что входящая информация является числовой.Вы можете сделать это легко, просто добавив «#» в начало чисел и «A» в начало возвращающейся строки символов.См. функцию toHex().

Веселиться!

Спустя еще год и долгие размышления я решил, что функцию «toHex» (а у меня также есть функция «fromHex») действительно необходимо обновить.Весь вопрос был: «Как я могу сделать это более эффективно?» Я решил, что функция A -от/от шестнадцатеричной функции не должна заботиться о том, является ли что -то дробной частью, но в то же время она должна гарантировать, что дробные части включены в строку.

Тогда возник вопрос: «Откуда вы знаете, что работаете с шестнадцатеричной строкой?».Ответ прост.Используйте стандартную информацию перед строкой, которая уже признана во всем мире.

Другими словами – используйте «0x».Итак, теперь моя функция toHex проверяет, существует ли она уже там, и если да, то она просто возвращает строку, которая была ей отправлена.В противном случае он преобразует строку, число или что угодно.Вот переработанная функция toHex://///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////// // tohex ().Преобразуйте строку ASCII в шестнадцатеричную./////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////// 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) == "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.Если вы хотите, чтобы он переводил Unicode, вам нужно будет изменить цикл на обработку четырех (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;

?>

Благодаря тому, как JavaScript работает с функцией toString(), можно устранить все те проблемы, которые раньше вызывали проблемы.Теперь все строки и числа можно легко конвертировать.Кроме того, такие вещи, как объекты, приводят к генерации ошибки самим JavaScript.Я считаю, что это настолько хорошо, насколько это возможно.Единственное улучшение, которое осталось для W3C, — это просто включить функции toHex() и fromHex() в JavaScript.

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

16 — это система счисления, а шестнадцатеричное число содержит 16 значений :-)

Ограничено/дополнено заданным количеством символов:

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
}

Если вы хотите преобразовать число в шестнадцатеричное представление значения цвета RGBA, я считаю, что это наиболее полезная комбинация нескольких советов отсюда:

function toHexString(n) {
    if(n < 0) {
        n = 0xFFFFFFFF + n + 1;
    }
    return "0x" + ("00000000" + n.toString(16).toUpperCase()).substr(-8);
}

Насколько мне известно комментарий 57807 неверно и должно быть что-то вроде:var hex = Number(d).toString(16);вместовар 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;
}

Для всех, кому интересно, здесь JSFiddle, сравнивающий большинство ответов на этот вопрос.

И вот метод, который я выбрал:

function decToHex(dec) {
    return (dec + Math.pow(16, 6)).toString(16).substr(-6);
}

Кроме того, имейте в виду, что если вы хотите преобразовать десятичное число в шестнадцатеричное для использования в CSS в качестве тип данных цвета, вместо этого вы можете предпочесть извлечь значения RGB из десятичной дроби и использовать RGB().

Например (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 + ")");

Это устанавливает #some-elementCSS color собственность rgb(64, 62, 154).

Вот урезанная версия 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'

А если число отрицательное?

Вот моя версия.

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

Вы можете проверить следующее Пример JsFiddle или пример кода JavaScript для переполнения стека.

'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'

Я выполняю преобразование в шестнадцатеричную строку в довольно большом цикле, поэтому попробовал несколько методов, чтобы найти самый быстрый.Мои требования заключались в том, чтобы в результате получить строку фиксированной длины и правильно закодировать отрицательные значения (-1 => ff..f).

Простой .toString(16) у меня не сработало, так как мне нужно было правильно закодировать отрицательные значения.Следующий код — самый быстрый из всех, что я когда-либо тестировал на значениях размером 1–2 байта (обратите внимание, что symbols определяет количество выходных символов, которое вы хотите получить, то есть для 4-байтового целого числа оно должно быть равно 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;
}

Он работает быстрее, чем .toString(16) на 1-2-байтовых числах и медленнее на больших числах (когда symbols >= 6), но все равно должен превосходить методы, которые правильно кодируют отрицательные значения.

Как говорится в принятом ответе, самый простой способ конвертировать десятичное число в шестнадцатеричное - это var hex = dec.toString(16).Однако вы можете предпочесть добавить преобразование строк, поскольку оно гарантирует, что строковые представления, такие как "12".toString(16) работать правильно.

// Avoids a hard-to-track-down bug by returning `c` instead of `12`
(+"12").toString(16);

Чтобы обратить процесс вспять, вы также можете использовать решение ниже, поскольку оно еще короче.

var dec = +("0x" + hex);

Кажется, что в Google Chrome и Firefox он медленнее, но в Opera он значительно быстрее.Видеть http://jsperf.com/hex-to-dec.

Как преобразовать десятичное число в шестнадцатеричное в JavaScript

Мне не удалось найти предельно чистое/простое преобразование десятичных чисел в шестнадцатеричные, которое не включало бы беспорядок функций и массивов...поэтому мне пришлось сделать это для себя.

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

Подводя итог всему этому;

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

Однако, если вам не нужно конвертировать его обратно в целое число в конце (т.для цветов), тогда достаточно просто убедиться, что значения не отрицательны.

Я не нашел четкого ответа без проверки, является ли он отрицательным или положительным, который использует дополнение до двух (включая отрицательные числа).Для этого я показываю свое решение в один байт:

((0xFF + number +1) & 0x0FF).toString(16);

Вы можете использовать эту инструкцию для любого количества байтов, только вы добавляете FF в соответствующих местах.Например, до двух байтов:

((0xFFFF + number +1) & 0x0FFFF).toString(16);

Если вы хотите преобразовать целое число массива в шестнадцатеричную строку:

s = "";
for(var i = 0; i < arrayNumber.length; ++i) {
    s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}

Если вы хотите преобразоваться в «полное» представление JavaScript или CSS, вы можете использовать что-то вроде:

  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

Вы можете сделать что-то подобное в ECMAScript 6:

const toHex = num => (num).toString(16).toUpperCase();

Если вы ищете преобразование больших целых чисел, т.е.Числа больше Number.MAX_SAFE_INTEGER -- 9007199254740991, тогда вы можете использовать следующий код

const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)

Вот мое решение:

hex = function(number) {
  return '0x' + Math.abs(number).toString(16);
}

В вопросе говорится: «Как преобразовать десятичное число в шестнадцатеричное в JavaScript».Хотя в вопросе не указано, что шестнадцатеричная строка должна начинаться с префикса 0x, любой, кто пишет код, должен знать, что 0x добавляется к шестнадцатеричным кодам, чтобы различать шестнадцатеричные коды от программные идентификаторы и другие номера (1234 может быть шестнадцатеричным, десятичным или даже восьмеричным).

Поэтому, чтобы правильно ответить на этот вопрос, для написания скриптов необходимо добавить префикс 0x.

Функция Math.abs(N) преобразует отрицательные значения в положительные, и в качестве бонуса не похоже, что кто-то пропустил ее через измельчитель древесины.

Ответ, который я хотел, должен был иметь спецификатор ширины поля, чтобы мы могли, например, отображать 8/16/32/64-битные значения так, как вы бы видели их в приложении для редактирования шестнадцатеричных чисел.Это настоящий и правильный ответ.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow