# Equality (==)

## 在此页

The equality operator ( ``` == ``` ) checks whether its two operands are equal, returning a Boolean result. Unlike the strict equality operator, it attempts to convert and compare operands that are of different types.

## 句法

```x == y
```

## 描述

The equality operators ( ``` == ``` and ``` != ``` ) use the Abstract Equality Comparison Algorithm to compare two operands. This can be roughly summarised as follows:

• If the operands are both objects, return ``` true ``` only if both operands reference the same object.
• If one operand is ``` null ``` and the other is ``` undefined ``` , return ``` true ``` .
• If the operands are of different types, try to convert them to the same type before comparing:
• When comparing a number to a string, try to convert the string to a numeric value.
• If one of the operands is ``` Boolean ``` , convert the Boolean operand to 1 if it is ``` true ``` and +0 if it is ``` false ``` .
• If one of the operands is an object and the other is a number or a string, try to convert the object to a primitive using the object's ``` valueOf() ``` and ``` toString() ``` 方法。
• If the operands have the same type, they are compared as follows:
• ``` String ``` : return ``` true ``` only if both operands have the same characters in the same order.
• ``` Number ``` : return ``` true ``` only if both operands have the same value. ``` +0 ``` and ``` -0 ``` are treated as the same value. If either operand is ``` NaN ``` , return ``` false ``` .
• ``` Boolean ``` : return ``` true ``` only if operands are both ``` true ``` or both ``` false ``` .

The most notable difference between this operator and the strict equality ( ``` === ``` ) operator is that the strict equality operator does not attempt type conversion. Instead, the strict equality operator always considers operands of different types to be different.

## 范例

### Comparison with no type conversion

```1 == 1;              // true
"hello" == "hello";  // true
```

### Comparison with type conversion

```"1" ==  1;            // true
1 == "1";             // true
0 == false;           // true
0 == null;            // false
0 == undefined;       // false
0 == !!null;          // true, look at Logical NOT operator
0 == !!undefined;     // true, look at Logical NOT operator
null == undefined;    // true
const number1 = new Number(3);
const number2 = new Number(3);
number1 == 3;         // true
number1 == number2;   // false
```

### Comparison of objects

```const object1 = {"key": "value"}
const object2 = {"key": "value"};
object1 == object2 // false
object2 == object2 // true
```

### Comparing strings and String objects

Note that strings constructed using ``` new String() ``` are objects. If you compare one of these with a string literal, the ``` String ``` object will be converted to a string literal and the contents will be compared. However, if both operands are ``` String ``` objects, then they are compared as objects and must reference the same object for comparison to succeed:

```const string1 = "hello";
const string2 = String("hello");
const string3 = new String("hello");
const string4 = new String("hello");
console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true
```

### Comparing Dates and strings

```const d = new Date('December 17, 1995 03:24:00');
const s = d.toString(); // for example: "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
console.log(d == s);    //true
```

## 浏览器兼容性

 Desktop Mobile Server Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome for Android Firefox for Android Opera for Android Chrome 1 Edge 12 Firefox 1 IE 3 Opera 3 Safari 1 WebView Android 1 Chrome Android 18 Firefox Android 4 Opera Android 10.1 Safari iOS 1 Samsung Internet Android 1.0 nodejs 0.1.100

## 另请参阅

1. JavaScript
2. 教程：
3. 完整初学者
4. JavaScript 指南
5. 中间体
6. 高级
7. 参考：
8. 内置对象
9. 表达式 & 运算符
10. 语句 & 声明
11. 函数
12. 错误
13. 杂项