Конвертация систем счисления: Hex, Binary, Octal и Decimal для разработчиков

5 февраля 2026•12 мин чтения

Вы отлаживаете дамп памяти и видите 0x7FFFFFFF. CSS-цвет записан как #FF5733. Права файла указаны как 0755. Сетевая маска выглядит как 11111111.11111111.11111111.00000000. Всё это числа в разных системах счисления — и понимание того, как конвертировать между ними, необходимо для разработчиков. Это руководство охватывает практическую конвертацию систем счисления с реальными примерами.

Четыре системы счисления, которые используют разработчики

Основание	Название	Цифры	Префикс	Применение
2	Двоичная	0, 1	`0b`	Побитовые операции, флаги, маски
8	Восьмеричная	0-7	`0o` или `0`	Права файлов Unix
10	Десятичная	0-9	(нет)	Человекочитаемые числа
16	Шестнадцатеричная	0-9, A-F	`0x` или `#`	Цвета, адреса памяти, байты

Краткий справочник: Распространённые значения

Десятич.  Двоичное    Восьм.  Шестн.
--------  --------    ------  ------
       0b0         0o0     0x0
       0b1         0o1     0x1
       0b111       0o7     0x7
       0b1000      0o10    0x8
      0b1010      0o12    0xA
      0b1111      0o17    0xF
      0b10000     0o20    0x10
     0b11111111  0o377   0xFF
     0b100000000 0o400   0x100
   (16 бит)    —       0xFFFF

Используйте Конвертер систем счисления для быстрой конвертации между любыми основаниями без ручных вычислений.

Шестнадцатеричная система: Цвета, байты и память

CSS коды цветов

Hex-коды цветов представляют RGB-значения, где каждая пара шестнадцатеричных цифр — это один цветовой канал (0-255):

#FF5733
 ││││││
 ││││└┴─ Blue (Синий):   0x33 = 51
 ││└┴─── Green (Зелёный): 0x57 = 87
 └┴───── Red (Красный):   0xFF = 255

# Разбор распространённых цветов:
#FFFFFF = rgb(255, 255, 255) = Белый
#000000 = rgb(0, 0, 0)       = Чёрный
#FF0000 = rgb(255, 0, 0)     = Красный
#00FF00 = rgb(0, 255, 0)     = Зелёный
#0000FF = rgb(0, 0, 255)     = Синий
#808080 = rgb(128, 128, 128) = Серый

Конвертация hex в десятичное для каждого канала:

# Значения hex-цифр: 0-9 = 0-9, A-F = 10-15
# Две hex-цифры = первая × 16 + вторая

FF = 15 × 16 + 15 = 240 + 15 = 255
57 = 5 × 16 + 7   = 80 + 7   = 87
33 = 3 × 16 + 3   = 48 + 3   = 51

# Итак #FF5733 = rgb(255, 87, 51)

Адреса памяти

Адреса памяти отображаются в шестнадцатеричной системе, потому что они чётко соответствуют двоичной (каждая hex-цифра = 4 бита):

# 32-битный адрес
0x7FFFFFFF = 0111 1111 1111 1111 1111 1111 1111 1111
           = 2 147 483 647 (макс. знаковое 32-бит int)

# 64-битный адрес
0x00007FFFFFFFFFFF = типичный лимит адресов пользовательского пространства

# Распространённые паттерны памяти при отладке:
0xDEADBEEF  # Часто используется как магическое число / неинициализированная память
0xCAFEBABE  # Магическое число Java class файлов
0xFEEDFACE  # Магическое число Mach-O бинарников (macOS)
0xBAADF00D  # Windows LocalAlloc неинициализированная куча
0xCDCDCDCD  # MSVC отладочная куча неинициализированная

Байтовые значения и данные

# Один байт = 8 бит = 2 hex-цифры
# Диапазон: 0x00 до 0xFF (0 до 255)

# ASCII в hex:
'A' = 0x41 = 65
'a' = 0x61 = 97
'0' = 0x30 = 48
' ' = 0x20 = 32

# Просмотр байтов файла (hexdump):
$ xxd file.txt | head -1
00000000: 4865 6c6c 6f20 576f 726c 640a            Hello World.
          ↑↑↑↑ ↑↑↑↑ ↑↑↑↑ ↑↑↑↑ ↑↑↑↑
          H e  l l  o     W o  r l  d \n

Двоичная система: Побитовые операции и флаги

Понимание позиций битов

# Позиции битов (справа налево, начиная с 0):
Позиция:  7   6   5   4   3   2   1   0
Значение: 128  64  32  16   8   4   2   1

# Пример: 0b11010110 = 214
128 + 64 + 0 + 16 + 0 + 4 + 2 + 0 = 214

# Быстрый устный счёт: степени двойки
2^0 = 1      2^4 = 16     2^8 = 256
2^1 = 2      2^5 = 32     2^9 = 512
2^2 = 4      2^6 = 64     2^10 = 1024 (1К)
2^3 = 8      2^7 = 128    2^20 = 1М, 2^30 = 1Г

Побитовые операции

# AND (&) - оба бита должны быть 1
  0b1100
& 0b1010
--------
  0b1000

# OR (|) - любой бит может быть 1
  0b1100
| 0b1010
--------
  0b1110

# XOR (^) - биты должны быть разными
  0b1100
^ 0b1010
--------
  0b0110

# NOT (~) - инвертирует все биты
~ 0b1100 = 0b0011 (упрощённо)

# Сдвиг влево (<<) - умножение на 2^n
0b0001 << 3 = 0b1000  # 1 × 8 = 8

# Сдвиг вправо (>>) - деление на 2^n
0b1000 >> 2 = 0b0010  # 8 ÷ 4 = 2

Битовые флаги на практике

# Определение флагов как степеней 2
FLAG_READ    = 0b0001  # 1
FLAG_WRITE   = 0b0010  # 2
FLAG_EXECUTE = 0b0100  # 4
FLAG_DELETE  = 0b1000  # 8

# Комбинирование флагов через OR
permissions = FLAG_READ | FLAG_WRITE  # 0b0011 = 3

# Проверка флага через AND
hasRead = (permissions & FLAG_READ) != 0   # True
hasExec = (permissions & FLAG_EXECUTE) != 0 # False

# Добавление флага через OR
permissions |= FLAG_EXECUTE  # 0b0111 = 7

# Удаление флага через AND + NOT
permissions &= ~FLAG_WRITE   # 0b0101 = 5

# Переключение флага через XOR
permissions ^= FLAG_READ     # Инвертирует бит чтения

Сетевые маски подсетей

# Маска подсети: последовательные 1, затем 0
/24 = 255.255.255.0
    = 11111111.11111111.11111111.00000000

/16 = 255.255.0.0
    = 11111111.11111111.00000000.00000000

/8  = 255.0.0.0
    = 11111111.00000000.00000000.00000000

# CIDR нотация = количество ведущих единиц
# /24 означает 24 бита для сети, 8 бит для хостов
# 2^8 - 2 = 254 используемых адресов хостов

Восьмеричная система: Права файлов Unix

Права файлов Unix используют восьмеричную систему, потому что каждая цифра соответствует ровно 3 битам (rwx):

# Каждая восьмеричная цифра = 3 бита прав
# r=read(4), w=write(2), x=execute(1)

Восьм.  Двоичн.  Значение
------  ------   --------
0       000      ---  (нет прав)
1       001      --x  (только выполнение)
2       010      -w-  (только запись)
3       011      -wx  (запись + выполнение)
4       100      r--  (только чтение)
5       101      r-x  (чтение + выполнение)
6       110      rw-  (чтение + запись)
7       111      rwx  (все права)

Распространённые паттерны прав

# Три цифры: владелец / группа / остальные
chmod 755 script.sh
       │││
       ││└─ остальные: r-x (5) = чтение + выполнение
       │└── группа:    r-x (5) = чтение + выполнение
       └─── владелец:  rwx (7) = все права

# Распространённые права:
644 = rw-r--r--  # Стандартный файл (владелец rw, остальные чтение)
755 = rwxr-xr-x  # Исполняемый/директория (владелец всё, остальные rx)
600 = rw-------  # Приватный файл (только владелец)
700 = rwx------  # Приватная директория/исполняемый
777 = rwxrwxrwx  # Полный доступ (обычно плохая практика!)
400 = r--------  # Только чтение владельцем (SSH-ключи)

Конвертация символьной в числовую форму

# Конвертация символьной в восьмеричную
ls -l file.txt
-rw-r--r-- 1 user group 1234 Jan 1 12:00 file.txt
 │││││││││
 │││││││└┴── остальные: r-- = 4
 ││││││└──── группа:    r-- = 4
 │││└┴┴───── владелец:  rw- = 6
 └┴┴──────── тип:       -   = обычный файл

Результат: 644

# Распространённые индикаторы типа:
-  = обычный файл
d  = директория
l  = символическая ссылка
c  = символьное устройство
b  = блочное устройство

Техники конвертации

Десятичное в двоичное (метод деления)

# Конвертация 42 в двоичное
÷ 2 = 21 остаток 0  ↑
÷ 2 = 10 остаток 1  │
÷ 2 = 5  остаток 0  │ Читаем
÷ 2 = 2  остаток 1  │ снизу
÷ 2 = 1  остаток 0  │ вверх
÷ 2 = 0  остаток 1  │

= 0b101010

Двоичное в шестнадцатеричное (метод группировки)

# Группируем двоичные цифры по 4 (справа)
0b 1010 1100 1111 0001
   │    │    │    │
   A    C    F    1

Результат: 0xACF1

# Обратно: разворачиваем каждую hex-цифру в 4 бита
0xDEAD = 0b 1101 1110 1010 1101
            D    E    A    D

Восьмеричное в двоичное (метод группировки)

# Группируем двоичные цифры по 3 (справа)
0b 111 101 101
   │   │   │
   7   5   5

Результат: 0o755

# Обратно: разворачиваем каждую восьм. цифру в 3 бита
0o644 = 0b 110 100 100
           6   4   4

Конвертация в языках программирования

# JavaScript
parseInt('FF', 16)    // 255 (hex в десятичное)
parseInt('11111111', 2)  // 255 (двоичное в десятичное)
(255).toString(16)    // 'ff' (десятичное в hex)
(255).toString(2)     // '11111111' (десятичное в двоичное)

# Python
int('FF', 16)         # 255
int('11111111', 2)    # 255
hex(255)              # '0xff'
bin(255)              # '0b11111111'
oct(255)              # '0o377'

# Литералы в коде
const dec = 255;
const hex = 0xFF;     // То же что 255
const bin = 0b11111111; // То же что 255
const oct = 0o377;    // То же что 255

Реальные сценарии отладки

Чтение кодов ошибок

# Windows HRESULT: 0x80070005
# Разбор:
# 0x8... = ошибка (старший бит установлен)
# 0x.007... = код подсистемы 7 (Win32)
# 0x....0005 = код ошибки 5 (ACCESS_DENIED)

# HTTP статусы в hex логах:
0x191 = 401 (Unauthorized)
0x194 = 404 (Not Found)
0x1F4 = 500 (Internal Server Error)

Анализ UUID/GUID

# UUID: 550e8400-e29b-41d4-a716-446655440000
#       xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
#                     │    │
#                     │    └─ Вариант (8-b = RFC 4122)
#                     └────── Версия (4 = случайный)

# UUID версии 4: M = 4
# Биты варианта: N начинается с 10 (двоичное)
# N = a = 1010 (начинается с 10) ✓

Манипуляции с IPv4 адресами

# IP-адрес как 32-битное целое
192.168.1.100 =
  192 × 256³ + 168 × 256² + 1 × 256 + 100
= 3232235876
= 0xC0A80164

# Обратно: извлечение октетов
0xC0A80164
C0 = 192 (первый октет)
A8 = 168 (второй октет)
01 = 1   (третий октет)
64 = 100 (четвёртый октет)

Извлечение битовых полей

# Извлечение битов из упакованного значения
# Пример: RGB565 (16-битный цвет)
# RRRRRGGGGGGBBBBB

color = 0b1111100000011111  // Пурпурно-подобный
//        RRRRRGGGGGGBBBBB

red   = (color >> 11) & 0b11111    // 5 бит
green = (color >> 5)  & 0b111111   // 6 бит
blue  = color & 0b11111            // 5 бит

// Масштабирование до 8-бит (0-255)
red8   = (red * 255) / 31
green8 = (green * 255) / 63
blue8  = (blue * 255) / 31

Распространённые ошибки

1. Путаница с восьмеричной системой в JavaScript

// Устаревшая восьмеричная (избегайте!)
const bad = 010;   // 8, не 10! Ведущий ноль = восьмеричная

// Современная восьмеричная (явная)
const good = 0o10; // Явно 8 в восьмеричной

// Ловушка JSON: ведущие нули недопустимы
{ "value": 010 }   // Синтаксическая ошибка в JSON!

2. Знаковая vs беззнаковая интерпретация

// 0xFF как знаковое 8-бит = -1
// 0xFF как беззнаковое 8-бит = 255

// Побитовые операции JavaScript возвращают знаковое 32-бит
0xFFFFFFFF | 0     // -1 (не 4294967295!)

// Используйте >>> 0 для беззнакового
(0xFFFFFFFF >>> 0) // 4294967295

3. Регистрозависимость hex

// Hex-цифры A-F регистронезависимы по значению
0xFF === 0xff  // true

// Но строки могут отличаться
'FF' !== 'ff'  // Разные строки!

// Нормализуйте при сравнении
str.toUpperCase() === 'FF'

Практические инструменты

Для быстрой конвертации без устного счёта:

Конвертер систем счисления — мгновенная конвертация между двоичной, восьмеричной, десятичной и шестнадцатеричной системами прямо в браузере

Альтернативы командной строки:

# Bash/zsh встроенные
echo $((16#FF))      # Hex в десятичное: 255
echo $((2#11111111)) # Двоичное в десятичное: 255
printf '%x\n' 255    # Десятичное в hex: ff
printf '%o\n' 255    # Десятичное в восьмеричное: 377

# Python однострочники
python3 -c "print(hex(255))"   # 0xff
python3 -c "print(int('FF',16))" # 255

# Калькулятор bc
echo "obase=16; 255" | bc      # FF
echo "ibase=16; FF" | bc       # 255

Итоги

Шестнадцатеричная (основание 16): Используется для цветов (#FF5733), адресов памяти (0x7FFFFFFF) и байтовых значений. Каждая цифра = 4 бита.
Двоичная (основание 2): Используется для побитовых операций, флагов и масок подсетей. Необходима для понимания низкоуровневой работы с данными.
Восьмеричная (основание 8): Преимущественно используется для прав файлов Unix (chmod 755). Каждая цифра = 3 бита.
Десятичная (основание 10): Человекочитаемая, используется для общих вычислений и отображения.

Ключевой инсайт: hex и восьмеричная существуют потому, что они чётко соответствуют двоичной — hex группирует 4 бита, восьмеричная группирует 3 бита. Используйте Конвертер систем счисления для быстрой конвертации при отладке или работе с разными представлениями чисел.

DevToys Pro

бесплатные веб-инструменты для разработчиков