Umwandlung von Dezimal- in Hexadezimalzahlen in JavaScript

Question

Wie konvertiert man in JavaScript dezimale Werte in ihr hexadezimales Äquivalent?

Answer 1

• rgb(255, 255, 255) // ergibt FFFFFF

• rgb(255, 255, 300) // ergibt FFFFFF

• rgb(0,0,0) // ergibt 000000

• rgb(148, 0, 211) // ergibt 9400D3

   function rgb(...values){
            return values.reduce((acc, cur) => {
              let val = cur >= 255 ? 'ff' : cur <= 0 ? '00' : Number(cur).toString(16);
              return acc + (val.length === 1 ? '0'+val : val);
            }, '').toUpperCase();
        }

Answer 2

Beliebige Genauigkeit

Diese Lösung nimmt eine dezimale Zeichenkette als Eingabe und gibt eine hexadezimale Zeichenkette zurück. Dezimalbrüche werden unterstützt. Algorithmus

• Splitnummer zum Vorzeichen ( s ), ganzzahliger Teil ( i ) und den gebrochenen Teil ( f ) z.B. für -123.75 wir haben s=true , i=123 , f=75
• Ganzzahliger Teil in Hex:
  • wenn i='0' stoppen
  • get modulo: m=i%16 (in beliebiger Genauigkeit)
  • konvertieren m in Hexadezimalzahlen umwandeln und in die Ergebniszeichenfolge einfügen
  • für den nächsten Schritt den ganzzahligen Teil berechnen i=i/16 (in beliebiger Genauigkeit)

• Nachkommastelle

  • Nachkommastellen zählen n
  • multiplizieren k=f*16 (in beliebiger Genauigkeit)
  • geteilt k zum rechten Teil mit n Ziffern und setzen sie in f und den linken Teil mit dem Rest der Ziffern und setzen sie zu d
  • konvertieren d in Hex umwandeln und zum Ergebnis addieren.
  • Beenden, wenn die Anzahl der Nachkommastellen des Ergebnisses ausreichend ist

  // @param decStr - string with non-negative integer // @param divisor - positive integer function dec2HexArbitrary(decStr, fracDigits=0) {
  // Helper: divide arbitrary precision number by js number // @param decStr - string with non-negative integer // @param divisor - positive integer function arbDivision(decStr, divisor) { // algorithm https://www.geeksforgeeks.org/divide-large-number-represented-string/ let ans=''; let idx = 0; let temp = +decStr[idx]; while (temp < divisor) temp = temp * 10 + +decStr[++idx];

      while (decStr.length > idx) { 
          ans += (temp / divisor)|0 ; 
          temp = (temp % divisor) * 10 + +decStr[++idx]; 
      } 
  
      if (ans.length == 0) return "0"; 
  
      return ans; 
  } 
  
  // Helper: calc module of arbitrary precision number
  // @param decStr - string with non-negative integer
  // @param mod - positive integer
  function arbMod(decStr, mod) { 
    // algorithm https://www.geeksforgeeks.org/how-to-compute-mod-of-a-big-number/
    let res = 0; 
  
    for (let i = 0; i < decStr.length; i++) 
      res = (res * 10 + +decStr[i]) % mod; 
  
    return res; 
  } 
  
  // Helper: multiply arbitrary precision integer by js number
  // @param decStr - string with non-negative integer
  // @param mult - positive integer
  function arbMultiply(decStr, mult) {
    let r='';
    let m=0;
    for (let i = decStr.length-1; i >=0 ; i--) {
      let n = m+mult*(+decStr[i]);
      r= (i ? n%10 : n) + r 
      m= n/10|0;
    }
    return r;
  }
  
  // dec2hex algorithm starts here
  
  let h= '0123456789abcdef';                                         // hex 'alphabet'
  let m= decStr.match(/-?(.*?)\.(.*)?/) || decStr.match(/-?(.*)/);   // separate sign,integer,ractional
  let i= m[1].replace(/^0+/,'').replace(/^$/,'0');                   // integer part (without sign and leading zeros)
  let f= (m[2]||'0').replace(/0+$/,'').replace(/^$/,'0');            // fractional part (without last zeros)
  let s= decStr[0]=='-';                                                                             // sign
  
  let r='';                                                                                                          // result
  
  if(i=='0') r='0';
  
  while(i!='0') {                                                    // integer part
    r=h[arbMod(i,16)]+r; 
    i=arbDivision(i,16);
  }
  
  if(fracDigits) r+=".";
  
  let n = f.length;
  
  for(let j=0; j<fracDigits; j++) {                                  // frac part
    let k= arbMultiply(f,16);
    f = k.slice(-n);
    let d= k.slice(0,k.length-n); 
    r+= d.length ? h[+d] : '0';
  }
  
  return (s?'-':'')+r;

  }

  // ----------- // TESTS // -----------

  let tests = [ ["0",2], ["000",2],
  ["123",0], ["-123",0],
  ["00.000",2],

  ["255.75",5], ["-255.75",5], ["127.999",32], ];

  console.log('Input Standard Abitrary'); tests.forEach(t=> { let nonArb = (+t[0]).toString(16).padEnd(17,' '); let arb = dec2HexArbitrary(t[0],t[1]); console.log(t[0].padEnd(10,' '), nonArb, arb); });

  // Long Example (40 digits after dot) let example = "123456789012345678901234567890.09876543210987654321" console.log(\nLong Example:); console.log('dec:',example); console.log('hex: ',dec2HexArbitrary(example,40));

Answer 3

Das Problem besteht im Wesentlichen darin, wie viele Auffüllungsnullen zu erwarten sind.

Wenn Sie String erwarten 01 y 11 von Nummer 1 und 17. Es ist besser, die Puffer als Brücke, mit der die Zahl in Bytes umgewandelt wird, und das Hexadezimalformat ist dann nur ein Ausgabeformat davon. Und die Organisation der Bytes wird durch Buffer-Funktionen gut kontrolliert, wie schreibenUInt32BE , writeInt16LE , usw.

import { Buffer } from 'buffer';

function toHex(n) { // 4byte
  const buff = Buffer.alloc(4);
  buff.writeInt32BE(n);
  return buff.toString('hex');
}

> toHex(1)
'00000001'
> toHex(17)
'00000011'
> toHex(-1)
'ffffffff'
> toHex(-1212)
'fffffb44'
> toHex(1212)
'000004bc'

Answer 4

Hier ist meine Lösung:

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

Die Frage lautet: "Wie konvertiert man Dezimal in Hexadezimal in JavaScript" . In der Frage wird zwar nicht angegeben, dass die hexadezimale Zeichenfolge mit einem 0x-Präfix beginnen soll, aber jeder, der Code schreibt, sollte wissen, dass 0x an hexadezimale Codes angehängt wird, um sie zu unterscheiden hexadezimale Codes de programmatische Bezeichner y andere Zahlen (1234 kann hexadezimal, dezimal oder sogar oktal sein).

Um diese Frage richtig zu beantworten, müssen Sie daher für die Zwecke der Skripterstellung das Präfix 0x hinzufügen.

Die Funktion Math.abs(N) wandelt Negative in Positive um, und als Bonus sieht es nicht so aus, als hätte man es durch einen Holzhacker gejagt.

Die Antwort, die ich wollte, hätte einen Feldbreitenspezifizierer gehabt, so dass wir zum Beispiel 8/16/32/64-Bit-Werte so anzeigen könnten, wie sie in einer Hexadezimal-Editieranwendung aufgelistet werden. Das ist die eigentliche, richtige Antwort.