How to determine whether variables are equal in javascript

Judgment method: 1. Use the equality operator "==" or "==="; 2. Use the toString() method in the array; 3. Use the "Object.is()" method; 4 , first use "JSON.stringify()" to convert the object or array into a string type, and then use "===" for equality comparison.

The operating environment of this tutorial: Windows 7 system, ECMAScript version 6, Dell G3 computer.

Ways to determine whether variables are equal

To determine whether variables are equal, there are roughly the following ways

• == and ===;
• Use the toString method in the array;
• in ES6 The Object.is method;
• uses JSON.stringify to convert to String type for comparison;

== and ===

##== are conversion type comparison operations operator, === is a strict comparison operator. When the data types are the same, using == will generally not cause problems.

let num = 5;
let num2 = 5;

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

But when the data types are inconsistent,

== will do some implicit type conversion.

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

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

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

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

Implicit conversion type can bring some convenience, but it may also cause

bugs that are not easy to find, so it is more recommended to use === for comparison , which is one of the reasons why TS is popular.

In addition, the above lists are all comparisons of basic data types, and there will be certain limitations when using

=== to compare reference types.

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

a === b;//true

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

c === d;//false

When comparing reference types,

=== compares whether the reference of the variable is the same, rather than the value . When the reference is different, # will be returned ##false. It can be seen that

===

is not a silver bullet that is invincible. When comparing whether objects are equal, other more reliable methods are needed. [Recommended learning:

javascript advanced tutorial

]

Array toString methodThe front end is given to the back end When passing parameters from the end, the backend sometimes requires multiple parameters separated by

and

. The Array toString method is more useful. This method can also be used for array comparison. <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:php;toolbar:false;'>let arr = [1,3,5,7,9]; let arr2 = [1,3,5,7,9]; arr.toString() === arr2.toString();//true &quot;1,3,5,7,9&quot;</pre><div class="contentsignin">Copy after login</div></div> However, there are certain limitations. It cannot be used to compare arrays of two dimensions and above, and it cannot contain

null

, undefined, and object##. #, function, etc., otherwise it is easy to make errors, as follows

[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"

Object.is method

Object. is

is a new method in ES6. It is very similar to

=== and is also used to compare whether two values ​​are equal.

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

The difference is in judging 0

and

-0, NaN and NaN.

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

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

When dealing with compatibility issues, polyfill can be written like this.

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

JSON.stringify

method is used to convert an object or array into a JSON string , the resulting string can be used for object comparison.

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

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

JSON.stringify

makes up for the limitation that

=== cannot accurately compare objects, but it also has certain limitations. When encountering undefined, function and symbol values ​​are ignored. In addition, it is worth mentioning that using JSON.parse

and

JSON.stringify can realize object deep copy, with the same limitations as above.

When to use them

Different scenarios may have different requirements. If only basic data types are compared, then ===

is enough. If you want to "

Once and for all", then it is undoubtedly necessary to pay a certain cost to use a custom method. In the daily repeated development, you still need to explore more.

For more programming related knowledge, please visit:

Programming Video

! !

The above is the detailed content of How to determine whether variables are equal in javascript. For more information, please follow other related articles on the PHP Chinese website!