Comment déterminer si les variables sont égales en javascript

Méthode de jugement : 1. Utilisez l'opérateur d'égalité "==" ou "==="; 2. Utilisez la méthode toString() dans le tableau ; ; 4, utilisez d'abord "JSON.stringify()" pour convertir l'objet ou le tableau en type chaîne, puis utilisez "===" pour la comparaison d'égalité.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

Façons de juger si les variables sont égales

Pour juger si les variables sont égales, il existe à peu près les manières suivantes

• == et === ;
• utilise la méthode toString dans le tableau ; la méthode
• ES6 dans la méthode Object.is ; > utilise
, converti en type
• pour comparer JSON.stringifyString

et ===== sont des opérateurs de comparaison de types de conversion,

est un opérateur de comparaison strict Lorsque les types de données sont identiques, l'utilisation de

ne pose généralement pas de problèmes. ==

let num = 5;
let num2 = 5;

num == num2;//true
num === num2;//true

===Mais lorsque les types de données sont incohérents, == effectuera une conversion de type implicite.

let num = 5;
let str = '5';

num == str;//true
num === str;//false

'' == false;//true
'' === false;//false

null == undefined;//true
null === undefined;//false

Le type de conversion implicite peut apporter une certaine commodité, mais il peut également provoquer ==, il est donc plus recommandé d'utiliser

à des fins de comparaison, ce qui est l'une des raisons pour lesquelles

est populaire. 不易发现的bug===De plus, les listes ci-dessus sont toutes des comparaisons de types de données de base, et il y aura certaines limitations lors de l'utilisation de TS pour comparer les types de référence.

let a = {xx: 1};
let b = a;

a === b;//true

let c = {xx: 1};
let d = {xx: 1};

c === d;//false

Lors de la comparaison des types de référence, === compare si les références des variables sont les mêmes,

, et lorsque les références sont différentes,

sera renvoyé. ===而非值On peut voir que false n'est pas une solution miracle infaillible. Pour comparer si des objets sont égaux, d'autres méthodes plus fiables sont nécessaires.

[Apprentissage recommandé : ===Tutoriel avancé javascript

]

Méthode Array toString

Le front-end est donné à l'arrière Lors du passage des paramètres depuis la fin, le backend nécessite parfois que plusieurs paramètres soient séparés par , donc la méthode

est plus utile. Cette méthode peut également être utilisée pour la comparaison de tableaux.

let arr = [1,3,5,7,9];
let arr2 = [1,3,5,7,9];

arr.toString() === arr2.toString();//true "1,3,5,7,9"

, Cependant, il existe certaines limitations. Il ne peut pas être utilisé pour comparer des tableaux à deux dimensions et plus, et il ne peut pas contenir Array toString,

,

, null, etc. sinon, il est facile de faire des erreurs, comme suit undefined

[1,3,5,[2,4,6]].toString();//"1,3,5,2,4,6"
[1,null,undefined,'',2].toString();//"1,,,,2"
[{xx:2},window,1,2].toString();//"[object Object],[object Window],1,2"

objectfunction

La méthode Object.is

est une nouvelle méthode dans ES6 It. est très similaire à

et est également utilisé Compare deux valeurs pour l'égalité. La différence entre

Object.is(1,1);//true
Object.is('str','str');//true
Object.is({},{});//false

Object.is est la différence entre juger === et

,

et +0. -0

+0 === -0 //true
NaN === NaN //false

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

NaNEn cas de problèmes de compatibilité, polyfill peut être écrit comme ceci. La méthode NaN

if (!Object.is) {
  Object.is = function(x, y) {
    if (x === y) {
      // 针对+0 不等于 -0的情况
      return x !== 0 || 1 / x === 1 / y;
    } else {
     // 针对NaN的情况
      return x !== x && y !== y;
    }
  };
}

JSON.stringify

est utilisée pour convertir un objet ou un tableau en une chaîne JSON, et la chaîne résultante Il peut être utilisé pour comparer des objets.

let obj = {name: 'lin', age: 24};
let obj2 = {name: 'lin', age: 24};

obj === obj2;//false
JSON.stringify(obj) === JSON.stringify(obj2);//true

JSON.stringify compense la limitation selon laquelle

ne peut pas comparer avec précision les objets, mais il a également certaines limitations et sera ignoré lors de la rencontre des valeurs

, JSON.stringify et ===. undefinedfunctionDe plus, il convient de mentionner que l'utilisation de symbol et

peut réaliser une copie approfondie d'objet, avec les mêmes limitations que ci-dessus.

JSON.parseJSON.stringify

Quand les utiliser

Différents scénarios peuvent avoir des exigences différentes Si vous comparez uniquement les types de données de base, alors C'est suffisant. . Si vous souhaitez "

", alors il faut sans doute payer un certain coût pour utiliser une méthode personnalisée.

===Dans le développement répété quotidien, vous devez encore explorer davantage. 一劳永逸

Pour plus de connaissances sur la programmation, veuillez visiter :

Vidéo de programmation

 ! !

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!