在 JavaScript 环境下，可以让表达式 a == @L_406_0@ && a == false 为 true 吗？

就像下面这样，可以在控制台打印出 ’yeah':

// code here
if (a == true && a == false) {
    console.LOG('yeah');
}

JavaScript 是一门类型松散的语言，在使用 == 进行比较时，倘若左右类型不一致，是会进行类型装换的。首先来了解一下宽松相等的概念，

宽松相等 ==

先看看 ECMA 5.1 的规范，包含 toPRimITive:

规范

1. If Type(x) is the same as Type(y), then

   1. If Type(x) is Undefined, return true.
   2. If Type(x) is Null, return true.

   3. If Type(x) is Number, then

      1. If x is NaN, return false.
      2. If y is NaN, return false.
      3. If x is the same Number value as y, return true.
      4. If x is +0 and y is −0, return true.
      5. If x is −0 and y is +0, return true.
      6. Return false.
   4. If Type(x) is String, then return true if x and y are exactly the same sequence of characters (same length and same characters in corresponding positions). Otherwise, return false.
   5. If Type(x) is Boolean, return true if x and y are both true or both false. Otherwise, return false.
   6. Return true if x and y refer to the same object. Otherwise, return false.
2. If x is null and y is undefined, return true.
3. If x is undefined and y is null, return true.
4. If Type(x) is Number and Type(y) is String, return the result of the comparison x == ToNumber(y).
5. If Type(x) is String and Type(y) is Number, return the result of the comparison ToNumber(x) == y.
6. If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.
7. If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).
8. If Type(x) is either String or Number and Type(y) is Object, return the result of the comparison x == ToPrimitive(y).
9. If Type(x) is Object and Type(y) is either String or Number, return the result of the comparison ToPrimitive(x) == y.
10. Return false.

9.1 ToPrimitive

Table 10 — ToPrimitive Conversions

稍作总结

对于下述表达式：

x == y

• 类型相同，判断的就是 x === y

• 类型不同

  • 如果 x，y 其中一个是布尔值，将这个布尔值进行 ToNumber 操作
  • 如果 x，y 其中一个是字符串，将这个字符串进行 ToNumber 操作
  • 若果 x，y 一方为对象，将这个对象进行 ToPrimitive 操作

至于 ToPrimitive，即求原始值，可以简单理解为进行 valueOf() 和 toString() 操作。

稍后我们再详细剖析，接下来先看一个问题。

Question：是否存在这样一个变量，满足 x == !x

就像这样：

// code here
if (x == !x) {
    console.log('yeah');
}

可能很多人会想到下面这个，毕竟我们也曾热衷于各种奇技淫巧：

[] == ![] // true

但答案绝不仅仅局限于此，比如：

VAR x = new Boolean(false);


if (x == !x) {
    console.log('yeah');
}

理解这个问题，基本上下面的这些例子都不是问题了。

宽松相等的栗子

9 == '9'

9 == '9x'

9 == true

9 == undefined

9 == null

0 == undefined

0 == null

undefined == null

0 == false

'' == false

'1' == true

'9' == true

9 == [9]

'9' == [9]

'9' == [9, 4]

'9,4' == [9, 4]

[] == []

[] == ![]

![] == ![]

[] == {}

[] == !{}

{} == ![]

{} == {}

{} == !{}

9 == { toString() { return 9 }}

9 == { valueOf() { return 9 }}

9 == { a: 9 }

9 == {}

'[object Object]' == {}

在来看看什么是 ToPrimitive

ToPrimitive

贴个规范：8.12.8 [[DefaultValue]] (hint)

如果是 Date 求原始值，则 hint 是 String，其他均为 Number，即先调用 valueOf() 再调用 toString()。

如果 hint 为 Number，具体过程如下：

1. 调用对象的 valueOf() 方法，如果值是原值则返回
2. 否则，调用对象的 toString() 方法，如果值是原值则返回
3. 否则，抛出 TypeError 错误

// valueOf 和 toString 的调用顺序
var a = {
    valueOf() {
        console.log('valueof')
        return []
    },
    toString() {
        console.log('toString')
        return {}
    }
}

a == 0
// valueof
// toString
// Uncaught TypeError: Cannot convert object to primitive value


// Date 类型先 toString，后 valueOf
var t = new Date('2018/04/01');
t.valueOf = function() {
    console.log('valueof')
    return []
}
t.toString = function() {
    console.log('toString')
    return {}
}
t == 0
// toString
// valueof
// Uncaught TypeError: Cannot convert object to primitive value

到目前为止，上面的都是 ES5 的规范，那么在 ES6 中，有什么变化呢

ES6 中 ToPrimitive

7.1.1ToPrimitive ( input [, PreferredType] )

在 ES6 中吗，是可以自定义 @@toPrimitive 方法的，是 Well-Known Symbols(§6.1.5.1)中的一个。JavaScript 还内建了一些在 ECMAScript 5 之前没有暴露给开发者的 symbol，它们代表了内部语言行为。

// 没有 Symbol.toPrimitive 属性的对象
var obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // '[object Object]'
console.log(obj1 + ''); // '[object Object]'

// 拥有 Symbol.toPrimitive 属性的对象
var obj2 = {
    [Symbol.toPrimitive](hint) {
        if (hint == 'number') {
            return 10;
        }
        if (hint == 'string') {
            return 'hello';
        }
        return true;
    }
};
console.log(+obj2); // 10 -- hint is 'number'
console.log(`${obj2}`); // 'hello' -- hint is 'string'
console.log(obj2 + ''); // 'true' -- hint is 'default'

有了上述铺垫，答案就呼之欲出了

最初题目的答案

var a = {
    flag: false,
    toString() {
        return this.flag = !this.flag;
    }
}

或者使用 valueOf()：

var a = {
    flag: false,
    valueOf() {
        return this.flag = !this.flag;
    }
}

或者是直接改变 ToPrimitive 行为：

// 其实只需设置 default 即可
var a = {
    flag: false,
    [Symbol.toPrimitive](hint) {
        if (hint === 'number') {
            return 10
        }
        if (hint === 'string') {
            return 'hello'
        }
        return this.flag = !this.flag
    }
}

如果是严格相等呢

但是，有没有办法是严格相等，即：

// code here
if (a === true && a === false) {
console.log('yeah');
}

答案是：有。

使用 defineProperty，可能有不少朋友一开始就想到这种方式，简单贴一下：

let flag = false
Object.defineProperty(window, 'a', {
    get() {
        return (flag = !flag)
    }
})

if (a === true && a === false) {
    console.log('yeah');
}

阅读更多

• Can (a== 1 && a ==2 && a==3) ever evaluate to true?