Что такое примитив?

Что такое примитив

Примитив (primitive type) - это базовый тип данных в JavaScript, который не является объектом. Примитивы хранятся по значению, а не по ссылке, и имеют фиксированный размер в памяти.

Список примитивных типов в JavaScript

В JavaScript есть 7 примитивных типов (с ES2020 добавился BigInt):

1. String - строки
2. Number - числа
3. Boolean - логические значения
4. Undefined - отсутствие значения
5. Null - явное отсутствие значения
6. Symbol - уникальные идентификаторы
7. BigInt - большие целые числа

String (строка)

const name = "John"; // примитив
const greeting = 'Hello'; // примитив
const template = `World`; // примитив

const strObject = new String("John"); // объект, не примитив!

console.log(typeof name); // "string"
console.log(typeof strObject); // "object" (не строка!)

Number (число)

const integer = 42; // примитив
const decimal = 3.14; // примитив
const negative = -10; // примитив
const scientific = 1e5; // примитив (100000)
const infinity = Infinity; // примитив
const nan = NaN; // примитив (Not a Number)

const numObject = new Number(42); // объект, не примитив

console.log(typeof integer); // "number"
console.log(typeof nan); // "number" (NaN это number!)
console.log(typeof infinity); // "number"

Boolean (логическое значение)

const isTrue = true; // примитив
const isFalse = false; // примитив

const boolObject = new Boolean(true); // объект, не примитив

console.log(typeof isTrue); // "boolean"
console.log(typeof boolObject); // "object"

Undefined

let variable; // неинициализированная переменная
console.log(variable); // undefined (примитив)

function noReturn() {
  // функция без return
}
console.log(noReturn()); // undefined

const obj = {};
console.log(obj.notExist); // undefined

console.log(typeof undefined); // "undefined"

Null

const empty = null; // примитив (явное отсутствие значения)
const user = null; // "нет пользователя"

console.log(typeof null); // "object" (это баг в JavaScript!)

Важно: typeof null возвращает "object", хотя null это примитив. Это историческая ошибка в JavaScript.

Symbol (уникальный идентификатор)

const symbol1 = Symbol("id"); // примитив
const symbol2 = Symbol("id"); // примитив

console.log(symbol1 === symbol2); // false - каждый Symbol уникален!

const user = {
  name: "John",
  [symbol1]: "secret-value" // скрытое свойство
};

console.log(Object.keys(user)); // ["name"] - Symbol не перечисляется

BigInt (большие целые числа)

const bigNumber = 123456789012345678901234567890n; // примитив
const alsoNig = BigInt("123456789012345678901234567890");

console.log(typeof bigNumber); // "bigint"

// Number не может хранить точно больше чем Number.MAX_SAFE_INTEGER
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(9007199254740992 === 9007199254740992); // true
console.log(9007199254740993 === 9007199254740992); // true (потеря точности!)

// BigInt сохраняет точность
const big = BigInt("9007199254740993");
console.log(big); // 9007199254740993n (точное значение)

Примитивы vs Объекты

Хранение в памяти

// Примитив - хранится по значению
let x = 5;
let y = x; // копируется значение
x = 10;

console.log(x); // 10
console.log(y); // 5 (независимо)

// Объект - хранится по ссылке
let obj1 = { value: 5 };
let obj2 = obj1; // копируется ссылка
obj1.value = 10;

console.log(obj1.value); // 10
console.log(obj2.value); // 10 (изменились оба!)

Сравнение

// Примитивы - сравниваются по значению
const str1 = "hello";
const str2 = "hello";
console.log(str1 === str2); // true (одинаковые значения)

const num1 = 42;
const num2 = 42;
console.log(num1 === num2); // true

// Объекты - сравниваются по ссылке
const arr1 = [1, 2, 3];
const arr2 = [1, 2, 3];
console.log(arr1 === arr2); // false (разные ссылки)

const arr3 = arr1;
console.log(arr1 === arr3); // true (одна ссылка)

Автоматическое упаковывание (Boxing)

Частая путаница: примитивы имеют методы, как будто это объекты. Это потому, что JavaScript автоматически "упаковывает" примитивы:

const str = "hello"; // примитив

// Когда вызываем метод
console.log(str.toUpperCase()); // "HELLO"

// JavaScript делает так:
// 1. Создает временный String объект
const temp = new String(str);
// 2. Вызывает метод
const result = temp.toUpperCase();
// 3. Удаляет временный объект

console.log(typeof str); // все еще "string", не "object"

Таже происходит с Number и Boolean:

const num = 42;
console.log(num.toFixed(2)); // "42.00"
// JavaScript временно упаковал num в Number объект

const bool = true;
console.log(bool.toString()); // "true"
// JavaScript временно упаковал bool в Boolean объект

Immutability примитивов

Примитивы неизменяемы (immutable). Нельзя изменить примитив - можно только переприсвоить переменную:

let str = "hello";
str.toUpperCase(); // возвращает "HELLO"
console.log(str); // "hello" - оригинальная строка не изменилась

str = str.toUpperCase(); // теперь переприсвоили
console.log(str); // "HELLO"

// С объектами иначе
const arr = [1, 2, 3];
arr.push(4); // модифицирует массив
console.log(arr); // [1, 2, 3, 4] - массив изменился

Тип проверка

// typeof для примитивов
console.log(typeof "string"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof Symbol()); // "symbol"
console.log(typeof 42n); // "bigint"
console.log(typeof null); // "object" (баг!)

// Для null используй точную проверку
console.log(value === null); // правильно
console.log(typeof value === 'object' && value !== null); // правильно для объектов

Примеры в реальном коде

// Функция с примитивными параметрами
function greet(name, age, isStudent = false) {
  // name: string (примитив)
  // age: number (примитив)
  // isStudent: boolean (примитив)
  
  console.log(`Hello ${name}, age ${age}`);
}

// API возвращает примитивные значения
const response = {
  id: 123,           // number
  name: "John",      // string
  email: "john@..."  // string
  isActive: true,    // boolean
  createdAt: null    // null (примитив)
};

// Условие с примитивом
if (response.isActive === true) {
  // boolean примитив
}

Вывод

Примитивы - это 7 базовых типов данных в JavaScript:

• String, Number, Boolean, Undefined, Null, Symbol, BigInt

Основные характеристики примитивов:

1. Хранятся по значению, не по ссылке
2. Immutable - неизменяемы
3. Сравниваются по значению, не по ссылке
4. Меньше памяти и быстрее в обработке
5. Имеют методы благодаря автоматическому упаковыванию

Все остальное в JavaScript - это объекты (массивы, функции, даты, регулярные выражения, обычные объекты и т.д.).