Jak dużą liczbę obsługuje?

Dowolnie duże. Narzędzie używa JavaScript BigInt, więc nie ma limitu 32 ani 64 bitów ani zaokrągleń.

Dlaczego liczby szesnastkowe zaczynają się od 0x?

To konwencja z języka C, używana dziś przez większość języków, która pokazuje, że cyfry są szesnastkowe. Podobnie 0b oznacza liczbę binarną, a 0o ósemkową.

Gdzie wciąż używa się systemu ósemkowego?

Głównie przy uniksowych uprawnieniach plików, gdzie 755 oznacza rwxr-xr-x. Każda cyfra ósemkowa odpowiada dokładnie trzem bitom uprawnień.

Jak zamienić hex na tekst ASCII?

To narzędzie konwertuje liczby, nie ciągi znaków. W tekście zapisanym w hex każda para cyfr to jeden bajt, który sprawdzasz w tablicy ASCII: 48 65 6C 6C 6F to „Hello”. W wierszu poleceń echo 48656c6c6f | xxd -r -p zamienia ciąg hex z powrotem na tekst.

Czy można konwertować ułamki lub liczby z częścią dziesiętną?

Nie, tylko liczby całkowite. Ułamki i tak są w systemie binarnym kłopotliwe: dziesiętne 0.1 nie ma dokładnej postaci binarnej i powtarza się w nieskończoność, dlatego w większości języków programowania 0.1 + 0.2 nie daje dokładnie 0.3. Wartości zmiennoprzecinkowe są przechowywane w formacie IEEE 754, a nie jako zwykłe binarne liczby całkowite.

Jaka jest największa liczba mieszcząca się w 8, 16, 32 lub 64 bitach?

Bez znaku jest to 2ⁿ − 1: 255, 65 535, 4 294 967 295 i 18 446 744 073 709 551 615. Wartości ze znakiem sięgają mniej więcej połowy tego, np. 2 147 483 647 dla 32 bitów. Liczby w JavaScripcie są dokładne tylko do 9 007 199 254 740 991, dlatego to narzędzie używa BigInt, by zachować precyzję powyżej tej granicy.

Konwerter systemów liczbowych

Konwertuj między systemem binarnym, ósemkowym, dziesiętnym i szesnastkowym.

O tym narzędziu

Wpisz liczbę w systemie binarnym, ósemkowym, dziesiętnym lub szesnastkowym i zobacz ją we wszystkich pozostałych, razem z bitami pogrupowanymi w bajty. Obsługuje dowolnie duże liczby całkowite i rozpoznaje prefiksy 0x, 0b i 0o.

Jak z tego korzystać

Wpisz liczbę w dowolnym z czterech pól: binarnym, ósemkowym, dziesiętnym lub szesnastkowym.
Pozostałe pola aktualizują się natychmiast. Akceptowane są prefiksy takie jak 0x, 0b i 0o.
Zajrzyj do panelu bitów, aby zobaczyć wartość podzieloną na bajty.

Pytania

Jak dużą liczbę obsługuje?: Dowolnie duże. Narzędzie używa JavaScript BigInt, więc nie ma limitu 32 ani 64 bitów ani zaokrągleń.
Dlaczego liczby szesnastkowe zaczynają się od 0x?: To konwencja z języka C, używana dziś przez większość języków, która pokazuje, że cyfry są szesnastkowe. Podobnie 0b oznacza liczbę binarną, a 0o ósemkową.
Gdzie wciąż używa się systemu ósemkowego?: Głównie przy uniksowych uprawnieniach plików, gdzie 755 oznacza rwxr-xr-x. Każda cyfra ósemkowa odpowiada dokładnie trzem bitom uprawnień.
Jak zamienić hex na tekst ASCII?: To narzędzie konwertuje liczby, nie ciągi znaków. W tekście zapisanym w hex każda para cyfr to jeden bajt, który sprawdzasz w tablicy ASCII: 48 65 6C 6C 6F to „Hello”. W wierszu poleceń echo 48656c6c6f | xxd -r -p zamienia ciąg hex z powrotem na tekst.
Czy można konwertować ułamki lub liczby z częścią dziesiętną?: Nie, tylko liczby całkowite. Ułamki i tak są w systemie binarnym kłopotliwe: dziesiętne 0.1 nie ma dokładnej postaci binarnej i powtarza się w nieskończoność, dlatego w większości języków programowania 0.1 + 0.2 nie daje dokładnie 0.3. Wartości zmiennoprzecinkowe są przechowywane w formacie IEEE 754, a nie jako zwykłe binarne liczby całkowite.
Jaka jest największa liczba mieszcząca się w 8, 16, 32 lub 64 bitach?: Bez znaku jest to 2ⁿ − 1: 255, 65 535, 4 294 967 295 i 18 446 744 073 709 551 615. Wartości ze znakiem sięgają mniej więcej połowy tego, np. 2 147 483 647 dla 32 bitów. Liczby w JavaScripcie są dokładne tylko do 9 007 199 254 740 991, dlatego to narzędzie używa BigInt, by zachować precyzję powyżej tej granicy.

Jak zamienić liczbę binarną na dziesiętną i z powrotem?

Każda cyfra liczby binarnej jest warta potęgę dwójki, zaczynając od 1 po prawej. Aby zamienić 1011 na liczbę dziesiętną, dodaj pozycje, na których stoi 1: 8 + 0 + 2 + 1 = 11. System szesnastkowy działa tak samo z potęgami 16, więc 0x2F to 2 × 16 + 15 = 47. System ósemkowy używa potęg ósemki. Jedna reguła obejmuje każdą podstawę: każda cyfra razy podstawa podniesiona do potęgi równej jej pozycji.

Aby przejść w drugą stronę, dziel wielokrotnie przez docelową podstawę i zapisuj reszty od ostatniej do pierwszej. Dzielenie 11 przez 2 raz za razem daje reszty 1, 1, 0 i 1, które czytane od końca dają 1011. W tym konwerterze systemów liczbowych wystarczy pisać w dowolnym polu, a pozostałe trzy się zaktualizują. W kodzie JavaScript ma parseInt(text, 2) i n.toString(16), a Python int(text, 2) i hex(n).

Dlaczego programiści używają systemu szesnastkowego?

Jedna cyfra szesnastkowa odpowiada dokładnie czterem bitom, więc dwie cyfry hex opisują jeden bajt. Dzięki temu hex to zwięzły i czytelny sposób zapisu danych binarnych: 11111111 to FF, a każda 32-bitowa wartość mieści się w ośmiu znakach. Spotkasz go w adresach pamięci, kodach kolorów, takich jak #FF8800, hashach, adresach MAC, punktach kodowych Unicode, np. U+1F680, i zrzutach bajtów wypisywanych przez narzędzia takie jak xxd i hexdump.

Panel bitów pokazuje ten związek bezpośrednio. Wartość jest uzupełniana do pełnych bajtów, a każda grupa ośmiu bitów jest pokazana z dwucyfrową wartością hex pod spodem. 48879 staje się 10111110 11101111, z etykietami BE i EF, dlatego czyta się ją jako 0xBEEF. Ułatwia to sprawdzanie flag, masek bitowych i granic bajtów. Kalkulator podsieci (CIDR) stosuje ten sam widok binarny do adresów IPv4 i masek sieci.

Jak zapisać liczbę ujemną binarnie: kod uzupełnień do dwóch

Komputery zwykle przechowują liczby całkowite ze znakiem w kodzie uzupełnień do dwóch. Aby zapisać −1 na 8 bitach, odwróć każdy bit liczby 1 i dodaj jeden: 00000001 staje się 11111110, a po dodaniu jedynki daje 11111111, czyli 0xFF. Najwyższy bit pełni rolę znaku, więc 8-bitowa wartość ze znakiem ma zakres od −128 do 127, a te same bity odczytane bez znaku dają od 0 do 255. Wzorzec bitów jest identyczny; zmienia się tylko interpretacja.

Ten konwerter działa na zwykłych liczbach całkowitych, a nie na rejestrach o stałej szerokości. Wpisz -5, a dostaniesz -101 binarnie i -5 w hex, ze znakiem minus z przodu zamiast wzorca w kodzie uzupełnień do dwóch. Aby dostać 8-bitowy wzorzec liczby ujemnej, najpierw dodaj 256: −5 + 256 = 251, czyli 0xFB. Dla 32 bitów dodaj 4294967296. Spacje i podkreślenia są ignorowane, więc 1111_1011 też zadziała jako dane wejściowe.

Tabela liczb dziesiętnych, szesnastkowych, binarnych i ósemkowych

Liczby, które sprawdzasz najczęściej, we wszystkich czterech systemach liczbowych.

Dziesiętnie	Szesnastkowo	Binarnie	Ósemkowo
`0`	`0x0`	`0000`	`0o0`
`1`	`0x1`	`0001`	`0o1`
`2`	`0x2`	`0010`	`0o2`
`3`	`0x3`	`0011`	`0o3`
`4`	`0x4`	`0100`	`0o4`
`5`	`0x5`	`0101`	`0o5`
`6`	`0x6`	`0110`	`0o6`
`7`	`0x7`	`0111`	`0o7`
`8`	`0x8`	`1000`	`0o10`
`9`	`0x9`	`1001`	`0o11`
`10`	`0xA`	`1010`	`0o12`
`11`	`0xB`	`1011`	`0o13`
`12`	`0xC`	`1100`	`0o14`
`13`	`0xD`	`1101`	`0o15`
`14`	`0xE`	`1110`	`0o16`
`15`	`0xF`	`1111`	`0o17`
`16`	`0x10`	`0001 0000`	`0o20`
`32`	`0x20`	`0010 0000`	`0o40`
`64`	`0x40`	`0100 0000`	`0o100`
`100`	`0x64`	`0110 0100`	`0o144`
`127`	`0x7F`	`0111 1111`	`0o177`
`128`	`0x80`	`1000 0000`	`0o200`
`255`	`0xFF`	`1111 1111`	`0o377`
`256`	`0x100`	`0001 0000 0000`	`0o400`
`512`	`0x200`	`0010 0000 0000`	`0o1000`
`1000`	`0x3E8`	`0011 1110 1000`	`0o1750`
`1024`	`0x400`	`0100 0000 0000`	`0o2000`
`4096`	`0x1000`	`0001 0000 0000 0000`	`0o10000`
`65535`	`0xFFFF`	`1111 1111 1111 1111`	`0o177777`

Coś nie działa albo wynik wygląda na błędny? Zgłoś problem z tym narzędziem