function decimalToHexString(number)
{
  if (number < 0)
  {
    number = 0xFFFFFFFF + number + 1;
  }
  return number.toString(16).toUpperCase();
}
console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));

Antwoord 3, Autoriteit 3%

De onderstaande code zal de decimale waarde d naar hexadecimaal converteren. Hiermee kunt u ook vulling toevoegen aan het hexadecimale resultaat. Dus 0 wordt standaard 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;
}

Antwoord 4, autoriteit 3%

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

Antwoord 5, autoriteit 2%

Voor de volledigheid: als je het two’s-complementhexadecimale weergave van een negatief getal, kunt u de zero-fill-right shift >>>operator. Bijvoorbeeld:

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

Er is echter één beperking: JavaScript bitsgewijze operators behandelen hun operanden als een reeks van 32 bits, dat wil zeggen dat u het 32-bits twee-complement krijgt.

Antwoord 6

Met opvulling:

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

Antwoord 7

Zonder de lus:

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

Is het ook niet beter om geen lustests te gebruiken die geëvalueerd moeten worden?

Bijvoorbeeld in plaats van:

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

hebben

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

Antwoord 8

Een paar van deze goede ideeën combineren voor een RGB-waarde-naar-hexadecimale functie (voeg de #elders toe voor 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);
}

Antwoord 9

Het geaccepteerde antwoord hield geen rekening met enkelcijferige geretourneerde hexadecimale codes. Dit is eenvoudig aan te passen door:

function numHex(s)
{
    var a = s.toString(16);
    if ((a.length % 2) > 0) {
        a = "0" + a;
    }
    return a;
}

en

function strHex(s)
{
    var a = "";
    for (var i=0; i<s.length; i++) {
        a = a + numHex(s.charCodeAt(i));
    }
    return a;
}

Ik geloof dat de bovenstaande antwoorden meerdere keren door anderen in een of andere vorm zijn gepost. Ik wikkel deze in een toHex() functie als volgt:

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

Merk op dat de numerieke reguliere expressie afkomstig is van 10+ handige JavaScript reguliere expressiefuncties om de efficiëntie van uw webapplicaties te verbeteren.

Update: nadat ik dit ding verschillende keren had getest, vond ik een fout (dubbele aanhalingstekens in de RegExp), dus ik heb dat opgelost. ECHTER! Na nogal wat testen en het bericht van almaz gelezen te hebben, realiseerde ik me dat ik geen negatieve getallen aan het werk kon krijgen.

Verder – ik heb hier wat over gelezen en aangezien alle JavaScript-nummers worden opgeslagen als 64-bits woorden, wat er ook gebeurt – heb ik geprobeerd de numHex-code aan te passen om het 64-bits woord te krijgen. Maar het blijkt dat je dat niet kunt. Als u “3.14159265” ALS EEN NUMMER in een variabele plaatst, krijgt u alleen de “3”, omdat het fractionele deel alleen toegankelijk is door het getal herhaaldelijk met tien te vermenigvuldigen (IE: 10,0). Of om dat anders te zeggen: de hexadecimalewaarde van 0xF zorgt ervoor dat de drijvende kommawaarde wordt vertaald in een integervoordat deze wordt ANDed die verwijdert alles achter de periode. In plaats van de waarde als geheel te nemen (d.w.z.: 3.14159265) en de drijvende kommawaarde te ANDEN tegen de 0xF-waarde.

Dus in dit geval is het het beste om de 3.14159265 te converteren naar een stringen vervolgens de string te converteren. Vanwege het bovenstaande maakt het het ook gemakkelijk om negatieve getallen om te zetten, omdat het minteken gewoon 0x26 wordt aan de voorkant van de waarde.

Dus wat ik deed, was bepalen dat de variabele een getal bevat – converteer het gewoon naar een string en converteer de string. Dit betekent voor iedereen dat je aan de serverkant de inkomende string moet unhexen en vervolgens moet bepalen dat de inkomende informatie numeriek is. U kunt dat eenvoudig doen door gewoon een “#” toe te voegen aan de voorkant van cijfers en “A” aan de voorkant van een tekenreeks die terugkomt. Zie de toHex() functie.

Veel plezier!

Na nog een jaar en veel nadenken, besloot ik dat de “toHex”-functie (en ik heb ook een “fromHex”-functie) echt moest worden vernieuwd. De hele vraag was: “Hoe kan ik dit efficiënter doen?” Ik heb besloten dat een to/from hexadecimale functie het niet uitmaakt of iets een fractioneel deel is, maar dat het er tegelijkertijd voor moet zorgen dat fractionele delen in de string worden opgenomen.

Dus toen werd de vraag: “Hoe weet je dat je met een hexadecimale tekenreeks werkt?”. Het antwoord is simpel. Gebruik de standaard pre-string informatie die al over de hele wereld wordt herkend.

Met andere woorden: gebruik “0x”. Dus nu kijkt mijn toHex-functie om te zien of dat er al is en als dat zo is – het retourneert gewoon de string die ernaar is verzonden. Anders converteert het de tekenreeks, het getal, wat dan ook. Hier is de herziene toHex-functie:

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

Dit is een zeer snelle functie die rekening houdt met enkele cijfers, drijvende puntnummers, en zelfs controleert of de persoon een hex-waarde verzendt om weer te hext. Het gebruikt slechts vier functie-oproepen en er zijn slechts twee van die in de lus. Om de waarden die u gebruikt om te verwijderen:

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

Net als de functie TOHEX (), zoekt de Fromhex () Functie eerst naar de “0x” en vervolgens vertaalt het de inkomende informatie in een string als het nog niet al een tekenreeks is. Ik weet niet hoe het niet een string zou zijn – maar voor het geval dat – ik controleer. De functie gaat dan door, grijpt twee personages en het vertalen van die naar ASCII-tekens. Als je het wilt om Unicode te vertalen, moet je de lus veranderen om met vier (4) tekens tegelijk te gaan. Maar dan moet u er ook voor zorgen dat de tekenreeks niet deelbaar is door vier. Als het is – dan is het een standaard hexadecimale string. (Denk eraan dat de string “0x” op de voorkant ervan heeft.)

Een eenvoudig testscript om aan te tonen dat -3.14159265, wanneer geconverteerd naar een string, is -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;
?>

Vanwege de manier waarop JavaScript werkt met betrekking tot de functie toString() kunnen al die problemen worden geëlimineerd die voorheen problemen veroorzaakten. Nu kunnen alle strings en cijfers eenvoudig worden omgezet. Verder zullen zaken als objecten ervoor zorgen dat een fout wordt gegenereerd door JavaScript zelf. Ik geloof dat dit ongeveer zo goed is als maar kan. De enige verbetering die overblijft is dat W3C alleen een toHex() en fromHex() functie in JavaScript opneemt.

Antwoord 10

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

De 16 is de radix en er zijn 16 waarden in een hexadecimaal getal 🙂

Antwoord 11

Voor iedereen die geïnteresseerd is, hier is een JSFiddle die de meeste antwoorden op deze vraag vergelijkt.

En hier is de methode die ik uiteindelijk heb gekozen:

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

Houd er ook rekening mee dat als u wilt converteren van decimaal naar hex voor gebruik in CSS als een kleurgegevenstype, kunt u in plaats daarvan de RGB-waarden uit het decimaalteken halen en rgb().

Bijvoorbeeld (JSFiddle):

let c = 4210330 // your color in decimal format
let rgb = [(c & 0xff0000) >> 16,  (c & 0x00ff00) >> 8,  (c & 0x0000ff)]
// Vanilla JS:
document..getElementById('some-element').style.color = 'rgb(' + rgb + ')'
// jQuery:
$('#some-element').css('color', 'rgb(' + rgb + ')')

Dit stelt #some-element‘s CSS coloreigenschap in op rgb(64, 62, 154).

Antwoord 12

Beperkt/opgevuld tot een bepaald aantal tekens:

function decimalToHex(decimal, chars) {
    return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}

Antwoord 13

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
}

Antwoord 14

Als je een getal wilt converteren naar een hexadecimale weergave van een RGBA-kleurwaarde, vind ik dit de handigste combinatie van verschillende tips van hier:

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

Antwoord 15

AFAIK commentaar 57807is verkeerd en zou zoiets moeten zijn als:
var hex = Getal(d).toString(16);
in plaats van
var 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;
}

Antwoord 16

En als het getal negatief is?

Hier is mijn versie.

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

Antwoord 17

Ik ben bezig met conversie naar hex-string in een vrij grote lus, dus ik heb verschillende technieken geprobeerd om de snelste te vinden. Mijn vereisten waren om een string met een vaste lengte te hebben en negatieve waarden correct te coderen (-1 => ff..f).

Eenvoudig .toString(16)werkte niet voor mij omdat ik negatieve waarden nodig had om correct te coderen. De volgende code is de snelste die ik tot nu toe heb getest op 1-2 byte-waarden (merk op dat symbolshet aantal uitvoersymbolen definieert dat u wilt krijgen, dat wil zeggen voor 4-byte integer zou het moeten zijn gelijk aan 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;
}

Het voert sneller uit dan .toString(16)op 1-2 byte-nummers en langzamer op grotere nummers (wanneer symbols& gt; = 6), maar nog steeds beter presteren methoden die de negatieve waarden correct coderen.

Antwoord 18

Zoals de geaccepteerde antwoordstaten, is de gemakkelijkste manier om te converteren van decimaal tot hexadecimaal var hex = dec.toString(16). U kunt echter liever een tekenreeksconversie toevoegen, omdat het garandeert dat string-representaties zoals "12".toString(16)correct werken.

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

Om het proces te keren, kunt u ook de onderstaande oplossing gebruiken, omdat deze zelfs korter is.

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

Het lijkt langzamer te zijn in Google Chrome en Firefox, maar is aanzienlijk sneller in Opera. Zie http://jsperf.com/hex-to-dec .

Antwoord 19

Hoe Decimal naar Hexadecimal in Javascript converteren

Ik was niet in staat om een ​​brutaal schoon / eenvoudige decimale tot hexadecimale conversie te vinden die geen puinhoop van functies en arrays heeft betrokken … dus ik moest dit voor mezelf maken.

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

Antwoord 20

Je kunt zoiets doen in ECMAScript 6:

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

Antwoord 21

Om het allemaal samen te vatten;

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

Als u het echter niet aan het eind terug naar een geheel getal hoeft te converteren (d.w.z. voor kleuren), zou het voldoende moeten zijn om ervoor te zorgen dat de waarden niet negatief zijn.

Antwoord 22

Ik heb geen duidelijk antwoord gevonden, zonder te controleren of het negatief of positief is, dat het complement van twee gebruikt (inclusief negatieve getallen). Daarvoor toon ik mijn oplossing tot één byte:

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

Je kunt deze instructie gebruiken voor elk willekeurig aantal bytes, alleen voeg je FFtoe op de respectievelijke plaatsen. Bijvoorbeeld tot twee bytes:

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

Als je een array integer wilt casten naar string hexadecimaal:

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

Antwoord 23

Als u wilt converteren naar een ‘volledige’ JavaScript- of CSS-representatie, kunt u zoiets gebruiken als:

 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

Antwoord 24

Als u op zoek bent naar het converteren van grote gehele getallen, d.w.z. getallen groter dan Number.MAX_SAFE_INTEGER — 9007199254740991, dan kunt u de volgende code gebruiken

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

function decimalToPaddedHexString(number, bitsize)
{ 
  let byteCount = Math.ceil(bitsize/8);
  let maxBinValue = Math.pow(2, bitsize)-1;
  /* In node.js this function fails for bitsize above 32bits */
  if (bitsize > 32)
    throw "number above maximum value";
  /* Conversion to unsigned form based on  */
  if (number < 0)
    number = maxBinValue + number + 1;
  return "0x"+(number >>> 0).toString(16).toUpperCase().padStart(byteCount*2, '0');
}

for (let n = 0 ; n < 64 ; n++ ) { 
     let s=decimalToPaddedHexString(-1, n); 
     console.log(`decimalToPaddedHexString(-1,${(n+"").padStart(2)}) = ${s.padStart(10)} = ${("0b"+parseInt(s).toString(2)).padStart(34)}`);
   }

decimalToPaddedHexString(-1, 0) =        0x0 =                                0b0
decimalToPaddedHexString(-1, 1) =       0x01 =                                0b1
decimalToPaddedHexString(-1, 2) =       0x03 =                               0b11
decimalToPaddedHexString(-1, 3) =       0x07 =                              0b111
decimalToPaddedHexString(-1, 4) =       0x0F =                             0b1111
decimalToPaddedHexString(-1, 5) =       0x1F =                            0b11111
decimalToPaddedHexString(-1, 6) =       0x3F =                           0b111111
decimalToPaddedHexString(-1, 7) =       0x7F =                          0b1111111
decimalToPaddedHexString(-1, 8) =       0xFF =                         0b11111111
decimalToPaddedHexString(-1, 9) =     0x01FF =                        0b111111111
decimalToPaddedHexString(-1,10) =     0x03FF =                       0b1111111111
decimalToPaddedHexString(-1,11) =     0x07FF =                      0b11111111111
decimalToPaddedHexString(-1,12) =     0x0FFF =                     0b111111111111
decimalToPaddedHexString(-1,13) =     0x1FFF =                    0b1111111111111
decimalToPaddedHexString(-1,14) =     0x3FFF =                   0b11111111111111
decimalToPaddedHexString(-1,15) =     0x7FFF =                  0b111111111111111
decimalToPaddedHexString(-1,16) =     0xFFFF =                 0b1111111111111111
decimalToPaddedHexString(-1,17) =   0x01FFFF =                0b11111111111111111
decimalToPaddedHexString(-1,18) =   0x03FFFF =               0b111111111111111111
decimalToPaddedHexString(-1,19) =   0x07FFFF =              0b1111111111111111111
decimalToPaddedHexString(-1,20) =   0x0FFFFF =             0b11111111111111111111
decimalToPaddedHexString(-1,21) =   0x1FFFFF =            0b111111111111111111111
decimalToPaddedHexString(-1,22) =   0x3FFFFF =           0b1111111111111111111111
decimalToPaddedHexString(-1,23) =   0x7FFFFF =          0b11111111111111111111111
decimalToPaddedHexString(-1,24) =   0xFFFFFF =         0b111111111111111111111111
decimalToPaddedHexString(-1,25) = 0x01FFFFFF =        0b1111111111111111111111111
decimalToPaddedHexString(-1,26) = 0x03FFFFFF =       0b11111111111111111111111111
decimalToPaddedHexString(-1,27) = 0x07FFFFFF =      0b111111111111111111111111111
decimalToPaddedHexString(-1,28) = 0x0FFFFFFF =     0b1111111111111111111111111111
decimalToPaddedHexString(-1,29) = 0x1FFFFFFF =    0b11111111111111111111111111111
decimalToPaddedHexString(-1,30) = 0x3FFFFFFF =   0b111111111111111111111111111111
decimalToPaddedHexString(-1,31) = 0x7FFFFFFF =  0b1111111111111111111111111111111
decimalToPaddedHexString(-1,32) = 0xFFFFFFFF = 0b11111111111111111111111111111111
Thrown: 'number above maximum value'

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