Какие типы данных существуют в JavaScript?

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

В JavaScript существует 8 типов данных:

Примитивные типы (7):

number — числа
string — строки
boolean — логический тип
undefined — неопределенное значение
null — пустое значение
symbol — уникальный идентификатор (ES6)
bigint — большие целые числа (ES2020)

Ссылочный тип (1):

object — объекты (включая массивы, функции, даты и т.д.)

Примитивные типы данных

1. Number (Число)

Включает целые числа, дробные, специальные значения.

let age = 25;           // целое число
let price = 99.99;      // дробное число
let infinity = Infinity; // бесконечность
let notANumber = NaN;   // "не число"
 
console.log(typeof age);      // "number"
console.log(typeof infinity); // "number"
console.log(typeof notANumber); // "number"

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

Максимальное безопасное целое: Number.MAX_SAFE_INTEGER (2^53 - 1)
NaN не равно самому себе: NaN === NaN → false
Проверка на число: Number.isNaN(), Number.isFinite()

2. String (Строка)

Последовательность символов в кавычках.

let name = "Александр";        // двойные кавычки
let surname = 'Ермолов';       // одинарные кавычки
let fullName = `${name} ${surname}`; // шаблонные строки (ES6)
 
console.log(typeof name);     // "string"
console.log(fullName);        // "Александр Ермолов"

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

Строки неизменяемы (immutable)
Доступ к символам: name[0] или name.charAt(0)
Длина строки: name.length

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

Только два значения: true или false.

let isActive = true;
let isCompleted = false;
let isAdult = age >= 18;  // результат сравнения
 
console.log(typeof isActive); // "boolean"

Преобразование к boolean:

// Falsy значения (приводятся к false):
Boolean(0);         // false
Boolean("");        // false
Boolean(null);      // false
Boolean(undefined); // false
Boolean(NaN);       // false
Boolean(false);     // false
 
// Все остальное — truthy (приводится к true)
Boolean(1);         // true
Boolean("hello");   // true
Boolean([]);        // true
Boolean({});        // true

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

Значение переменной, которая объявлена, но не инициализирована.

let x;
console.log(x);        // undefined
console.log(typeof x); // "undefined"
 
// Функция без return тоже возвращает undefined
function test() {
  // нет return
}
console.log(test()); // undefined

5. Null (Пустое значение)

Представляет намеренное отсутствие значения.

let data = null;
console.log(data);        // null
console.log(typeof data); // "object" (это баг в JS!)
 
// Правильная проверка на null
console.log(data === null); // true

Разница между null и undefined:

let a;           // undefined (не инициализирована)
let b = null;    // null (намеренно пустая)
 
console.log(a == b);  // true (нестрогое сравнение)
console.log(a === b); // false (строгое сравнение)

6. Symbol (Символ)

Уникальный идентификатор, введенный в ES6.

let id1 = Symbol("id");
let id2 = Symbol("id");
 
console.log(id1 === id2);    // false (всегда уникальны)
console.log(typeof id1);     // "symbol"
 
// Использование в объектах
let user = {
  name: "Александр",
  [id1]: 123  // символ как ключ
};
 
console.log(user[id1]); // 123

7. BigInt (Большие целые)

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

let bigNumber = 123456789012345678901234567890n; // суффикс 'n'
let anotherBig = BigInt("123456789012345678901234567890");
 
console.log(typeof bigNumber); // "bigint"
 
// Нельзя смешивать с обычными числами
// console.log(bigNumber + 1); // TypeError!
console.log(bigNumber + 1n);   // работает

Ссылочный тип данных

Object (Объект)

Все, что не является примитивом — это объект.

// Обычный объект
let person = {
  name: "Александр",
  age: 30
};
 
// Массив (тоже объект!)
let numbers = [1, 2, 3, 4, 5];
 
// Функция (тоже объект!)
function greet() {
  return "Привет!";
}
 
// Дата (объект)
let now = new Date();
 
console.log(typeof person);  // "object"
console.log(typeof numbers); // "object"
console.log(typeof greet);   // "function" (особый случай)
console.log(typeof now);     // "object"

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

// Примитивы передаются по значению
let a = 5;
let b = a;
a = 10;
console.log(b); // 5 (не изменилось)
 
// Объекты передаются по ссылке
let obj1 = { x: 5 };
let obj2 = obj1;
obj1.x = 10;
console.log(obj2.x); // 10 (изменилось!)

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

Тип данных	typeof	Пример проверки
number	”number”	`typeof 42`
string	”string”	`typeof "hello"`
boolean	”boolean”	`typeof true`
undefined	”undefined”	`typeof undefined`
symbol	”symbol”	`typeof Symbol()`
bigint	”bigint”	`typeof 123n`
function	”function”	`typeof function(){}`
object	”object”	`typeof {}`, `typeof []`
null	”object”	`value === null`

Более точные способы проверки:

// Проверка массива
Array.isArray([1, 2, 3]);        // true
Array.isArray({});               // false
 
// Проверка null
value === null;                  // true для null
 
// Проверка NaN
Number.isNaN(NaN);              // true
isNaN("hello");                 // true (но неточно!)
 
// Универсальная проверка типа
Object.prototype.toString.call([]); // "[object Array]"
Object.prototype.toString.call({}); // "[object Object]"

Задачи для практики

Задача 1

console.log(typeof null);

Ответ

"object" — это историческая ошибка в JavaScript, которую нельзя исправить из-за обратной совместимости.

Задача 2

console.log(typeof NaN);

Ответ

"number" — `NaN` технически является числовым типом, хотя означает "не число".

Задача 3

let a = [];
let b = {};
let c = function() {};
 
console.log(typeof a, typeof b, typeof c);

Ответ

"object object function" — массивы и объекты имеют тип "object", функции — "function".

Задача 4

console.log(0 == false);
console.log("" == false);
console.log(null == undefined);

Ответ

`true true true` — при нестрогом сравнении происходит приведение типов.

Задача 5

let x = Symbol("test");
let y = Symbol("test");
console.log(x === y);

Ответ

`false` — каждый Symbol уникален, даже с одинаковым описанием.

Задача 6

let big = 9007199254740991n;
console.log(typeof big);
console.log(big + 1);

Ответ

"bigint" и TypeError — нельзя складывать BigInt с обычными числами без явного преобразования.

Практические советы

1. Используйте строгое сравнение

// Плохо
if (value == null) { /* ... */ }
 
// Хорошо
if (value === null || value === undefined) { /* ... */ }
// или
if (value == null) { /* только для проверки null/undefined */ }

2. Проверяйте типы правильно

// Для массивов
if (Array.isArray(value)) { /* ... */ }
 
// Для null
if (value === null) { /* ... */ }
 
// Для объектов (исключая null и массивы)
if (typeof value === "object" && value !== null && !Array.isArray(value)) {
  /* ... */
}

3. Будьте осторожны с приведением типов

// Неожиданные результаты
console.log("5" + 3);    // "53" (конкатенация)
console.log("5" - 3);    // 2 (вычитание)
console.log(+"5");       // 5 (унарный плюс)
console.log(!!"hello");  // true (двойное отрицание)

Резюме

В JavaScript 8 типов данных: 7 примитивных + объекты
Примитивы неизменяемы и передаются по значению
Объекты изменяемы и передаются по ссылке
typeof null === "object" — это баг, используйте === null
Для точной проверки типов используйте специальные методы
Избегайте неявного приведения типов — используйте строгое сравнение

Знание типов данных — это основа JavaScript, без которой невозможно писать качественный код!

Хочешь больше статей по подготовке к собеседованию? Подпишись на EasyAdvice(@AleksandrEmolov_EasyAdvice), добавляй сайт в избранное и прокачивай себя каждый день 💪