How to determine whether a phase is equal in JavaScript

How to determine equality in JavaScript: 1. Use the "==" or "!=" operator to compare whether the values ​​of the two operands are equal; 2. Use "===" or "! ==" operator, compares whether the values ​​of two operands are equal and checks whether their types are the same.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

JavaScript determines equality

In JavaScript, you can use ==, ===, !=, !== operator to determine equality or inequality

Equality detection operator	Description
==(Equal)	Compares whether the values ​​of two operands are equal
!= (don’t want to wait)	Compare whether the values ​​of the two operands are not equal
===(Congruent)	Compare whether the values ​​of the two operands are equal and check whether their types are the same
!== (not congruent)	Compare two operations Whether the values ​​of the numbers are not equal and whether their types are not the same

In the equality operation, you should pay attention to the following issues:

• If the operand is a Boolean value, it is converted to a numerical value first, where false is converted to 0 and true is converted to 1.

• If one operand is a string and the other operand is a number, try to convert the string to a number first.

• If one operand is a string and the other operand is an object, try to convert the object to a string first.

• If one operand is a number and the other operand is an object, try to convert the object to a number first.

• If both operands are objects, the reference addresses are compared. If the reference addresses are the same, they are equal; otherwise they are not equal.

Example 1

The following is an equality comparison of special operands.

console.log("1" == 1);  //返回true。字符串被转换为数字
console.log(true == 1);  //返回true。true被转换为1
console.log(false == 0);  //返回true。false被转换为0
console.log(null == 0);  //返回false
console.log(undefined == 0);  //返回false
console.log(undefined == null);  //返回true
console.log(NaN == "NaN");  //返回false
console.log(NaN ==1);  //返回false
console.log(NaN == NaN);  //返回false
console.log(NaN != NaN);  //返回true

NaN is not equal to any value, including itself. The null and undefined values ​​are equal, but they are different types of data. In equality comparisons, null and undefined are not allowed to be converted to values ​​of other types.

Example 2

The values ​​of the following two variables are equal.

var a = "abc" + "d";
var b = "a" + "bcd";
console.log(a == b);  //返回true

The equality comparison operation of numerical and Boolean values ​​is relatively efficient, while strings need to be compared character by character, and the equality comparison operation efficiency is relatively low.

In congruent operations, you should pay attention to the following issues:

• If both operands are simple values, as long as the values ​​are equal and the types are the same, Just equal.

• If one operand is a simple value and the other operand is a composite object, they are not congruent.

• If both operands are composite objects, compare whether the reference addresses are the same.

Example 3

The following is a congruent comparison of special operands.

console.log(null === undefined);  //返回false
console.log(0 === "0");  //返回false
console.log(0 === false);  //返回false

Example 4

The following is a comparison of two objects. Since they both refer to the same address, true is returned.

var a = {};
var b = a;
console.log(a === b);  //返回true

Although the following two objects have the same structure, they have different addresses, so they are not congruent.

var a = {};
var b = {};
console.log(a === b);  //返回false

Example 5

For composite objects, the reference address is mainly compared, and the value of the object is not compared.

var a = new String("abcd);  //定义字符串“abcd”对象
var b = new String("abcd);  //定义字符串“abcd”对象
console.log(a === b);  //返回false
console.log(a == b);  //返回false

In the above example, the values ​​of the two objects are equal, but the reference addresses are different, so they neither want to wait nor are they equal. Therefore, for composite objects, the results of the equality == and congruence === operations are the same.

Example 6

For simple values, as long as they have the same type and equal values, they are congruent, regardless of changes in the expression operation process or variables. reference address.

var a = "1" + 1;
var b = "11";
console.log(a ===b);  //返回true

Example 7

The expression (a>b || a==b) is not exactly equal to the expression (a>=b).

var a = 1;
var b = 2;
console.log((a > b || a == b) == (a >= b));  //返回true，此时似乎相等

If the variables a and b are assigned null and undefined respectively, the return value false indicates that the two expressions are not completely equivalent.

var a = null;
var b = undefined;
console.log((a > b || a == b) == (a >= b));  //返回false，表达式的值并非相等

Because null == undefined is equal to true, the return value of the expression (a > b || a == b) is true, but the return value of the expression null >= undefined is false.

[Related recommendations: javascript learning tutorial]

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