Какие знаешь способы преобразования типов примитивов в JavaScript?

Способы преобразования типов примитивов в JavaScript

В JavaScript преобразование типов (type coercion) — это фундаментальная концепция, поскольку язык является слабо типизированным. Все преобразования можно разделить на явные (explicit) и неявные (implicit). Рассмотрим основные способы преобразования примитивных типов: string, number, boolean, null, undefined, symbol и bigint.

Явное преобразование типов

Явное преобразование происходит, когда разработчик явно указывает, как преобразовать значение.

1. Преобразование в строку (String)

// Использование String() или .toString()
const num = 42;
const str1 = String(num);      // "42"
const str2 = num.toString();   // "42"
const str3 = (123).toString(); // "123"

// Особые случаи
String(null);      // "null"
String(undefined); // "undefined"
String(true);      // "true"

2. Преобразование в число (Number)

// Использование Number()
Number("42");      // 42
Number("42px");    // NaN (не число)
Number("");        // 0 (пустая строка)
Number("  ");      // 0 (пробелы)
Number(null);      // 0
Number(undefined); // NaN
Number(true);      // 1
Number(false);     // 0

// Парсинг чисел
parseInt("42px");  // 42 (извлекает целое число)
parseFloat("3.14"); // 3.14

3. Преобразование в логическое значение (Boolean)

Boolean(0);        // false
Boolean(1);        // true
Boolean("");       // false
Boolean("hello");  // true
Boolean(null);     // false
Boolean(undefined);// false
Boolean(NaN);      // false
Boolean([]);       // true (объект)
Boolean({});       // true (объект)

// Двойное отрицание
const truthyValue = !!"text"; // true

4. Преобразование с помощью унарного плюса

+"42";     // 42
+true;     // 1
+false;    // 0
+null;     // 0
+"";       // 0
+"  ";     // 0

Неявное преобразование типов

Неявное преобразование происходит автоматически в определенных контекстах.

1. В арифметических операциях

"5" - 3;   // 2 (строка преобразуется в число)
"5" + 3;   // "53" (конкатенация строк)
"10" / 2;  // 5
"10" * "2";// 20

2. В операторах сравнения

"5" == 5;  // true (нестрогое сравнение)
"5" === 5; // false (строгое сравнение)
null == undefined; // true
null === undefined;// false

3. В логическом контексте

if ("text") { /* выполнится */ }
if (0) { /* не выполнится */ }

const result = "text" || "default"; // "text" (логическое ИЛИ)
const value = "" && "default";      // "" (логическое И)

4. В шаблонных литералах

const count = 5;
console.log(`Количество: ${count}`); // "Количество: 5" (автоматическое преобразование)

Специальные методы преобразования

1. Использование оператора ?? (nullish coalescing)

const value = null ?? "default"; // "default"
const empty = "" ?? "default";   // "" (только null/undefined)

2. Преобразование с помощью Object.prototype.valueOf()

const obj = {
  valueOf() {
    return 42;
  }
};
Number(obj); // 42

3. Преобразование BigInt

BigInt(42);          // 42n
BigInt("9007199254740991"); // 9007199254740991n
42n + 2n;            // 44n
Number(42n);         // 42
String(42n);         // "42"

Важные особенности и подводные камни

• Ложные значения (falsy): false, 0, "", null, undefined, NaN
• Сложение со строкой: всегда приводит к конкатенации
• NaN: результат некорректного математического преобразования
• Преобразование объектов: Сначала вызывается valueOf(), затем toString()

// Пример сложного преобразования
const obj = {
  valueOf() { return 1; },
  toString() { return "2"; }
};
alert(obj); // "2" (использует toString)
obj + 1;    // 2 (использует valueOf)

Понимание механизмов преобразования типов критически важно для написания предсказуемого кода и предотвращения трудноуловимых багов. Рекомендуется использовать явное преобразование там, где возможна двусмысленность, и всегда применять строгое сравнение (===, !==) вместо нестрогого.