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

Ich würde gerne positive oder negative Ganzzahlen in Binärform sehen.

Eher wie diese Frage , aber für JavaScript.

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

dec2bin(1);    // 1
dec2bin(-1);   // 11111111111111111111111111111111
dec2bin(256);  // 100000000
dec2bin(-256); // 11111111111111111111111100000000

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

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

Wenn Sie ausführen (-1 >>> 0).toString(2), verschieben Sie Ihre Zahl 0-Bits nach rechts, wodurch die Zahl selbst nicht geändert wird, sondern als vorzeichenlose Ganzzahl dargestellt wird. Der obige Code wird "11111111111111111111111111111111"korrekt ausgegeben .

Diese Frage hat weitere Erklärungen.

-3 >>> 0 (rechte logische Verschiebung) erzwingt seine Argumente zu vorzeichenlosen Ganzzahlen, weshalb Sie die Komplementdarstellung der 32-Bit-Zwei von -3 erhalten.

Versuchen

num.toString(2);

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

Quelle hier

AKTUALISIEREN:

Dies funktioniert nur für positive Zahlen. Javascript repräsentiert negative binäre Ganzzahlen in Zweierkomplementnotation. Ich habe diese kleine Funktion gemacht, die den Trick machen sollte, ich habe sie nicht richtig getestet:

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 /programming/10936600/javascript-decimal-to-binary-64-bit 
        */
        return (~dec).toString(2);
    }
}

Ich hatte Hilfe von hier

Die Binärdatei in 'In Binär konvertieren' kann sich auf drei Hauptsachen beziehen. Das Positionsnummernsystem, die binäre Darstellung im Speicher oder 32-Bit-Bitstrings. (Für 64-Bit-Bitstrings siehe Patrick Roberts 'Antwort )

1. Zahlensystem

(123456).toString(2)konvertiert Zahlen in das Positionszahlensystem der Basis 2 . In diesem System werden negative Zahlen wie in Dezimalzahlen mit Minuszeichen geschrieben.

2. Interne Vertretung

Die interne Darstellung von Zahlen ist ein 64-Bit-Gleitkomma In dieser Antwort werden einige Einschränkungen erläutert . Es gibt keine einfache Möglichkeit , eine Bit-String-Darstellung davon in Javascript zu erstellen oder auf bestimmte Bits zuzugreifen.

3. Masken und bitweise Operatoren

MDN hat eine guten Überblick über die Funktionsweise bitweiser Operatoren. Wichtig:

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

Bevor Operationen angewendet werden, werden die 64-Bit-Gleitkommazahlen in 32-Bit-Ganzzahlen mit Vorzeichen umgewandelt. Nachdem sie zurück konvertiert wurden.

Hier ist der MDN-Beispielcode zum Konvertieren von Zahlen in 32-Bit-Zeichenfolgen.

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"

Ein einfacher Weg ist nur ...

Number(42).toString(2);

// "101010"

Diese Antwort versucht, Eingaben mit einem Absolutwert im Bereich von 2147483648 ₁₀ (2 ³¹ ) - 9007199254740991 ₁₀ (2 ⁵³ -1) zu adressieren .

In JavaScript werden Zahlen in einer 64-Bit-Gleitkommadarstellung gespeichert , aber bitweise Operationen zwingen sie zu 32-Bit-Ganzzahlen im Zweierkomplementformat. Daher beschränkt jeder Ansatz, der bitweise Operationen verwendet, den Ausgabebereich auf -2147483648 ₁₀ (-2 ³¹ ). - 2147483647 ₁₀ (2 ³¹ -1).

Wenn jedoch bitweise Operationen vermieden werden und die 64-Bit-Gleitkommadarstellung nur unter Verwendung mathematischer Operationen erhalten bleibt, können wir jede sichere Ganzzahl zuverlässig in die 64-Bit-Zweierkomplement- Binärnotation konvertieren, indem wir die 53-Bit-Zeichen vorzeichenerweiterern 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 jeden Radix (2–36) unterstützen, wenn Sie die Zweierkomplementkonvertierung für negative Zahlen in Ziffern ⌈64 / log ₂ (Radix) ⌉ durchführen, indem Sie Folgendes verwenden 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 ArrayBuffer, mit der eine Verbindung zwischen a Float64Arrayund a hergestellt wurde Uint16Array, lesen Sie bitte den Revisionsverlauf dieser Antwort .

Eine Lösung, mit der ich mich für 32-Bit entscheiden würde, ist der Code am Ende dieser Antwort, der von developer.mozilla.org (MDN) stammt, aber mit einigen Zeilen für A) Formatierung und B) Überprüfung der Nummer ist in Reichweite.

Einige schlugen vor, x.toString(2)was für Negative nicht funktioniert, es steckt nur ein Minuszeichen für sie, was nicht gut ist.

Fernando erwähnte eine einfache Lösung, (x>>>0).toString(2);die für Negative in Ordnung ist, aber ein kleines Problem hat, wenn x positiv ist. Der Ausgang beginnt mit 1, was für positive Zahlen kein richtiges 2s-Komplement ist.

Jeder, der die Tatsache von positiven Zahlen, die mit 0 beginnen, und negativen Zahlen mit 1 im 2s-Komplement nicht versteht, könnte diese SO QnA im 2s-Komplement überprüfen. Was ist "2's Complement"?

Eine Lösung könnte darin bestehen, positiven Zahlen eine 0 voranzustellen, was ich in einer früheren Überarbeitung dieser Antwort getan habe. Und man könnte akzeptieren, manchmal eine 33-Bit-Zahl zu haben, oder man könnte sicherstellen, dass die zu konvertierende Zahl innerhalb des Bereichs liegt - (2 ^ 31) <= x <2 ^ 31-1. Die Zahl ist also immer 32 Bit. Aber anstatt das zu tun, können Sie mit dieser Lösung auf mozilla.org gehen

Patricks Antwort und Code sind lang und funktionieren anscheinend für 64-Bit, hatten aber einen Fehler, den ein Kommentator gefunden hat, und der Kommentator hat den Fehler von Patrick behoben, aber Patrick hat eine "magische Zahl" in seinem Code, die er nicht kommentiert hat und hat vergessen und Patrick versteht seinen eigenen Code nicht mehr vollständig / warum er funktioniert.

Annan hatte eine falsche und unklare Terminologie, erwähnte jedoch eine Lösung von developer.mozilla.org https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators Dies funktioniert für 32-Bit-Zahlen.

Der Code ist ziemlich kompakt, eine Funktion von drei Zeilen.

Aber ich habe einen regulären Ausdruck hinzugefügt, um die Ausgabe in Gruppen von 8 Bit zu formatieren. Basierend auf dem Drucken einer Zahl mit Kommas als Tausendertrennzeichen in JavaScript (Ich habe sie gerade geändert, indem ich sie in 3 Sekunden von rechts nach links gruppiert und Kommas hinzugefügt habe , in 8 Sekunden von rechts nach links gruppiert und Leerzeichen hinzugefügt habe ).

Und während Mozilla einen Kommentar zur Größe von nMask (der eingegebenen Nummer) abgegeben hat, dass sie im Bereich liegen muss, haben sie keinen Fehler getestet oder ausgelöst, wenn die Nummer außerhalb des Bereichs liegt fügte hinzu, dass.

Ich bin mir nicht sicher, warum sie ihren Parameter 'nMask' genannt haben, aber ich werde das so lassen, wie es ist.

Referenz: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators

function createBinaryString(nMask) {
  // nMask must be between -2147483648 and 2147483647
  if (nMask > 2**31-1) 
     throw "number too large. number shouldn't be > 2**31-1"; //added
  if (nMask < -1*(2**31))
     throw "number too far negative, number shouldn't be < 2**31" //added
  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  sMask=sMask.replace(/\B(?=(.{8})+(?!.))/g, " ") // added
  return sMask;
}


console.log(createBinaryString(-1))    // "11111111 11111111 11111111 11111111"
console.log(createBinaryString(1024))  // "00000000 00000000 00000100 00000000"
console.log(createBinaryString(-2))    // "11111111 11111111 11111111 11111110"
console.log(createBinaryString(-1024)) // "11111111 11111111 11111100 00000000"

Sie können Ihre eigene Funktion schreiben, die ein Array von Bits zurückgibt. Beispiel zum Konvertieren von Zahlen in Bits

Teiler | Dividende | Bits / Rest

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

~ | 1 | ~

Beispiel der obigen Zeile: 2 * 4 = 8 und der Rest ist 1, also 9 = 1 0 0 1

function numToBit(num){
    var number = num
    var result = []
    while(number >= 1 ){
        result.unshift(Math.floor(number%2))
        number = number/2
    }
    return result
}

Reste von unten nach oben lesen. Ziffer 1 in der Mitte nach oben.

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 ihn an einem relevanten Ort belassen, falls er für jemanden nützlich ist.

• Verwendet keine Bitverschiebung oder Zweierkomplement-Zwang.
• Sie wählen die Anzahl der ausgegebenen Bits (es wird nach gültigen Werten von '8', '16', '32' gesucht, aber ich nehme an, Sie könnten das ändern)
• Sie wählen, ob Sie es als vorzeichenbehaftete oder vorzeichenlose Ganzzahl behandeln möchten.
• Angesichts der Kombination aus vorzeichenbehafteten / vorzeichenlosen und Anzahl der Bits wird nach Bereichsproblemen gesucht. Sie sollten jedoch die Fehlerbehandlung verbessern.
• Es hat auch die "umgekehrte" Version der Funktion, die die Bits zurück in das int konvertiert. Sie werden das brauchen, da es wahrscheinlich nichts anderes gibt, das diese Ausgabe interpretiert: 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("---");

Noch eine 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));

Das ist mein Code:

var x = prompt("enter number", "7");
var i = 0;
var binaryvar = " ";

function add(n) {
    if (n == 0) {
        binaryvar = "0" + binaryvar; 
    }
    else {
        binaryvar = "1" + binaryvar;
    }
}

function binary() {
    while (i < 1) {
        if (x == 1) {
            add(1);
            document.write(binaryvar);
            break;
        }
        else {
            if (x % 2 == 0) {
                x = x / 2;
                add(0);
            }
            else {
                x = (x - 1) / 2;
                add(1);
            }
        }
    }
}

binary();

Das ist die Lösung. Tatsächlich ist es ganz einfach

function binaries(num1){ 
        var str = num1.toString(2)
        return(console.log('The binary form of ' + num1 + ' is: ' + str))
     }
     binaries(3

)

        /*
         According to MDN, Number.prototype.toString() overrides 
         Object.prototype.toString() with the useful distinction that you can 
         pass in a single integer argument. This argument is an optional radix, 
         numbers 2 to 36 allowed.So in the example above, we’re passing in 2 to 
         get a string representation of the binary for the base 10 number 100, 
         i.e. 1100100.
        */