Как интерпретатор приводит типы?

Как интерпретатор JavaScript приводит типы (Type Coercion)

Type Coercion (приведение типов) — это автоматическое преобразование одного типа данных в другой. JavaScript делает это неявно в определённых ситуациях, что часто приводит к неожиданным результатам.

Два вида приведения типов

1. Implicit Coercion (неявное)

Интерпретатор преобразует тип без твоего ведома:

// Строка + Число = Строка (конкатенация)
'5' + 3 // '53' (число преобразуется в строку)

// Строка - Число = Число (числовое вычитание)
'5' - 3 // 2 (строка преобразуется в число)

// Логическое значение + Число
true + 1 // 2 (true преобразуется в 1)
false + 1 // 1 (false преобразуется в 0)

2. Explicit Coercion (явное)

Ты явно указываешь преобразование:

Number('5') // 5
String(5) // '5'
Boolean(1) // true

Правила приведения к строке (String Coercion)

// Конкатенация с оператором +
'Hello ' + 5 // 'Hello 5'
'Hello ' + true // 'Hello true'
'Hello ' + null // 'Hello null'
'Hello ' + undefined // 'Hello undefined'

// Метод toString()
(123).toString() // '123'
true.toString() // 'true'

Правила приведения к числу (Number Coercion)

// В арифметических операциях (кроме +)
'5' - 2 // 3
'5' * 2 // 10
'5' / 2 // 2.5

// Пустая строка и whitespace преобразуются в 0
+'' // 0
+' ' // 0
+' 123 ' // 123

// null преобразуется в 0
+null // 0

// undefined преобразуется в NaN
+undefined // NaN

// true = 1, false = 0
+true // 1
+false // 0

Правила приведения к boolean (Boolean Coercion)

// Логические операторы, if, while и т.д.
if ('hello') { } // true
if ('') { } // false
if (0) { } // false
if (1) { } // true
if (null) { } // false
if (undefined) { } // false

// Явное приведение
Boolean('hello') // true
Boolean('') // false
Boolean(0) // false
Boolean(1) // true
Boolean(null) // false
Boolean(undefined) // false

Falsy (ложные) и Truthy (истинные) значения

Falsy (преобразуются в false):

• false
• 0 и -0
• 0n (BigInt)
• '' (пустая строка)
• null
• undefined
• NaN

Truthy (преобразуются в true):

• Всё остальное
• '0' (строка с 0, не ноль!)
• [] (массив, даже пустой)
• {} (объект, даже пустой)
• function(){} (функция)

if ('0') console.log('true'); // выведет 'true'!
if ([]) console.log('true'); // выведет 'true'!
if ({}) console.log('true'); // выведет 'true'!

Сравнение с оператором == (loose equality)

== выполняет приведение типов перед сравнением:

// Число vs Строка
5 == '5' // true (строка преобразуется в число)
5 === '5' // false (без приведения типов)

// null и undefined
null == undefined // true (специальный случай)
null === undefined // false

// Число vs Boolean
1 == true // true (true преобразуется в 1)
0 == false // true (false преобразуется в 0)

// Массив vs Строка
[1, 2] == '1,2' // true (массив преобразуется в строку)

Трёхсторонний алгоритм сравнения (== между строкой и числом)

// Если слева число, справа строка
5 == '5' // Строка преобразуется в число -> 5 == 5 -> true

// Если слева boolean
false == 0 // Boolean преобразуется в число -> 0 == 0 -> true
true == '1' // true в число (1), '1' в число (1) -> 1 == 1 -> true

// Если оба объекты
[1, 2] == [1, 2] // false (разные объекты, даже если значения равны)

Хитрые примеры приведения типов

// ❌ Неожиданный результат
'' == 0 // true (пустая строка преобразуется в 0)
'' == false // true (и то, и другое falsy)
0 == false // true

// Но это не работает по транзитивности
'' == false // true
0 == false // true
'' == 0 // true (OK, работает)

// Объекты
[] + [] // '' (два пустых массива преобразуются в пустую строку)
[] + {} // '[object Object]'
{} + [] // NaN (конфликт синтаксиса)

// NaN
NaN == NaN // false (NaN не равна даже себе!)
NaN === NaN // false
isNaN(NaN) // true

Как интерпретатор выполняет приведение

ToPrimitive() — преобразование объекта в примитив:

const obj = {
  valueOf() {
    return 5;
  },
  toString() {
    return 'hello';
  }
};

// Когда нужно число
obj + 3 // 8 (вызывает valueOf() -> 5 + 3)

// Когда нужна строка
String(obj) // 'hello' (вызывает toString())

Лучшие практики

1. Используй === вместо ==

// ❌ Плохо
if (value == null) { } // может вызвать неожиданное поведение

// ✅ Хорошо
if (value === null || value === undefined) { }

2. Явное приведение типов

// ❌ Неясно
if (x == 5) { }

// ✅ Ясно
if (Number(x) === 5) { }
if (parseInt(x, 10) === 5) { }

3. Проверка falsy значений

// ✅ Правильно: проверяешь конкретное значение
if (value !== null && value !== undefined) { }
if (value != null) { } // OK: null == undefined

// ❌ Неправильно: теряются нули и пустые строки
if (value) { } // Не пройдёт для 0, '', false

Резюме

Type Coercion — это автоматическое преобразование типов, которое может привести к неожиданным результатам:

• Используй === (strict equality), а не == (loose equality)
• Явно приводи типы через Number(), String(), Boolean() когда надо
• Знай Falsy значения: false, 0, '', null, undefined, NaN
• Избегай приведения типов в критичных сравнениях
• Понимай, как работают операторы: + для конкатенации, - для числовых операций

Это знание критично для написания надёжного и понятного кода.