Der Unterschied zwischen Gleichheitsbeurteilung ===, == und Object.is() in js

Ich glaube, dass Leute, die neu bei JS sind, durch das Gleichheitsurteil verwirrt sein werden. Schauen Sie sich den folgenden Code an.

NaN === NaN // false
NaN == NaN // false
Object.is(NaN, NaN) // true
0 == false  // true
1 == true   // true
Number(null) === 0  // true
null == 0   // false

Javascript bietet drei verschiedene Wertevergleichsoperationen, nämlich strikte Gleichheit, entspannte Gleichheit und Object.is. Ich hoffe, dass der folgende Inhalt für alle hilfreich sein kann Hilfe. Wenn es Fehler gibt, können Sie mich gerne korrigieren.

[Verwandte Kursempfehlungen: JavaScript-Video-Tutorial]

1. Strikte Gleichheit x === y-Beurteilungslogik

1 Wenn sich der Datentyp von x vom Datentyp von y unterscheidet, wird „falsch“ zurückgegeben.

2 Typ

● x ist NaN, gibt „false“ zurück

● y ist NaN, gibt „false“ zurück

● Der Wert von x ist gleich dem Wert von y, gibt „true“ zurück

● x ist +0, y ist -0, gibt true zurück

● x ist -0, y ist +0, gibt true zurück

● Andernfalls wird false zurückgegeben

3. Andere Typreferenz SameValueNonNumber(x, y)

● Behauptung: x, y ist kein Zahlentyp;

● Behauptung: x, y haben den gleichen Datentyp

● x ist undefiniert, y ist undefiniert, Rückgabe wahr;

● x ist null, y ist null, Rückgabe wahr;

● x ist genau dann ein Zeichenfolgentyp wenn die Zeichenfolgen von x und y gleichzeitig vollständig konsistent sind (gleiche Länge und gleiche Zeichen an jeder Position), geben Sie true zurück, andernfalls geben Sie false zurück.

● Wenn x ein boolescher Typ ist, geben Sie true zurück wenn x und y beide wahr oder falsch sind, sonst Rückgabe falsch; >● Wenn x, y der gleiche Objektwert sind, wird true zurückgegeben, andernfalls wird false zurückgegeben;

NaN === NaN // false
undefined === undefined // true
null === null   // true
undefined === null  // false

2 Entspannte Gleichheit x == y

1 und y vom gleichen Typ sind, geben Sie x===y zurück. Wenn x ein numerischer Wert und y eine Zeichenfolge ist, geben Sie x == ToNumber(y);5 zurück eine Zeichenfolge und y ein numerischer Wert ist, geben Sie ToNumber(x) == y;

6 zurück. Wenn x ein boolescher Typ ist, geben Sie das Ergebnis von ToNumber(x)==y;

<🎜 zurück >7. Wenn y ein boolescher Typ ist, geben Sie das Ergebnis von x==ToNumber(y);

8 zurück. Wenn x einer von String, Number oder Symbol ist und Type(y) Object ist, geben Sie das zurück Ergebnis von x==ToPrimitive(y)

9. Wenn Type(x) ein Objekt ist und Type(y) entweder String, Number oder Symbol ist, wird das Ergebnis von ToPrimitive(x)==y< zurückgegeben 🎜>

10. Andere geben false zurück

12 == '0xc' // true, 0xc是16进制
12 == '12'  // true
12 == '12c' // false, 说明ToNumber转换是用的Number()方法

Hinweis:

Number(null) === 0

Aber

null == 0 // false,

2.1 ToNumber konvertiert einen Wert in einen numerischen Typ

1. Wenn es sich um einen booleschen Typ handelt, gibt „true“ 1 zurück und „false“ gibt 0 zurück. Wenn es sich um einen numerischen Wert handelt, wird er einfach übergeben und zurückgegeben >

3. Wenn es null ist, wird 0 zurückgegeben.

4 Wenn es undefiniert ist, wird NaN zurückgegeben.

5 Zahlen, konvertieren Sie es in eine Dezimalzahl; wenn es ein gültiges Gleitkommaformat ist, konvertieren Sie es in den entsprechenden Gleitkommawert; wenn es sich um einen Binär- oder Hexadezimalwert handelt Wenn es sich um ein Objekt handelt, rufen Sie die valueOf()-Methode des Objekts auf und konvertieren Sie dann gemäß den vorherigen Regeln. Wenn der valueOf-Rückgabewert NaN ist, rufen Sie die toString()-Methode auf und konvertieren Sie dann die zurückgegebene Zeichenfolge

gemäß den vorherigen Regeln 2.2 ToPrimitive

toPrimitive(A) indem versucht wird, die Methoden A.toString() und A.valueOf() aufzurufen, Parameter A in einen primitiven Wert (Primitive) umwandeln;

Zu den primitiven Typen in JS gehören: Number, String, Boolean, Null, Undefiniert;

valueOf()-Methode für verschiedene Objekttypen. Rückgabewert:

// Array：返回数组对象本身
var array = ["ABC", true, 12, -5];
console.log(array.valueOf() === array);   // true
// Date：当前时间距1970年1月1日午夜的毫秒数
var date = new Date(2013, 7, 18, 23, 11, 59, 230);
console.log(date.valueOf());   // 1376838719230
// Number：返回数字值
var num =  15.26540;
console.log(num.valueOf());   // 15.2654
// 布尔：返回布尔值true或false
var bool = true;
console.log(bool.valueOf() === bool);   // true
// new一个Boolean对象
var newBool = new Boolean(true);
// valueOf()返回的是true，两者的值相等
console.log(newBool.valueOf() == newBool);   // true
// 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型
console.log(newBool.valueOf() === newBool);   // false
// Function：返回函数本身
function foo(){}
console.log( foo.valueOf() === foo );   // true
var foo2 =  new Function("x", "y", "return x + y;");
console.log( foo2.valueOf() );
/*
ƒ anonymous(x,y
) {
return x + y;
}
*/
// Object：返回对象本身
var obj = {name: "张三", age: 18};
console.log( obj.valueOf() === obj );   // true
// String：返回字符串值
var str = "http://www.xyz.com";
console.log( str.valueOf() === str );   // true
// new一个字符串对象
var str2 = new String("http://www.xyz.com");
// 两者的值相等，但不全等，因为类型不同，前者为string类型，后者为object类型
console.log( str2.valueOf() === str2 );   // false

3.同值相等

同值相等由 Object.is 方法判断：

● 两个值都是 undefined

● 两个值都是 null

● 两个值都是 true 或者都是 false

● 两个值是由相同个数的字符按照相同的顺序组成的字符串

● 两个值指向同一个对象

● 两个值都是数字并且

○ 都是正零 +0，

○ 或者都是负零 -0，

○ 或者都是 NaN

○ 都是除零和 NaN 外的其它同一个数字

Object.is('foo', 'foo');     // true
Object.is(window, window);   // true
Object.is('foo', 'bar');     // false
Object.is([], []);           // false
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo);         // true
Object.is(foo, bar);         // false
Object.is(null, null);       // true
Object.is(true, 'true')     // false
// 特例
Object.is(0, -0);            // false
Object.is(0, +0);            // true
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

4.零值相等

与同值相等类似，不过会认为 +0 与 -0 相等。

小结

=== 不做类型转换，当两边的数类型不相同时，直接返回false；当前类型相同且都是数值类型的时候，有一个是NaN，那么结果就是false, 另外 +0 === -0

==运算符，当两边操作数类不相同时会做隐式转换，然后才进行比较，这样的话就会出现 false == 0, '' == false 等现象， 但是Object.is不会做这种转换

本文来自 js教程 栏目，欢迎学习！  

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen Gleichheitsbeurteilung ===, == und Object.is() in js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!