JavaScriptで整数をバイナリに変換するにはどうすればよいですか？

正または負の整数を2進数で表示したいのですが。

むしろこの質問のようですが、JavaScript用です。

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

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

Number.toString(2)関数を使用できますが、負の数を表すときにいくつかの問題があります。たとえば、(-1).toString(2)出力は"-1"です。

この問題を解決するには、符号なし右シフトビット演算子（>>>）を使用して、数値を符号なし整数に強制変換します。

実行(-1 >>> 0).toString(2)すると、数値を0ビット右にシフトします。これにより、数値自体は変更されませんが、符号なし整数として表されます。上記のコードは"11111111111111111111111111111111"正しく出力されます。

この質問にはさらに説明があります。

-3 >>> 0 （右論理シフト）は、引数を符号なし整数に強制変換します。これが、32ビットの2の補数表現-3を取得する理由です。

試す

num.toString(2);

2は基数であり、2から36までの任意の基数を指定できます

ここにソース

更新：

これは正の数に対してのみ機能します。JavaScriptは負の2進整数を2の補数表記で表します。私はトリックを行うべきこの小さな関数を作りました、私はそれを適切にテストしていません：

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

ここから助けてもらいました

「バイナリに変換」のバイナリは、主に3つのことを指します。位置番号システム、メモリ内のバイナリ表現または32ビットのビット文字列。（64ビットのビット文字列については、Patrick Robertsの回答を参照してください）

1.番号システム

(123456).toString(2)数値を基数2の位置数値システムに変換します。このシステムでは、負の数は、10進数と同じようにマイナス記号で書き込まれます。

2.内部表現

数値の内部表現は64ビット浮動小数点であり、この回答ではいくつかの制限について説明します。JavaScriptでこれのビット文字列表現を作成したり、特定のビットにアクセスしたりする簡単な方法はありません。

3.マスクとビットごとの演算子

MDNには、ビットごとの演算子がどのように機能するかについての概要がわかります。重要なこと：

ビット演算子は、オペランドを32ビットのシーケンス（0と1）として扱います。

操作が適用される前に、64ビットの浮動小数点数が32ビットの符号付き整数にキャストされます。それらが元に戻された後。

以下は、数値を32ビット文字列に変換するためのMDNサンプルコードです。

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"

簡単な方法はただ...

Number(42).toString(2);

// "101010"

この回答は、2147483648 ₁₀（2 ³¹）〜9007199254740991 ₁₀（2 ⁵³ -1）の範囲の絶対値を持つ入力に対処しようとします。

JavaScriptでは、数値は64ビットの浮動小数点表現で格納されますが、ビット単位の演算では2の補数形式の32ビット整数に強制変換されるため、ビット単位の演算を使用するアプローチでは、出力の範囲が-2147483648 ₁₀（-2 ³¹）に制限されます。– 2147483647 ₁₀（2 ³¹ -1）。

ただし、ビット単位の演算が回避され、64ビットの浮動小数点表現が数学的演算のみを使用して保持される場合、53ビットを符号拡張することにより、安全な整数を64ビットの2の補数のバイナリ表記に確実に変換できます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}

古いブラウザでは、次の関数と値にポリフィルが存在します。

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

追加のボーナスとして、次を使用して⌈64/ log ₂（基数）桁の負の数値に対して2の補数変換を実行する場合、任意の基数（2〜36）をサポートできます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}

を使用しArrayBufferてa Float64Arrayとaの和集合を作成した私の古い回答に興味がある場合Uint16Arrayは、この回答の変更履歴を参照してください。

32ビットの場合は問題ありませんが、この答えの最後にあるのは、developer.mozilla.org（MDN）からのコードですが、A）フォーマットおよびB）チェックのためにいくつかの行が追加されています。数値は範囲内です。

x.toString(2)ネガティブには機能しないという提案もありますが、マイナス記号が表示されているだけで、良くありません。

フェルナンド氏は、(x>>>0).toString(2);ネガティブには問題のない簡単な解決策について言及しましたが、xが正の場合にはわずかな問題があります。1で始まる出力があり、正の数の場合は2の補数として適切ではありません。

2の補数で0から始まる正の数と1で始まる負の数の事実を理解していない人は、2の補数でこのSO QnAをチェックできます。「2の補数」とは何ですか？

解決策は、正の数の前に0を付加することです。これは、この回答の以前のリビジョンで行いました。また、33ビットの数値を受け入れることもできますし、変換する数値が-（2 ^ 31）<= x <2 ^ 31-1の範囲内であることを確認することもできます。したがって、数値は常に32ビットです。しかし、そうするのではなく、mozilla.orgのこのソリューションを使用できます

Patrickの回答とコードは長く、64ビットで動作するようですが、コメンターが発見したバグがあり、コメンターはpatrickのバグを修正しましたが、patrickはコードに「マジックナンバー」があり、コメントしていません。忘れてパトリックは自分のコードを完全に理解しなくなりました/それがなぜ機能するのか

アナンは不正確で不明確な用語をいくつか持っていましたが、developer.mozilla.orgによる解決策について言及しましたhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators これは32ビットの数値で機能します。

コードはかなりコンパクトで、3行の関数です。

しかし、出力を8ビットのグループにフォーマットするための正規表現を追加しました。基づいて、JavaScriptで桁区切りとしてカンマで番号を印刷する方法 （私だけでそれをグループ化するからそれを改正3S右、左と追加にカンマでグループ化し、8S右から左へ、そして追加のスペースを）

そして、モジラはnMask（入力された数）のサイズについてコメントしましたが、範囲内である必要がありますが、数が範囲外の場合はテストもエラーもスローしなかったため、と付け加えた。

彼らがなぜそれらのパラメーターを 'nMask'と名付けたのかは分かりませんが、それはそのままにしておきます。

リファレンス：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"

ビットの配列を返す独自の関数を作成できます。数値をビットに変換する方法の例

除数| 配当| ビット/残り

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

〜| 1 |〜

上記の行の例：2 * 4 = 8、残りは1なので、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
}

残りを下から上に読みます。中央から上に1桁目。

私はこれを行う何かを思いつくために別のアプローチを使用しました。私のプロジェクトではこのコードを使用しないことにしましたが、誰かに役立つ場合に備えて、関連性のある場所に残しておくと思いました。

• ビットシフトや2の補数強制を使用しません。
• 出てくるビット数を選択します（「8」、「16」、「32」の有効な値をチェックしますが、変更できると思います）
• 符号付き整数として処理するか、符号なし整数として処理するかを選択します。
• 符号付き/符号なしとビット数の組み合わせを指定して範囲の問題をチェックしますが、エラー処理を改善する必要があります。
• また、ビットをintに変換する「リバース」バージョンの関数もあります。この出力を解釈するものはおそらく他にないので、それが必要になります：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("---");

もう一つの選択肢

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

これは私のコードです：

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

これが解決策です。実際には非常に単純です

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.
        */