Sobes.tech
Junior

Какво се случва в JavaScript при нестрого сравнение (==)?

sobes.tech AI

Отговор от AI

При нестрогото сравнение (==) в JavaScript се извършва преобразуване на типове (coercion) на операндите преди сравнението. Ако типовете на операндите се различават, JavaScript се опитва да преобразува един или и двата операнда към един и същи тип, базирайки се на редица правила.

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

  1. Число и низ: Низът се преобразува в число. Ако преобразуването не успее (NaN), резултатът винаги е false.
    // "10" се преобразува в 10. Резултат: true
    console.log(10 == "10");
    // "abc" се преобразува в NaN. Резултат: false
    console.log(10 == "abc");
    
  2. Булев и не-Булев: Булевото се преобразува в число (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');
    

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