Какие типы данных в JavaScript относятся к простым?

Какие типы данных в JavaScript относятся к простым?

Простые типы данных (primitive types) — это базовые типы, которые хранят одно значение и передаются по значению. JavaScript имеет 7 простых типов данных (в ES2020+ добавили BigInt).

Список простых типов

1. Number (Число)

Представляет числовые значения (целые и дробные).

const integer = 42;
const float = 3.14;
const negative = -10;
const scientific = 1e3;  // 1000
const hex = 0xFF;        // 255
const octal = 0o77;      // 63
const binary = 0b1010;   // 10

// Специальные значения
const infinity = Infinity;
const negInfinity = -Infinity;
const notANumber = NaN;

// Проверка типа
console.log(typeof 42);      // "number"
console.log(typeof Infinity); // "number"
console.log(typeof NaN);      // "number" (это баг в JavaScript!)

// Диапазон
console.log(Number.MIN_VALUE);     // 5e-324
console.log(Number.MAX_VALUE);     // 1.7976931348623157e+308
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991 (2^53 - 1)
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

Особенности:

• Внутри хранится как 64-битное число (IEEE 754 double precision)
• Есть ошибки с точностью при работе с дробями

0.1 + 0.2;        // 0.30000000000000004 (не 0.3!)
0.1 + 0.2 === 0.3 // false

// Решение: использовать toFixed() или библиотеку Decimal.js

2. String (Строка)

Представляет текстовые данные.

const single = 'Hello';
const double = "World";
const template = `Hello, ${name}!`; // Template literal
const empty = '';

// Экранирование
const escaped = 'I\'m happy';
const newline = 'Line 1\nLine 2';
const tab = 'Col1\tCol2';

// Длина и доступ
const str = 'Hello';
console.log(str.length);     // 5
console.log(str[0]);         // 'H'
console.log(str.charAt(1));  // 'e'

// Методы
console.log(str.toUpperCase());  // 'HELLO'
console.log(str.toLowerCase());  // 'hello'
console.log(str.substring(1, 4)); // 'ell'
console.log(str.includes('ell')); // true
console.log(str.split(''));      // ['H','e','l','l','o']

// Проверка типа
console.log(typeof 'hello');    // "string"
console.log(typeof "");         // "string"

Особенности:

• Строки иммутабельны (неизменяемы)
• 16-битные Unicode символы

const str = 'Hello';
str[0] = 'X';  // Не работает, строка не изменилась

3. Boolean (Логический тип)

Представляет два значения: истина или ложь.

const yes = true;
const no = false;

// Логические операторы
console.log(true && false);   // false (AND)
console.log(true || false);   // true (OR)
console.log(!true);           // false (NOT)

// Truthiness и Falsy значения
// Falsy (преобразуются в false)
const falsy = [
  false,
  0,
  -0,
  0n,          // BigInt zero
  '',          // empty string
  null,
  undefined,
  NaN
];

// Все остальное - Truthy

// Примеры
if (0) { console.log('true'); }  // Не выполнится
if (1) { console.log('true'); }  // Выполнится
if ('') { console.log('true'); } // Не выполнится
if ('hello') { console.log('true'); } // Выполнится

// Проверка типа
console.log(typeof true);  // "boolean"
console.log(typeof false); // "boolean"

4. Undefined (Неопределено)

Значение, которое JavaScript присваивает переменным автоматически, если они не инициализированы.

let x;  // Не инициализирована
console.log(x);            // undefined
console.log(typeof x);     // "undefined"

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

// Отсутствующий параметр
function func(param) {
  console.log(param);      // undefined
}
func();

// Проверка на undefined
let value;
if (value === undefined) { /* ... */ }
if (typeof value === 'undefined') { /* ... */ }

// ВАЖНО: undefined это не просто значение
const obj = { a: 1 };
console.log(obj.b);        // undefined
console.log(obj.b === undefined); // true

5. Null (Ничего)

Явное значение, которое обозначает отсутствие какого-либо значения.

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

// Разница между null и undefined
let x = null;      // явное присваивание
let y = undefined; // нет значения

console.log(null === undefined);   // false
console.log(null == undefined);    // true (типа дружбы)

// Проверка на null
if (value === null) { /* ... */ }
if (value == null)  { /* ... */ }  // Проверяет и null и undefined

6. Symbol (Символ, ES2015)

Уникальные идентификаторы, которые используются как ключи объектов.

const symbol1 = Symbol('description');
const symbol2 = Symbol('description');

// Каждый Symbol уникален
console.log(symbol1 === symbol2);  // false
console.log(typeof symbol1);        // "symbol"

// Использование как ключ объекта
const obj = {
  [symbol1]: 'value1',
  [symbol2]: 'value2',
  name: 'John'
};

console.log(obj[symbol1]);  // 'value1'
console.log(Object.keys(obj)); // ['name'] - символы не перечисляются!
console.log(Object.getOwnPropertySymbols(obj)); // [symbol1, symbol2]

// Встроенные символы
const arr = [1, 2, 3];
for (const item of arr) {  // Использует Symbol.iterator
  console.log(item);
}

const obj2 = {
  [Symbol.iterator]() {
    // Кастомная итерация
  }
};

7. BigInt (Большое целое число, ES2020)

Для работы с очень большими целыми числами, больше Number.MAX_SAFE_INTEGER.

const big1 = 123456789012345678901234567890n;  // n в конце
const big2 = BigInt('999999999999999999999999');

// Операции
console.log(big1 + big2);
console.log(big1 * 2n);
console.log(big1 / 2n);

// НЕЛЬЗЯ смешивать с Number
console.log(1n + 1);     // TypeError!
console.log(BigInt(1) + 1n); // OK

// Проверка типа
console.log(typeof 123n); // "bigint"

// Диапазон
console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991
const big = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
console.log(big); // 9007199254740992n

Различие между примитивами и объектами

По значению vs по ссылке

// ПРИМИТИВЫ: передаются по значению
let a = 5;
let b = a;
b = 10;
console.log(a); // 5 (не изменилась)

// ОБЪЕКТЫ: передаются по ссылке
let obj1 = { value: 5 };
let obj2 = obj1;
obj2.value = 10;
console.log(obj1.value); // 10 (изменилась!)

Immutability

// Примитивы всегда иммутабельны
const num = 42;
const str = 'hello';
// Нельзя менять

// Но переменная может указывать на другое значение
let x = 5;
x = 10; // Новое значение, не изменение старого

Автоупаковка (Boxing)

JavaScript автоматически конвертирует примитивы в объекты:

const str = 'hello';
console.log(str.length);      // 5
console.log(str.toUpperCase()); // 'HELLO'

// Под капотом:
// 1. 'hello' конвертируется в new String('hello')
// 2. Вызывается метод
// 3. Объект удаляется

// То же самое с числами
const num = 42;
console.log(num.toFixed(2));  // '42.00'

Таблица всех типов

Проверка типов

// typeof для примитивов
console.log(typeof 42);           // "number"
console.log(typeof 'hello');      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof Symbol('id')); // "symbol"
console.log(typeof 123n);         // "bigint"

// instanceof для объектов
console.log([] instanceof Array);      // true
console.log({} instanceof Object);     // true
console.log(/regex/ instanceof RegExp); // true

// Специальные проверки
Number.isNaN(NaN);      // true (правильная проверка)
isNaN(NaN);             // true (но может дать false positives)
Object.is(NaN, NaN);    // true

Итоги

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

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

Ключевые свойства примитивов:

• Передаются по значению
• Иммутабельны
• Имеют встроенные методы (благодаря auto-boxing)
• Компактны в памяти

Остальное — объекты (функции, массивы, даты, регулярные выражения, etc.), которые передаются по ссылке.