La différence entre le jugement d'égalité ===, == et Object.is() en js

Je crois que les personnes qui sont nouvelles sur JS seront déconcertées par son jugement d'égalité. Jetez un œil au code suivant. À combien pouvez-vous répondre correctement ?

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 propose trois opérations de comparaison de valeurs différentes, à savoir l'égalité stricte, l'égalité assouplie et Object.is. Après avoir vérifié les informations aujourd'hui, j'espère que le contenu suivant pourra être utile à tout le monde. . S'il y a des erreurs, vous pouvez me corriger.

[Recommandations de cours associées : Tutoriel vidéo JavaScript]

1. Égalité stricte x === y logique de jugement

1 Si le type de données de x est différent du type de données de y, renvoie false

2. tapez

gir x est NaN, renvoie faux

gi y est NaN, renvoie faux

gi La valeur de x est égale à la valeur de y, renvoie vrai

● x est +0, y est -0, renvoie vrai

● x est -0, y est +0, renvoie vrai

● sinon renvoie faux

3. Autres Référence de type SameValueNonNumber(x, y)

● Assertion : x, y n'est pas de type Nombre

● Assertion : x, y ont le même type de données ; >

● x n'est pas défini, y n'est pas défini, renvoie vrai ;

● x est nul, y est nul, renvoie vrai ;

● x est un type de chaîne, si et seulement si les séquences de caractères de x et y sont exactement les mêmes. En même temps (même longueur et mêmes caractères à chaque position), renvoie true, sinon renvoie false

● Si x est un type booléen, renvoie true ; lorsque x et y sont tous deux vrais ou faux, sinon renvoie faux

● Si x est un type de symbole, lorsque x et y sont la même valeur de symbole, renvoie vrai, sinon renvoie faux

● Si x, y sont la même valeur d'objet, renvoie vrai, sinon renvoie faux ;

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

2 Égalité relâchée x == y

1 Si x. Et y sont du même type, return x===y Le résultat de. Si x est une valeur numérique et y est une chaîne, return x == ToNumber(y);

5 Si x est. une chaîne et y est une valeur numérique, renvoie ToNumber(x) == y;

6 Si x est un type booléen, renvoie le résultat de ToNumber(x)==y;

7. Si y est un type booléen, renvoie le résultat de x==ToNumber(y);

8 Si x est l'un des éléments suivants : String, Number ou Symbol et Type(y) est Object, renvoie le résultat. résultat de x==ToPrimitive(y)

9. Si Type(x) est un objet et que Type(y) est l'un des éléments suivants : chaîne, nombre ou symbole, renvoie le résultat de ToPrimitive(x)==y

10. D'autres renvoient false

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

Remarque :

Number(null) === 0

Mais

null == 0 // false,

2.1 ToNumber convertit une valeur en un type numérique

1. S'il s'agit d'un type booléen, true renvoie 1 et false renvoie 0 ;

2. S'il s'agit d'une valeur numérique, elle est simplement transmise et renvoyée ; >

3. S'il est nul, il renvoie 0

4 S'il n'est pas défini, il renvoie NaN;S'il s'agit d'une chaîne, si la chaîne ne contient que. nombres, convertissez-le en nombre décimal ; s'il s'agit d'un format à virgule flottante valide, convertissez-le en la valeur à virgule flottante correspondante ; s'il est binaire ou hexadécimal, convertissez-le en la valeur décimale correspondante

6. c'est un objet, appelez la méthode valueOf() de l'objet, puis convertissez selon les règles précédentes. Si la valeur de retour valueOf est NaN, appelez la méthode toString(), puis convertissez la chaîne renvoyée

<.> selon les règles précédentes 2.2 ToPrimitive

toPrimitive(A) en essayant d'appeler les méthodes A.toString() et A.valueOf( ), convertir le paramètre A en une valeur primitive (Primitive) ;

Les types primitifs en JS incluent : Number, String, Boolean, Null, Undefined ;

Méthode valueOf() pour différents types d'objets Valeur de retour :

// 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教程 栏目，欢迎学习！  

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!