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

Können wir auch das Binärsystem für positive oder negative Zahlen wie folgt berechnen:

function toBinary(n){
    let binary = "";
    if (n < 0) {
      n = n >>> 0;
    }
    while(Math.ceil(n/2) > 0){
        binary = n%2 + binary;
        n = Math.floor(n/2);
    }
    return binary;
}

console.log(toBinary(7));
console.log(toBinary(-7));

Answer 2

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

Dies ist eine alte Frage, und ich denke, dass es hier sehr gute Lösungen gibt, aber es gibt keine Erklärung für die Verwendung dieser cleveren Lösungen.

Zunächst müssen wir verstehen, dass eine Zahl positiv oder negativ sein kann. Außerdem bietet JavaScript eine MAX_SAFE_INTEGER Konstante, die einen Wert von 9007199254740991 . Der Grund für diese Zahl ist, dass JavaScript doppeltgenaue Gleitkommazahl Formatnummern gemäß den Angaben in IEEE 754 und kann nur ganze Zahlen zwischen -(2^53 - 1) y 2^53 - 1 .

Jetzt kennen wir also den Bereich, in dem Zahlen "sicher" sind. Außerdem hat JavaScript ES6 die eingebaute Methode Number.isSafeInteger() um zu prüfen, ob eine Zahl eine sichere Ganzzahl ist.

Wenn wir eine Zahl darstellen wollen, ist es logisch, dass n als Binärzahl benötigt diese Zahl eine Länge von 53 Bits, aber zur besseren Darstellung verwenden wir 7 Gruppen von 8 Bits = 56 Bits und füllen die linke Seite mit 0 o 1 auf der Grundlage seines Vorzeichens unter Verwendung der padStart Funktion.

Als Nächstes müssen wir mit positiven und negativen Zahlen umgehen: Positive Zahlen werden addiert 0 s nach links, negative Zahlen addieren 1 s. Auch negative Zahlen benötigen eine Zweierkomplement-Darstellung. Wir können dies leicht beheben, indem wir Folgendes hinzufügen Number.MAX_SAFE_INTEGER + 1 zur Nummer.

Wir wollen zum Beispiel Folgendes darstellen -3 als binär, nehmen wir an, dass Number.MAX_SAFE_INTEGER es 00000000 11111111 (255) では Number.MAX_SAFE_INTEGER + 1 wird 00000001 00000000 (256) . Fügen wir nun die Zahl Number.MAX_SAFE_INTEGER + 1 - 3 dies wird 00000000 11111101 (253) aber wie gesagt, wir werden die linke Seite mit 1 wie diese 11111111 11111101 (-3) stellt dies -3 im Binärformat.

Ein weiterer Algorithmus wird sein, dass wir 1 an die Zahl anhängen und das Vorzeichen wie folgt umkehren -(-3 + 1) = 2 dies wird 00000000 00000010 (2) . Jetzt kehren wir jedes Bit folgendermaßen um 11111111 11111101 (-3) haben wir wieder eine binäre Darstellung von -3 .

Hier haben wir ein funktionierendes Snippet dieser Algos:

function dec2binA(n) {
    if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer')
    if (n > 2**31) throw 'number too large. number should not be greater than 2**31'
    if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31'

    const bin = n < 0 ? Number.MAX_SAFE_INTEGER + 1 + n : n
    const signBit = n < 0 ? '1' : '0'

    return parseInt(bin, 10).toString(2)
        .padStart(56, signBit)
        .replace(/\B(?=(.{8})+(?!.))/g, ' ')
}

function dec2binB(n) {
    if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer')
    if (n > 2**31) throw 'number too large. number should not be greater than 2**31'
    if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31'

    const bin = n < 0 ?  -(1 + n) : n
    const signBit = n < 0 ? '1' : '0'

    return parseInt(bin, 10).toString(2)
        .replace(/[01]/g, d => +!+d)
        .padStart(56, signBit)
        .replace(/\B(?=(.{8})+(?!.))/g, ' ')
}

const a = -805306368
console.log(a)
console.log('dec2binA:', dec2binA(a))
console.log('dec2binB:', dec2binB(a))

const b = -3
console.log(b)
console.log('dec2binA:', dec2binA(b))
console.log('dec2binB:', dec2binB(b))

Answer 3

Eine weitere Alternative

const decToBin = dec => {
  let bin = '';
  let f = false;

  while (!f) {
    bin = bin + (dec % 2);    
    dec = Math.trunc(dec / 2);  

    if (dec === 0 ) f = true;
  }

  return bin.split("").reverse().join("");
}

console.log(decToBin(0));
console.log(decToBin(1));
console.log(decToBin(2));
console.log(decToBin(3));
console.log(decToBin(4));
console.log(decToBin(5));
console.log(decToBin(6));

Answer 4

Ich habe einen anderen Ansatz gewählt, um etwas zu finden, das dies tut. Ich habe beschlossen, diesen Code nicht in meinem Projekt zu verwenden, aber ich dachte, ich würde es irgendwo relevant zu verlassen, für den Fall, dass es für jemanden nützlich ist.

• Verwendet keine Bitverschiebung oder Zweierkomplement-Zwang.
• Du wählst die Anzahl der Bits, die herauskommen (es wird nach gültigen Werten von '8', '16', '32' gesucht, aber ich nehme an, du kannst das ändern)
• Sie können wählen, ob sie als Ganzzahl mit oder ohne Vorzeichen behandelt werden soll.
• Die Kombination von vorzeichenbehaftet/unvorzeichenbehaftet und die Anzahl der Bits wird auf Bereichsprobleme geprüft, obwohl Sie die Fehlerbehandlung verbessern sollten.

• Es hat auch die "umgekehrte" Version der Funktion, die die Bits zurück in den int konvertiert. Das werden Sie brauchen, da es wahrscheinlich nichts anderes gibt, das diese Ausgabe interpretieren kann :D

  function intToBitString(input, size, unsigned) { if ([8, 16, 32].indexOf(size) == -1) { throw "invalid params"; } var min = unsigned ? 0 : - (2 size / 2); var limit = unsigned ? 2 size : 2 ** size / 2; if (!Number.isInteger(input) || input < min || input >= limit) { throw "out of range or not an int"; } if (!unsigned) { input += limit; } var binary = input.toString(2).replace(/^-/, ''); return binary.padStart(size, '0'); }

  function bitStringToInt(input, size, unsigned) { if ([8, 16, 32].indexOf(size) == -1) { throw "invalid params"; } input = parseInt(input, 2); if (!unsigned) { input -= 2 ** size / 2; } return input; }

  // EXAMPLES

  var res; console.log("(uint8)10"); res = intToBitString(10, 8, true); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(uint8)127"); res = intToBitString(127, 8, true); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(int8)127"); res = intToBitString(127, 8, false); console.log("intToBitString(res, 8, false)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, false)); console.log("---");

  console.log("(int8)-128"); res = intToBitString(-128, 8, false); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(uint16)5000"); res = intToBitString(5000, 16, true); console.log("intToBitString(res, 16, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 16, true)); console.log("---");

  console.log("(uint32)5000"); res = intToBitString(5000, 32, true); console.log("intToBitString(res, 32, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 32, true)); console.log("---");

Answer 5

Dies ist eine Methode, die ich verwende. Es ist eine sehr schnelle und prägnante Methode, die für ganze Zahlen funktioniert.

Wenn Sie möchten, funktioniert diese Methode auch mit BigInts. Sie müssen nur jede 1 a 1n .

// Assuming {num} is a whole number
function toBin(num){
    let str = "";
    do {
        str = `${num & 1}${str}`;
        num >>= 1;
    } while(num);
    return str
}

Erläuterung

Bei dieser Methode werden alle Bits der Zahl durchlaufen, als ob sie bereits eine Binärzahl wäre.

Sie beginnt mit einer leeren Zeichenkette und stellt dann das letzte Bit voran. num & 1 gibt das letzte Bit der Zahl zurück ( 1 o 0 ). num >>= 1 entfernt dann das letzte Bit und macht das vorletzte Bit zum neuen letzten Bit. Der Vorgang wird so lange wiederholt, bis alle Bits gelesen worden sind.

Dies ist natürlich eine extreme Vereinfachung der tatsächlichen Vorgänge. Aber so kann ich es verallgemeinern.