mozilla
您的搜索结果

    JavaScript 中的相等性判断

    JavaScript 提供三种不同的比较操作符:

    • 严格相等,使用 ===
    • (非严格)相等,使用 ==
    • 以及 Object.is (ECMAScript 6 新特性)

    你可以根据你的需要选择操作符。

    简单地说,两等号判等会在比较时进行类型转换;三等号判等不会进行类型转换(如果类型不同会直接返回 false ); Object.is 在三等号判等的基础上特别处理了 NaN-0+0 ,保证 -0 和 +0 不再相同,但 Object.is(NaN, NaN) 会返回 true。(像其他数值一样比较 NaN ——由于 IEEE 754 的规范,无论使用双等号或三等号,比较 NaN 都会得到 false )但请注意,此外,这三个运算符的原语中,没有一个会比较两个变量是否结构上概念类似。对于任意两个不同的非原始对象,即便他们有相同的结构, 以上三个运算符都会计算得到 false 。

    严格相等 ===

    全等操作符比较两个值是否相等,两个被比较的值在比较前都不进行隐式转换。如果两个被比较的值具有不同的类型,这两个值是不全等的。否则,如果两个被比较的值类型相同,值也相同,并且都不是 number 类型时,两个值全等。最后,如果两个值都是 number 类型,当两个都不是 NaN,并且数值相同,或是两个值分别为 +0 和 -0 时,两个值被认为是全等的。

    var num = 0;
    var obj = new String("0");
    var str = "0";
    var b = false;
    
    print(num === num); // true
    print(obj === obj); // true
    print(str === str); // true
    
    print(num === obj); // false
    print(num === str); // false
    print(obj === str); // false
    print(null === undefined); // false
    print(obj === null); // false
    print(obj === undefined); // false
    

    在日常中使用全等操作符几乎总是正确的选择。对于除了数值之外的值,全等操作符使用明确的语义进行比较:一个值只与自身全等。对于数值,全等操作符使用略加修改的语义来处理两个特殊情况:第一个情况是,浮点数 0 是不分正负的。区分 +0 和 -0 在解决一些特定的数学问题时是必要的,但是大部分境况下我们并不用关心。全等操作符认为这两个值是全等的。第二个情况是,浮点数包含了 NaN 值,用来表示某些定义不明确的数学问题的解,例如:正无穷加负无穷。全等操作符认为 NaN 与其他任何值都不全等,包括它自己。(等式 (x !== x) 成立的唯一情况是 x 的值为 NaN)

    相等 ==

    相等操作符比较两个值是否相等,在比较前将两个被比较的值转换为相同类型。在转换后(等式的一边或两边都可能被转换),最终的比较方式等同于全等操作符 === 的比较方式。 相等操作符满足交换律。

    相等操作符对于不同类型的值,进行的比较如下图所示:

      被比较值 B
        Undefined Null Number String Boolean Object
    被比较值 A Undefined true true false false false IsFalsy(B)
    Null true true false false false IsFalsy(B)
    Number false false A === B A === ToNumber(B) ToNumber(B) === A ToPrimitive(B) == A
    String false false B === ToNumber(A) A === B ToNumber(A) === ToNumber(B) ToPrimitive(B) == A
    Boolean false false ToNumber(A) === B ToNumber(A) === ToNumber(B) A === B false
    Object IsFalsy(A) IsFalsy(A) ToPrimitive(A) == B ToPrimitive(A) == B false

    A === B

    在上面的表格中,ToNumber(A) 尝试在比较前将参数 A 转换为数字,这与 +A(单目运算符+)的效果相同。通过尝试依次调用 A 的A.toString 和 A.valueOf 方法,将参数 A 转换为原始值。

    一般而言,根据 ECMAScript 规范,所有的对象都与 undefined null 不相等。但是大部分浏览器允许非常窄的一类对象(即,所有页面中的 document.all 对象),在某些情况下,充当效仿 undefined 的角色。相等操作符就是在这样的一个背景下。因此,IsFalsy(A) 方法的值为 true ,当且仅当 A 效仿 undefined。在其他所有情况下,一个对象都不会等于 undefined null

    var num = 0;
    var obj = new String("0");
    var str = "0";
    var b = false;
    
    print(num == num); // true
    print(obj == obj); // true
    print(str == str); // true
    
    print(num == obj); // true
    print(num == str); // true
    print(obj == str); // true
    print(null == undefined); // true
    
    // both false, except in rare cases
    print(obj == null);
    print(obj == undefined);
    

    有些开发者认为,最好永远都不要使用相等操作符。全等操作符的结果更容易预测,并且因为没有隐式转换,全等比较的操作会更快。

    Same-value 相等

    Same-value 相等解决了最后一个用例确定两个值是否在任何情况下功能上是相同的。(这个用例演示了里氏替换原则的实例)当试图对不可变(immutable)属性修改时:

    // 向 Nmuber 构造函数添加一个不可变的属性 NEGATIVE_ZERO
    Object.defineProperty(Number, "NEGATIVE_ZERO",
                          { value: -0, writable: false, configurable: false, enumerable: false });
    
    function attemptMutation(v)
    {
      Object.defineProperty(Number, "NEGATIVE_ZERO", { value: v });
    }
    

    Object.defineProperty 在试图修改不可变属性时,如果这个属性确实被修改了则会抛出异常,反之什么都不会发生。例如如果 v 是 -0 ,那么没有发生任何变化,所以也不会抛出任何异常。但如果 v 是 +0 ,则会抛出异常。不可变属性和新设定的值使用 same-value 相等比较。

    Same-value 相等由 Object.is 方法提供。

    规范中的相等、严格相等以及 same-value 相等

    在 ES5 中, == 相等在 Section 11.9.3, The Abstract Equality Algorithm=== 相等在 11.9.6, The Strict Equality Algorithm。(请参考这两个链接,他们很简洁易懂。提示:请先阅读严格相等的算法)ES5 也提供了 same-value 相等, Section 9.12, The SameValue Algorithm ,用在 JS 引擎内部。除了 11.9.6.4 和 9.12.4 在处理数字上的不同外,它基本和严格相等算法相同。ES6 简单地通过  Object.is 暴露了这个算法。

    我们可以看到,使用双等或三等时,除了 11.9.6.1 类型检查,严格相等算法是相等算法的子集因为 11.9.6.2–7 对应 11.9.3.1.a–f。

    理解相等比较的模型

    在 ES6 以前,你可能会说双等和三等是“扩展”的关系。比如有人会说双等是三等的扩展版,因为他处理三等所做的,还做了类型转换。例如 6 == "6" 。反之另一些人可能会说三等是双等的扩展,因为他还要求两个参数的类型相同,所以增加了更多的限制。怎样理解取决于你怎样看待这个问题。

    但是这种比较的方式没办法把 ES6 的 Object.is 排列到其中。因为 Object.is 并不比双等更宽松,也并不比三等更严格,当然也不是在他们中间。从下表中可以看出,这是由于 Object.is 处理 NaN 的不同。注意假如 Object.is(NaN, NaN) 被计算成 false ,我们就可以说他比三等更为严格,因为他可以区分 -0+0 。但是对 NaN 的处理表明,这是不对的。 Object.is 应该被认为是有其特殊的用途,而不应说他和其他的相等更宽松或严格。

    判等
    x y == === Object.is
    undefined undefined true true true
    null null true true true
    true true true true true
    false false true true true
    "foo" "foo" true true true
    { foo: "bar" } x true true true
    0 0 true true true
    +0 -0 true true false
    0 false true false false
    "" false true false false
    "" 0 true false false
    "0" 0 true false false
    "17" 17 true false false
    [1,2] "1,2" true false false
    new String("foo") "foo" true false false
    null undefined true false false
    null false false false false
    undefined false false false false
    { foo: "bar" } { foo: "bar" } false false false
    new String("foo") new String("foo") false false false
    0 null false false false
    0 NaN false false false
    "foo" NaN false false false
    NaN NaN false false true

    什么时候使用 Object.is 或是三等

    总的来说,除了对待NaN的方式,Object.is唯一让人感兴趣的,是当你需要一些元编程方案时,它对待0的特殊方式,特别是关于属性描述器,即你的工作需要去镜像Object.defineProperty的一些特性时。如果你的工作不需要这些,那你应该避免使用Object.is,使用===来代替。即使你需要比较两个NaN使其结果为true,总的来说编写使用NaN 检查的特例函数(用旧版本ECMAScript的isNaN方法)也会比想出一些计算方法让Object.is不影响不同符号的0的比较更容易些。

    这里是一个会区别对待-0和+0的内置方法和操作符不完全列表:

    - (一元负)

    显而易见,对0一元负操作得到-0。但表达式的抽象化可能在你没有意识到得情况下导致-0延续传播。例如当考虑下例时:

    let stoppingForce = obj.mass * -obj.velocity
     

    如果obj.velocity0 (或计算结果为0), 一个-0就在上处产生并被赋值为stoppingForce的值.

    Math.atan2
    Math.ceil
    Math.pow
    Math.round
    即使传入的参数中没有-0,这些方法的返回值都有可能是-0。例如当用 Math.pow计算-Infinity的任何负奇指数的幂都会得到-0。详情请参见这些方法各自的文档。
    Math.floor
    Math.max
    Math.min
    Math.sin
    Math.sqrt
    Math.tan
    当传入参数中有-0时,这些方法也可能返回-0。例如, Math.min(-0, +0) 得出 -0。详情请参见这些方法各自的文档。
    ~
    <<
    >>
    这些操作符内部都使用了ToInt32算法。因为内部32位整数类型只有一个0(没有符号区别),-0的符号在反操作后并不会保留下来。例如Object.is(~~(-0), -0)Object.is(-0 << 2 >> 2, -0) 都会得到false.

    在未考虑0的符号的情况下依赖于Object.is是危险的。当然,如果本意就是区分-0和+0的话,Object.is能按照期望完成工作。

    参见

    文档标签和贡献者

    Contributors to this page: ziyunfei, ilia, tiansh, faceach, RenzHoly, fskuok, xufeng
    最后编辑者: xufeng,
    隐藏侧边栏