Что происходит в JavaScript при нестрогом сравнении (==)?

При нестрогом сравнении (==) в JavaScript выполняется преобразование типов (coercion) операндов перед сравнением. Если типы операндов различаются, JavaScript пытается преобразовать один или оба операнда к одному типу, основываясь на ряде правил.

Основные правила преобразования при ==:

1. Число и строка: Строка преобразуется в число. Если преобразовать не удалось (NaN), результат всегда false.

   // "10" преобразуется в 10. Результат: true
   console.log(10 == "10");
   // "abc" преобразуется в NaN. Результат: false
   console.log(10 == "abc");
   

2. Boolean и не-Boolean: Boolean преобразуется в число ( true в 1, false в 0). Затем сравниваются число и другой операнд (который может быть преобразован).

   // true преобразуется в 1. Результат: true
   console.log(true == 1);
   // false преобразуется в 0. Результат: true
   console.log(false == 0);
   // false преобразуется в 0, "0" преобразуется в 0. Результат: true
   console.log(false == "0");
   

3. Null и Undefined: null сравнивается с undefined как true, и ни с чем другим (кроме себя) как true.

   // Результат: true
   console.log(null == undefined);
   // Результат: false
   console.log(null == 0);
   // Результат: false
   console.log(undefined == 0);
   

4. Объект и примитив: Объект преобразуется в примитив (с помощью методов valueOf или toString), затем сравниваются примитивы.

   // Объект преобразуется в строку "10" (через toString()), затем сравнивается с числом 10
   // "10" преобразуется в 10. Результат: true
   console.log({ toString: () => "10" } == 10);
   

5. Символ и другое: Символ можно сравнить только с другим символом или примитивным значением, к которому символ может быть преобразован (что по сути невозможно в стандартных случаях).

   // Результат: false
   console.log(Symbol('a') == 'a');
   

Нестрогое сравнение может приводить к неожиданным результатам из-за автоматического преобразования типов. Для более предсказуемого поведения рекомендуется использовать строгое сравнение (===), которое не выполняет преобразование типов и сравнивает операнды напрямую.