Сколько выделяется памяти для переменной типа number?

Сколько выделяется памяти для переменной типа number?

Краткий ответ

В JavaScript переменные типа number занимают 8 байт (64 бита). Это стандарт во всех JavaScript движках, потому что JavaScript использует IEEE 754 double-precision floating-point format для всех чисел.

IEEE 754 Double-Precision Format

Все числа в JavaScript хранятся в одном формате — 64-битное число с плавающей точкой:

64 бита = 8 байт

[1 бит знака] [11 битов экспоненты] [52 бита мантиссы]

Визуально:

Число:  42
В памяти: 01000100 01010000 00000000 00000000 00000000 00000000 00000000 00000000
         (8 байт = 64 бита)

Все числа в JavaScript одного типа

const integer = 42;        // 8 байт
const float = 3.14;        // 8 байт
const negative = -100;     // 8 байт
const scientific = 1.5e10; // 8 байт
const infinity = Infinity; // 8 байт
const nan = NaN;           // 8 байт

// Все они занимают ОДИНАКОВОЕ количество памяти!

Почему всегда 8 байт?

Исторический выбор: Когда JavaScript был создан в 1995 году, разработчики выбрали использовать double-precision floats для ВСЕ чисел. Это было сделано для:

• Простоты — один тип для всех чисел
• Совместимости — IEEE 754 поддерживается всеми процессорами
• Диапазона — можно представить очень большие и очень маленькие числа

Какой диапазон можно представить?

// Целые числа (безопасные)
Number.MAX_SAFE_INTEGER = 9007199254740991  // 2^53 - 1
Number.MIN_SAFE_INTEGER = -9007199254740991 // -(2^53 - 1)

// Вообще всё
Number.MAX_VALUE = 1.7976931348623157e+308 // Очень большое
Number.MIN_VALUE = 5e-324                    // Очень маленькое

// Вне этого диапазона — неточности
const big = 9007199254740992;  // Целое число
const big2 = big + 1;          // big2 === big (ошибка округления!)

Внутреннее представление в памяти

Пример: число 42

Знак (1 бит):     0 (положительное)
Экспонента (11 битов):  10000100
Мантисса (52 бита):     0101000...

Движки JavaScript обычно оптимизируют хранение для целых чисел, но в памяти все равно занимают 8 байт.

Объекты и другие типы

Осторожно: когда число оборачивается в объект, память другая:

const primitive = 42;           // 8 байт (number primitive)
const object = new Number(42);  // 8 байт + overhead объекта (~56+ байт)

// Не делай так:
const boxed = new Number(42);
console.log(boxed === 42);      // false! (разные типы)
console.log(boxed == 42);       // true (приведение типов)

BigInt — исключение

Есть исключение для больших целых чисел:

const normal = 123456789012345;    // number (8 байт) — может потерять точность
const big = 123456789012345n;      // BigInt — переменное количество памяти

// BigInt занимает столько байт, сколько нужно для числа
// Маленький BigInt: может быть 16+ байт
// Большой BigInt: может быть 100+ байт

const hugeNumber = 12345678901234567890n; // Столько байт, сколько нужно

Оптимизация в движках

Движки JavaScript (V8, SpiderMonkey) часто оптимизируют:

// Целые числа могут храниться как 31-битные целые (Smi) в V8
const small = 42;     // Может храниться как 4 байта (оптимизировано)
const large = 1.5;    // Всегда 8 байт

// Но это внутренняя оптимизация, видимо — всегда 8 байт
const arr = new ArrayBuffer(8);
const view = new Float64Array(arr);
view[0] = 42;
console.log(view[0]); // 42, занимает 8 байт

Проверка в DevTools

// Примерный расход памяти (в Node.js)
const obj = { num: 42 };
console.log(JSON.stringify(obj).length); // "num":42 -> string представление

// Более точно — через Buffer
const buffer = Buffer.alloc(8);
buffer.writeDoubleLE(42, 0); // Пишет number в буфер (8 байт)
console.log(buffer);         // <Buffer ...>

TypedArrays — точное управление

Если нужна точность в использовании памяти, используй TypedArrays:

// Float64Array — точно 8 байт на число
const numbers = new Float64Array(100);
const memoryUsed = numbers.byteLength; // 800 байт (100 * 8)

numbers[0] = 3.14;
numbers[1] = 42;
numbers[99] = -999.5;

console.log(memoryUsed); // Всегда 800 байт, независимо от значений

Сравнение с другими языками

Практические примеры

Array объёма:

// Array из 1000 чисел
const arr = new Array(1000).fill(0).map((_, i) => i);
// Примерная память: 1000 * 8 байт = 8 кB (плюс overhead массива)

// Float64Array из 1000 чисел
const typed = new Float64Array(1000);
const exactMemory = typed.byteLength; // 8000 байт = 8 kB (точно)

При отправке данных:

// JSON (строка)
const num = 3.14159265;
const json = JSON.stringify({ value: num });
console.log(json.length); // длина строки, не памяти

// Двоичный формат (точно)
const buffer = Buffer.alloc(8);
buffer.writeDoubleLE(num, 0);
console.log(buffer.length); // 8 байт (точно)

Итог

• Все числа в JavaScript занимают 8 байт в памяти
• Это IEEE 754 double-precision формат
• Независимо от того, число это целое, дробное или специальное значение (Infinity, NaN)
• Исключение: BigInt занимает переменное количество памяти
• Движки могут оптимизировать малые целые числа, но видимо — всегда 8 байт
• Если нужна точность в использовании памяти — используй TypedArrays