JavaScript equality transitivity is weird

Odpowiedź na to pytanie ma związek z tym, jak JavaScript radzi sobie z przymusem. W przypadku ==, ciągi są wymuszane liczbami . Dlatego:

'' == '0' jest równoważne '' === '0' (oba są ciągami, więc nie jest konieczne przymus).

0 == '' jest równoważne 0 === 0 ponieważ łańcuch '' staje się liczbą 0 (math.abs('') === 0).

0 == '0' jest równoważne 0 === 0 z tego samego powodu.

false == undefined jest równoważne 0 === undefined ponieważ JavaScript wymusza booleans to be numbers when types don ' t match

false == null jest równoważne 0 === null z tego samego powodu.

null == undefined to prawda, ponieważ spec tak mówi.

Możesz napisać funkcję JavaScript, która zachowuje się dokładnie tak jak ==, która powinna dać ci wgląd w jej zachowanie.

Aby pokazać, co mam na myśli tutaj jest ta funkcja:

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);

    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Jak widać == ma dużo skomplikowanej logiki konwersji typów. Z tego powodu trudno przewidzieć, jaki wynik otrzymasz.

Oto kilka przykładów niektórych wyników, których nie można się spodziewać:

Unexpected Prawdy

[1] == true // returns true
'0' == false // returns true
[] == false // returns true
[[]] == false // returns true
[0] == false // returns true

'\r\n\t' == 0 // returns true

Nieoczekiwane Wnioski

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

Obiekty z funkcjami specjalnymi

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**

Powodem jest to, że operator identity lub strict ( = = = ) porównuje go z bez konwersji typu, co oznacza, że jeśli obie wartości nie mają tej samej wartości i tego samego typu, nie będą uważane za równe.

Zerknij na ten link, to cię budzi wątpliwości: łatwy sposób na zrozumienie działania operatora tożsamości