Wie konvertiere ich in JavaScript eine Ganzzahl in eine Binärzahl?

Question

Ich würde gerne ganze Zahlen, positiv oder negativ, in binärer Form sehen.

Eher wie この質問 sondern für JavaScript.

Answer 1

function dec2bin(dec) {
  return (dec >>> 0).toString(2);
}

console.log(dec2bin(1)); // 1
console.log(dec2bin(-1)); // 11111111111111111111111111111111
console.log(dec2bin(256)); // 100000000
console.log(dec2bin(-256)); // 11111111111111111111111100000000

Sie können verwenden Number.toString(2) Funktion, aber sie hat einige Probleme bei der Darstellung negativer Zahlen. Zum Beispiel, (-1).toString(2) Ausgabe ist "-1" .

Um dieses Problem zu beheben, können Sie den bitweisen Operator für die vorzeichenlose Rechtsverschiebung verwenden ( >>> ), um Ihre Zahl in eine Ganzzahl ohne Vorzeichen umzuwandeln.

Wenn Sie (-1 >>> 0).toString(2) wird die Zahl um 0 Bits nach rechts verschoben, was die Zahl selbst nicht verändert, aber sie wird als Ganzzahl ohne Vorzeichen dargestellt. Der obige Code gibt Folgendes aus "11111111111111111111111111111111" richtig.

Diese Frage hat weitere Erklärungen.

-3 >>> 0 (rechte logische Verschiebung) zwingt seine Argumente in vorzeichenlose Ganzzahlen, weshalb man die 32-Bit-Zweierkomplement-Darstellung von -3 erhält.

Answer 2

Versuchen Sie

num.toString(2);

Die 2 ist das Radix und kann eine beliebige Basis zwischen 2 und 36 sein.

fuente aquí

UPDATE:

Dies funktioniert nur für positive Zahlen, Javascript stellt negative binäre Ganzzahlen in Zweierkomplementnotation dar. Ich habe diese kleine Funktion, die den Trick tun sollte, habe ich nicht getestet es aus richtig:

function dec2Bin(dec)
{
    if(dec >= 0) {
        return dec.toString(2);
    }
    else {
        /* Here you could represent the number in 2s compliment but this is not what 
           JS uses as its not sure how many bits are in your number range. There are 
           some suggestions https://stackoverflow.com/questions/10936600/javascript-decimal-to-binary-64-bit 
        */
        return (~dec).toString(2);
    }
}

Ich hatte etwas Hilfe von aquí

Answer 3

Ein einfacher Weg ist einfach...

Number(42).toString(2);

// "101010"

Answer 4

Das Binäre in 'convert to binary' kann sich auf drei Dinge beziehen. Das Positionszahlensystem, die binäre Darstellung im Speicher oder 32-Bit-Bitstrings. (für 64bit-Bitstrings siehe Antwort von Patrick Roberts )

1. Nummernsystem

(123456).toString(2) konvertiert Zahlen zur Basis 2 Stellenwertziffernsystem . In diesem System werden negative Zahlen mit Minuszeichen geschrieben, genau wie im Dezimalsystem.

2. Interne Repräsentation

Die interne Darstellung von Zahlen ist 64-Bit-Gleitkomma und einige Einschränkungen werden in diese Antwort . Es gibt kein einfacher Weg um eine Bit-String-Darstellung in Javascript zu erstellen und auf bestimmte Bits zuzugreifen.

3. Masken und bitweise Operatoren

MDN hat eine guter Überblick wie die bitweisen Operatoren funktionieren. Das ist wichtig:

Bitweise Operatoren behandeln ihre Operanden als eine Folge von 32 Bits (Nullen und Einsen)

Bevor Operationen durchgeführt werden, werden die 64-Bit-Gleitkommazahlen in 32-Bit-Ganzzahlen mit Vorzeichen umgewandelt. Nach der Konvertierung werden sie zurückgewandelt.

Hier ist der MDN-Beispielcode für die Umwandlung von Zahlen in 32-Bit-Strings.

function createBinaryString (nMask) {
  // nMask must be between -2147483648 and 2147483647
  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  return sMask;
}

createBinaryString(0) //-> "00000000000000000000000000000000"
createBinaryString(123) //-> "00000000000000000000000001111011"
createBinaryString(-1) //-> "11111111111111111111111111111111"
createBinaryString(-1123456) //-> "11111111111011101101101110000000"
createBinaryString(0x7fffffff) //-> "01111111111111111111111111111111"

Answer 5

Mit dieser Antwort wird versucht, Eingaben mit einem absoluten Wert im Bereich von 2147483648 ₁₀ (2 31 ) - 9007199254740991 ₁₀ (2 53 -1).

---

In JavaScript werden die Zahlen in 64-Bit-Gleitkommadarstellung aber bitweise Operationen zwingen sie zu 32-Bit-Ganzzahlen sur Zweierkomplementformat Jeder Ansatz, der bitweise Operationen verwendet, schränkt den Bereich der Ausgabe auf -2147483648 ein. ₁₀ (-2 31 ) - 2147483647 ₁₀ (2 31 -1).

Wenn jedoch bitweise Operationen vermieden werden und die 64-Bit-Gleitkommadarstellung nur durch mathematische Operationen beibehalten wird, können wir zuverlässig jede sichere Ganzzahl in 64-Bit-Zweierkomplement-Binärschreibweise durch Vorzeichenerweiterung der 53-Bit twosComplement :

function toBinary (value) {
  if (!Number.isSafeInteger(value)) {
    throw new TypeError('value must be a safe integer');
  }

  const negative = value < 0;
  const twosComplement = negative ? Number.MAX_SAFE_INTEGER + value + 1 : value;
  const signExtend = negative ? '1' : '0';

  return twosComplement.toString(2).padStart(53, '0').padStart(64, signExtend);
}

function format (value) {
  console.log(value.toString().padStart(64));
  console.log(value.toString(2).padStart(64));
  console.log(toBinary(value));
}

format(8);
format(-8);
format(2**33-1);
format(-(2**33-1));
format(2**53-1);
format(-(2**53-1));
format(2**52);
format(-(2**52));
format(2**52+1);
format(-(2**52+1));

.as-console-wrapper{max-height:100%!important}

Für ältere Browser gibt es Polyfills für die folgenden Funktionen und Werte:

• Number.isSafeInteger()
• Number.isInteger()
• Number.MAX_SAFE_INTEGER
• String.prototype.padStart()

Als zusätzlichen Bonus können Sie jede Radix (2-36) unterstützen, wenn Sie die Zweierkomplement-Konvertierung für negative Zahlen in 64 / log durchführen ₂ (Radix-)Ziffern durch Verwendung von BigInt :

function toRadix (value, radix) {
  if (!Number.isSafeInteger(value)) {
    throw new TypeError('value must be a safe integer');
  }

  const digits = Math.ceil(64 / Math.log2(radix));
  const twosComplement = value < 0
    ? BigInt(radix) ** BigInt(digits) + BigInt(value)
    : value;

  return twosComplement.toString(radix).padStart(digits, '0');
}

console.log(toRadix(0xcba9876543210, 2));
console.log(toRadix(-0xcba9876543210, 2));
console.log(toRadix(0xcba9876543210, 16));
console.log(toRadix(-0xcba9876543210, 16));
console.log(toRadix(0x1032547698bac, 2));
console.log(toRadix(-0x1032547698bac, 2));
console.log(toRadix(0x1032547698bac, 16));
console.log(toRadix(-0x1032547698bac, 16));

.as-console-wrapper{max-height:100%!important}

Wenn Sie an meiner alten Antwort interessiert sind, die ein ArrayBuffer um eine Vereinigung zwischen einer Float64Array und eine Uint16Array finden Sie in dieser Antwort Revisionsgeschichte .