Jak przekonwertować liczbę całkowitą na binarną w JavaScript?

299

Chciałbym zobaczyć liczby całkowite, dodatnie lub ujemne, w postaci binarnej.

Raczej jak to pytanie , ale dla JavaScript.

barlop
źródło
2
przykłady a.toString (2) nie wydają się działać dla -1
barlop
1
Możliwa jest również konwersja z binarnej na dziesiętną: stackoverflow.com/questions/11103487/…
Anderson Green
A kiedy powiedziałem „binarnie”, może to być trochę niejednoznaczne. Mam na myśli wewnętrzną reprezentację ciągu bitów, która jest uzupełnieniem 2s, więc liczby dodatnie będą w bazie 2 i na początku 0, (a liczby ujemne nie zostaną zapisane za pomocą symbolu minus lub reprezentacji wielkości znaku, ale jako funkcja ich ekwiwalentu pozytywnego)
barlop

Odpowiedzi:

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

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

Możesz użyć Number.toString(2)funkcji, ale ma ona pewne problemy przy reprezentowaniu liczb ujemnych. Na przykład (-1).toString(2)dane wyjściowe to "-1".

Aby rozwiązać ten problem, możesz użyć niepodpisanego operatora bitowego przesunięcia w prawo (>>> ), aby zmusić swój numer do liczby całkowitej bez znaku.

Jeśli uruchomisz (-1 >>> 0).toString(2), przeniesiesz bity cyfry 0 w prawo, co nie zmienia samej liczby, ale będzie reprezentowane jako liczba całkowita bez znaku. Powyższy kod wyświetli się "11111111111111111111111111111111"poprawnie.

To pytanie zawiera dalsze wyjaśnienia.

-3 >>> 0 (prawe przesunięcie logiczne) wymusza argumenty na liczbach całkowitych bez znaku, dlatego otrzymujemy 32-bitową reprezentację uzupełnienia dwóch -3.

fernandosavio
źródło
7
Oto wyjaśnienie
fernandosavio
minęło trochę czasu, odkąd próbowałem javascript, ale próbuję go tutaj w3schools.com/js/tryit.asp?filename=tryjs_output_alert z tym <script> window.alert ((- 3 >>> 0) .toString (2)); </script> tak, zadziałało
barlop
1
toString (2) nie działa, ponieważ pobierasz dane z tekstu. Użyj tego: function decToBase (dec, base) {return parseInt (dec) .toString (base); } alert (decToBase (dec, 2));
Mag
Zakładasz, że dane wejściowe to tekst, ale funkcja w odpowiedzi oczekuje na liczbę całkowitą ... Więc jeśli dane wejściowe to tekst, po prostu przekonwertuj go na liczbę całkowitą, użyj fałszywej zmiany bitów i gotowe
fernandosavio
@Magus, kto pobiera dane z tekstu ?!
barlop
207

Próbować

num.toString(2);

2 to podstawa i może być dowolną bazą między 2 a 36

źródło tutaj

AKTUALIZACJA:

Działa to tylko w przypadku liczb dodatnich, JavaScript reprezentuje ujemne binarne liczby całkowite w notacji dwóch uzupełnień. Zrobiłem tę małą funkcję, która powinna załatwić sprawę, nie przetestowałem jej poprawnie:

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

Miałem stąd pomoc

Manatok
źródło
nie działa dla -1. a = -1; document.write (Number (a.toString (2))); wyświetla -1
barlop
Aktualizacja nadal nie działa w przypadku liczb ujemnych ( -3zwrotów 1). Też uważam, że dec > 0powinien być dec >= 0, który powinien przynajmniej naprawić 0. Ponieważ dec2Bin(0)zwraca 10.
Adam Merrifield
Oba przypadki w powyższych komentarzach zwracają poprawny wynik w mojej konsoli Chrome - var a = -1; a.toString (2); „-1” var a = -3; a.toString (2); „-11”
Anmol Saraf,
@AnmolSaraf Rozumiem, co masz na myśli, i chociaż potocznie, gdy ludzie mówią, co jest -5 w systemie dziesiętnym, a odpowiedź brzmi -5 Jeśli chodzi o liczby ujemne w formacie binarnym, w pewnym sensie tak, możesz umieścić tam znak minus, więc 5 to 101 i -5 to -101, ale ponieważ komputery nie przechowują znaków minus, reprezentują one po prostu 1 i 0, więc kiedy mówimy liczby ujemne w formacie binarnym, naprawdę mamy na myśli umieszczenie liczby ujemnej (włączając znak minus) w 1 i 0. Niektóre sposoby obejmują uzupełnienie 1, uzupełnienie 2 oraz „znak i wielkość”. Zatem -101010101 lub -0101010 nie jest tym, co ludzie rozumieją przez liczbę ujemną w postaci binarnej.
barlop
Ten link może zainteresować niektóre stackoverflow.com/questions/12337360/... w każdym razie Twoja odpowiedź zaprzecza samemu, piszesz: „JavaScript reprezentuje binarne liczby całkowite ujemne w notacji z dopełnieniem dwóch”. A twój kod mówi: „Tutaj możesz reprezentować liczbę w komplementie 2s, ale to nie jest to, co JS as używa jako [nonsensowny powód]” I nie podajesz też odniesienia.
barlop
53

Plik binarny w „Convert to binary” może odnosić się do trzech głównych rzeczy. System liczb pozycyjnych, reprezentacja binarna w pamięci lub 32-bitowe ciągi bitów. (w przypadku 64-bitowych ciągów bitów patrz odpowiedź Patricka Robertsa )

1. System liczbowy

(123456).toString(2)przekształci liczby w podstawowy system liczb pozycyjnych 2 . W tym systemie liczby ujemne są zapisywane ze znakami minusowymi, tak jak w systemie dziesiętnym.

2. Przedstawicielstwo wewnętrzne

Wewnętrzna reprezentacja liczb jest zmiennoprzecinkowa 64-bitowa i niektóre ograniczenia są omówione w tej odpowiedzi . Nie ma łatwego sposobu na utworzenie tego ciągu bitowego w javascript ani dostęp do określonych bitów.

3. Maski i operatory bitowe

MDN ma dobry przegląd działania operatorów bitowych. Co ważne:

Operatory bitowe traktują swoje operandy jako ciąg 32 bitów (zer i jedynek)

Przed zastosowaniem operacji 64-bitowe liczby zmiennoprzecinkowe są rzutowane na 32-bitowe liczby całkowite ze znakiem. Po ich ponownej konwersji.

Oto przykładowy kod MDN do konwersji liczb na ciągi 32-bitowe.

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"
AnnanFay
źródło
Jaka jest zaleta korzystania z tej funkcji zamiast zwykłego Number (num) .toString (2)?
Mag
5
@Magus Myślę, że odpowiednio wyjaśniam różnice między cyframi a ciągami binarnymi. 32-bitowy ciąg binarny ma zawsze trzydzieści dwa znaki złożone z „1” i „0”. toString zwraca rzeczywistą liczbę reprezentowaną za pomocą systemów liczb pozycyjnych z podaną bazą. To zależy, dlaczego chcesz ciąg, mają one bardzo różne znaczenia.
AnnanFay,
przepraszam masz rację Skoczyłem prosto do kodu.
Mag
1
Wystąpił problem z wiodącymi zerami przy użyciu innych opublikowanych metod (szczególnie pod tym numerem 536870912, dwa wiodące zera zostały usunięte), ale to rozwiązanie poradziło sobie z tym poprawnie.
UberMouse,
@UberMouse tak >>> ma wiodący problem 0, zaakceptuję ten.
barlop
43

Prostym sposobem jest po prostu ...

Number(42).toString(2);

// "101010"
ad rees
źródło
24
Wolałbym(42).toString(2)
Willem D'Haeseleer
33
Lub nawet krócej42..toString(2)
kapex
9
Ludzie borykają się z tym. Odpowiedź jest poprawna, ponieważ rzutuje wejście (42) na liczbę całkowitą i ta linia jest potrzebna. Jeśli otrzymasz „liczbę” z wprowadzania tekstu, toString (2) nie działałoby.
Mag
4
@Kapep, koleś geniusz. Skąd o tym wiesz?
Pacerier
2
@BatuG. Składnia liczb pozwala pominąć część po separatorze dziesiętnym. Możesz pisać 1.tak samo jak 1.0lub tylko 1(i podobnie możesz także pominąć część przed i pisać .5zamiast 0.5). Tak więc w tym przykładzie pierwsza kropka jest separatorem dziesiętnym, który jest częścią liczby, a druga kropka jest operatorem kropki służącym do wywołania metody na tym numerze. Musisz użyć dwóch kropek (lub owinąć liczbę w nawiasach) i nie możesz po prostu pisać, 42.toString(2)ponieważ parser widzi kropkę jako separator dziesiętny i zgłasza błąd z powodu braku operatora kropki.
kapex
30

Ta odpowiedź próbuje adresować dane wejściowe o wartości bezwzględnej w zakresie 2147483648 10 (2 31 ) - 9007199254740991 10 (2 53 -1).


W JavaScript liczby są przechowywane w 64-bitowej reprezentacji zmiennoprzecinkowej , ale operacje bitowe zmuszają je do 32-bitowych liczb całkowitych w formacie uzupełnienia do dwóch , więc każde podejście wykorzystujące operacje bitowe ogranicza zakres wyniku do -2147483648 10 (-2 31 ) - 2147483647 10 (2 31 -1).

Jeśli jednak uniknie się operacji bitowych, a 64-bitowa reprezentacja zmiennoprzecinkowa zostanie zachowana przy użyciu tylko operacji matematycznych, możemy niezawodnie przekonwertować dowolną bezpieczną liczbę całkowitą na 64-bitową dopełniającą notację binarną z dopełnieniem 53-bitowego znaku 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}

W starszych przeglądarkach istnieją wielopełniacze następujących funkcji i wartości:

Jako dodatkowy bonus możesz wesprzeć dowolny podstawnik (2–36), jeśli wykonasz konwersję uzupełnienia dwóch liczb ujemnych w liczbach ⌈64 / log 2 (podstawa) ⌉ przy użyciu 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}

Jeśli jesteś zainteresowany moją starą odpowiedzią, która posłużyła ArrayBufferdo utworzenia związku między a, Float64Arraya Uint16Arrayzapoznaj się z historią wersji tej odpowiedzi .

Patrick Roberts
źródło
Dzięki, dobrze, że to działa na 64-bit. Czy możesz mi powiedzieć, jakie są zalety tej odpowiedzi w porównaniu z odpowiedzią Annana?
barlop
2
Znacznie większy zasięg? Działa on na -(2**53)-1celu 2**53-1, a nie tylko -(2**31)do 2**31-1jak odpowiedź Annana.
Patrick Roberts,
Tak, to duża zaleta, rozumiem, i tak się stanie, chociaż jest to nieco więcej kodu, ale miałem na myśli, że jestem ciekawy, czy są jakieś inne zalety?
barlop
1
od 2 ** 32 + 1 wł. ostatni (prawy) bit jest kasowany, kiedy należy go ustawić.
Lovro,
1
Działa, gdy wiersz jest następujący: var wykładnik = ((uint16 [3] i 0x7FF0) >> 4) - 1023 + 1;
Lovro,
15

Rozwiązaniem, które wybrałbym w porządku dla 32-bitów, jest kod na końcu tej odpowiedzi, który pochodzi z developer.mozilla.org (MDN), ale z pewnymi wierszami dodanymi do A) formatowania i B) sprawdzania, czy liczba jest w zakresie.

Niektórzy sugerowali x.toString(2) że nie działa na negatywy, po prostu umieszcza tam znak minus, co nie jest dobre.

Fernando wspomniał o prostym rozwiązaniu (x>>>0).toString(2); które jest odpowiednie dla negatywów, ale ma niewielki problem, gdy x jest dodatnie. Ma wyjście zaczynające się od 1, co dla liczb dodatnich nie jest właściwym uzupełnieniem 2s.

Każdy, kto nie rozumie faktu, że liczby dodatnie zaczynają się od 0 i liczby ujemne z 1, w uzupełnieniu 2s, może sprawdzić tę SO QnA w uzupełnieniu 2s. Co to jest „Uzupełnienie 2”?

Rozwiązaniem mogłoby być wcześniejsze wpisanie 0 dla liczb dodatnich, co zrobiłem we wcześniejszej wersji tej odpowiedzi. Czasami można zaakceptować liczbę 33-bitową lub upewnić się, że liczba do konwersji mieści się w zakresie - (2 ^ 31) <= x <2 ^ 31-1. Tak więc liczba wynosi zawsze 32 bity. Ale zamiast tego możesz skorzystać z tego rozwiązania na mozilla.org

Odpowiedź i kod Patryka jest długi i najwyraźniej działa na 64-bit, ale miał błąd znaleziony przez komentatora, a komentator naprawił błąd patryka, ale patrick ma w swoim kodzie „magiczną liczbę”, o której nie skomentował i zapomniany i Patrick nie rozumie już w pełni własnego kodu / dlaczego on działa.

Annan miał niepoprawną i niejasną terminologię, ale wspomniał o rozwiązaniu autorstwa developer.mozilla.org https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators Działa to dla liczb 32-bitowych.

Kod jest dość kompaktowy, funkcja trzech wierszy.

Ale dodałem wyrażenie regularne, aby sformatować dane wyjściowe w grupach po 8 bitów. Oparty na tym, jak wydrukować liczbę z przecinkami jako tysiące separatorów w JavaScript (właśnie zmieniłem ją od zgrupowania jej w 3s od prawej do lewej i dodawania przecinków , do grupowania w 8s od prawej do lewej i dodania spacji )

I chociaż Mozilla skomentowała rozmiar nMaski (liczby wprowadzonej) .. że musi on znajdować się w zakresie, nie testowali ani nie zgłaszali błędu, gdy liczba jest poza zakresem, więc mam dodał to.

Nie jestem pewien, dlaczego nazwali swój parametr „nMask”, ale pozostawię to bez zmian.

Odniesienie: 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"

barlop
źródło
8

Możesz napisać własną funkcję, która zwraca tablicę bitów. Przykład jak przekonwertować liczbę na bity

Dzielnik | Dywidenda | bity / reszta

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

~ | 1 | ~

przykład powyższej linii: 2 * 4 = 8, a reszta to 1, więc 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
}

Czytaj resztki od dołu do góry. Cyfra 1 od środka do góry.

supritshah1289
źródło
1
Btw, dlaczego Math.floor(number%2)zamiast tego number = Math.floor(number/2)?
Pacerier
1
Powodem jest to, że liczba% 2 nie jest równa liczbie / 2. Interesuje nas reszta, a nie iloraz.
supritshah1289
0

Użyłem innego podejścia, aby wymyślić coś, co to robi. Zdecydowałem się nie używać tego kodu w moim projekcie, ale pomyślałem, że zostawię go gdzieś istotnym na wypadek, gdyby był przydatny dla kogoś.

  • Nie używa przesunięcia bitów ani przymusu uzupełniania dwóch.
  • Ty wybierasz liczbę bitów, które wychodzą (sprawdza poprawne wartości „8”, „16”, „32”, ale przypuszczam, że możesz to zmienić)
  • Ty decydujesz, czy traktować go jako liczbę całkowitą ze znakiem, czy bez znaku.
  • Sprawdza, czy nie występują problemy z zasięgiem, biorąc pod uwagę kombinację podpisu / niepodpisania i liczby bitów, ale warto poprawić obsługę błędów.
  • Ma także „odwrotną” wersję funkcji, która konwertuje bity z powrotem na int. Będziesz tego potrzebować, ponieważ prawdopodobnie nie ma nic innego, co interpretowałoby ten wynik: 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("---");

braki
źródło
-1

Jeszcze jedna alternatywa

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));
Ivan Proskuryakov
źródło
Proszę zobaczyć odpowiedź Vincenta i komentarz do niej, dotyczyłby również twojego postu
barlop
Oto, co zostało zamieszczone w komentarzu do jego odpowiedzi, bez różnicy zdań i za pewną zgodą innych: „To może być przydatne do studiowania informatyki, aby zobaczyć, jak to zrobić ręcznie, aby nauczyć się siebie, ale to nie to, co ja pytam! Jeśli zamierzasz wymyślić koło ręcznie, robiąc to w ten sposób, powinno to być przynajmniej zaletą zwiększonej wydajności lub jakąś zaletą, taką jak wzrost wielkości wartości, z którymi może sobie poradzić. Nie widzę jakakolwiek dyskusja, w której można znaleźć taką przewagę ”.
barlop
Co więcej, twoje rozwiązanie całkowicie zawodzi, powoduje, że liczby dodatnie zaczynają się od 1 i całkowicie zawodzi w przypadku liczb ujemnych, a moje pytanie dotyczyło dodatnich lub ujemnych
barlop
Twoja odpowiedź jest błędna na wielu poziomach. I zawsze powinieneś przejrzeć inne odpowiedzi przed opublikowaniem odpowiedzi
barlop
-2

To jest mój kod:

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();
Vincent William Rodriguez
źródło
3
Może to być przydatne do studiowania informatyki, aby zobaczyć, jak to zrobić ręcznie, aby nauczyć się siebie, ale nie o to pytam! Jeśli zamierzasz na nowo wymyślić koło, robiąc to w ten sposób ręcznie, powinno to być przynajmniej zaletą zwiększonej wydajności lub jakąś korzyścią, taką jak wzrost wielkości wartości, z którymi może sobie poradzić. Nie widzę w tobie żadnej dyskusji o takiej przewadze.
barlop
-3

To jest rozwiązanie. Jest to dość proste

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.
        */
Brian
źródło
1
To rozwiązanie było już wielokrotnie proponowane i, jak skomentował OP już 30 marca o 9:01, nie działa dla liczb ujemnych.
Adrian W
@AdrianW Sugeruję, aby oddać głos w dół. Zauważyłem, że nie. Co więc trzeba, by głosować na odpowiedź ?!
barlop