Object.is vs ===

2020/11/16 08:22 · javascript ·  · 0评论

我偶然发现了使用此比较的代码示例:

var someVar = 0;
Object.is(false, someVar); //Returns false 

我知道false == 0会是true这就是为什么我们有===

如何Object.is不同===

===在JavaScript中被称为严格比较运算符。Object.is和严格的比较运算符的行为完全一样,除了NaN+0/-0

从MDN:

Object.is()方法不同于等于===运算符的相等方法===操作者(和==操作员以及)对待数值-0和0为相等和治疗Number.NaN为不等于NaN

以下代码突出显示了===之间的区别Object.is()

console.log(+0 === -0); //true
console.log(Object.is(+0, -0)); //false

console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); //true

console.log(Number.NaN === Number.NaN); // false
console.log(Object.is(Number.NaN, Number.NaN)); // true

console.log(NaN === Number.NaN); // false
console.log(Object.is(NaN, Number.NaN)); // true

在此处输入图片说明

您可以在此处找到更多示例

注意Object.is是ECMAScript 6提案的一部分,尚未得到广泛支持(例如,任何版本的Internet Explorer或许多其他浏览器的较早版本均不支持它)。但是,您可以将polyfill用于非ES6浏览器,可以在上面给出的链接中找到。

Object.is使用规范的SameValue算法,而===使用严格相等算法关于严格平等算法的注释指出了区别:

该算法与SameValue算法不同...在处理带符号的零和NaN方面。

注意:

  • NaN === NaN是错误的,但是Object.is(NaN, NaN)真实的
  • +0 === -0是真的,但是Object.is(+0, -0)错误的
  • -0 === +0是真的,但是Object.is(-0, +0)错误的

JavaScript至少具有四种“平等”:

  • “松散”(==),将强制操作数尝试使其匹配。规则已明确规定,但并非显而易见。"" == 0true;"true" == truefalse,...)。
  • “严格”(===),其中不同类型的操作数将不会被强制转换(并且将不相等),但是请参见上面的注释NaN以及正零和负零。
  • SameValue-如上所述(由所使用Object.is)。
  • SameValueZero-与SameValueexcept类似+0-0并且相同,而不是不同(用于Map键和Array.prototype.includes)。

还存在对象对等,这不是语言或运行时本身提供的,而是通常表示为:对象具有相同的原型,相同的属性,并且它们的属性值相同(通过合理的“相同”定义) )。


SameValue算法

  • 如果Type(x)与Type(y)不同,则返回false。
  • 如果Type(x)是Number,则

    • 如果x为NaN而y为NaN,则返回true。
    • 如果x为+ 0,y为-0,则返回false。
    • 如果x为-0,y为+0,则返回false。
    • 如果x与y相同,则返回true。
    • 返回false。
  • 返回SameValueNonNumber(x,y)。

...其中SameValueNonNumber为:

  • 断言:Type(x)不是Number。
  • 断言:Type(x)与Type(y)相同。
  • 如果Type(x)为Undefined,则返回true。
  • 如果Type(x)为Null,则返回true。
  • 如果Type(x)为String,则

    • 如果x和y是完全相同的代码单元序列(在相同的索引处具有相同的长度和相同的代码单元),则返回true;否则,返回true。否则,返回false。
  • 如果Type(x)为布尔值,则

    • 如果x和y均为true或均为false,则返回true;否则,返回true。否则,返回false。
  • 如果Type(x)是Symbol,则

    • 如果x和y都是相同的Symbol值,则返回true;否则,返回true。否则,返回false。
  • 如果x和y是相同的Object值,则返回true。否则,返回false。

严格平等算法

  1. 如果Type(x)与Type(y)不同,则返回false。
  2. 如果Type(x)是Number,则

    • 如果x为NaN,则返回false。
    • 如果y为NaN,则返回false。
    • 如果x与y相同,则返回true。
    • 如果x为+ 0,y为-0,则返回true。
    • 如果x为-0,y为+0,则返回true。
    • 返回false。
  3. 返回SameValueNonNumber(x,y)。
Object.is = function(v1, v2){
  //test for `-0`
  if(v1 === 0 && v2 === 0) {
    return 1 / v1 === 1 / v2;
  }
  
  //test for `NaN`
  if(v1 !== v1) {
    return v2 !== v2;
  }
  
  //everything else
  return v1 === v2;
}

The above is the polyfill function to show how Object.is works, for anyone who are interested to know. A reference to You-Don't-Know-JS

Summary:

The Object.is() function takes 2 values as arguments and returns true if the 2 given values are exact the same, otherwise it will return false.

Why do we need this?

You might think, we already have strict equality (checks type + value) checking in javascript with the === operator, why do we need this function? Well strict equality isn't sufficient in some cases and they are the following:

console.log(NaN === NaN);   // false
console.log(-0 === +0);     // true

Object.is() helps us by being able to compare these values to see if they are similar, something the strict equality operator cannot do.

console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(-0, 0));     // false
console.log(Object.is(+0, +0));    // true
console.log(Object.is(+0, -0));    // false

In a nutshell, they are similar, but Object.is is smarter and more accurate...

Let's look at this...

+0 === -0 //true

But this is not fully right as it ignores - and + before...

Now we use:

Object.is(+0, -0) //false

As you see, this is more accurate to compare.

Also in case of NaN that works more like correct, as consider any NaN the same.

本文地址:http://javascript.askforanswer.com/object-is-vs.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!