卡卡网

在本文中，我们将详细讨论javascript中的等式和不等式运算符，它们是松散相等 ( == ) 和严格相等运算符 ( === )，我们还将学习javascript中==和===运算符之间的区别。

在 Javascript 中，为了比较两个值，我们使用比较运算符。存在一种比较的特殊情况，其中比较两个值并确定这些值是否相等（或不相等）。在这种情况下，我们可以在 javascript 中使用以下两个运算符：

• == 运算符。
• === 运算符。

注意：要检查两个值是否不相等，我们将第一个等号 (=) 替换为感叹号 (!)。因此!=和!==运算符分别用于检查两个值的不等性。

在了解 JavaScript 中 == 和 === 之间的区别之前，让我们看看 JavaScript 中的 == 和 !== 运算符是什么。

JavaScript中的==和!=是什么？

javascript 中的==和!=运算符用于比较两个值。==运算符检查两个值是否相等。!=运算符检查两个值是否不相等。它也被称为松散相等运算符，因为它检查抽象相等，即当两个操作数不是相同的数据类型时，它倾向于转换操作数的数据类型以便进行比较。

句法

对于==：

x == y

对于!=：

x != y

其中 x 和 y 是操作数，中间部分用于运算符。在相等比较的情况下，我们使用 == 运算符，在不等比较的情况下，我们使用 != 运算符。

返回类型：布尔值。它要么返回true要么返回false。

如果两个操作数具有相同的数据类型并且具有相同的值，或者如果它们具有不同的数据类型，但是它们中的任何一个都可以转换为另一个操作数的数据类型并且具有相同的值，则==运算符返回true 。如果两个操作数的值不同，则返回false。

如果两个操作数具有相同的数据类型和不同的值，或者如果两者具有不同的数据类型并且它们都不能与另一个操作数的类型进行比较，则! =运算符返回true 。如果两个操作数具有相同的数据类型并具有相同的值，或者两者具有不同的数据类型但其中一个可以转换为另一个操作数的数据类型并具有相同的值，则返回false。

注意： == 或 != 运算符在比较元素之前对元素进行类型转换。

什么是类型转换？

==和!=运算符松散地比较两个操作数，即在比较两个操作数时，如果两个操作数的数据类型不同，则运算符倾向于将它们中的任何一个转换为其他操作数的类型，然后比较它们的值。

这是 Javascript 中 == 和 === 之间最重要的区别之一。

例子：

如果我们要比较两个值，一个字符串和另一个数字，那么它会将字符串值转换为数字类型，然后比较值。

let a = 10;
let b = '10';

console.log(a == b); //true

在上面的例子中，b被运算符转换为数字类型，然后与a进行比较。由于a和b的数值相同，所以输出true。

当两个操作数属于同一类型时 == 和 != 运算符的行为

当要比较的两个操作数属于同一类型时，==和!=运算符的行为方式如下： 

如果两者都是数字数据类型，则==运算符将在两者保持相同值时返回 true，否则返回 false。!=运算符反之亦然。

例子：

let a = 10;
let b = 10;
let c = -10;

console.log(a==b); //true
console.log(a==c); //false
console.log(b!=c); //true
console.log(a!=b); //false

在上面的例子中，第一个输出为真，因为 a 和 b 的值相同，第二个输出为假，因为 a 和 c 有不同的符号。同样，第三个输出为真，因为 b 和 c 不相同，第四个输出为真，因为 a 和 b 相同。

如果一个数字与 NaN 比较，它仍然会为==运算符输出 false。

如果两个操作数都是字符串类型，那么只有当第一个操作数的每个元素与第二个操作数的每个元素匹配时，==运算符才会返回 true。!=运算符反之亦然。

let str1 = 'Javascript';
let str2 = 'Javascript';
let str3 = 'JavaScript';

console.log(str1 == str2); //true
console.log(str1 == str3); //false
console.log(str1 != str3); //true

在上面的例子中，第一个输出为真，因为 str1 和 str2完全相同，但第二个输出为假，因为 str1 和 str3 不完全相同。第三个输出为真，因为 str1 和 str3 不相同。

因此，我们可以得出结论，比较也是区分大小写的。

如果两个操作数都是布尔类型，那么==运算符只有在两个操作数都是true时才会返回 true ，否则它将返回 false 。!=运算符反之亦然。

bool a = false;
bool b = true;
bool c = true;
bool d = false;

console.log(b == c); //true
console.log(b == a); //false
console.log(a == d); //true
console.log(b != d); //true
console.log(b != c); //false

== 和 != 运算符在两个操作数的类型不同时的行为

当操作数的类型不相同时，==和!=运算符使用抽象相等比较算法来比较两个两个操作数。该算法放松了检查，并在执行任何操作之前尝试将操作数修改为相同的类型。

以下是当操作数类型不同时==和!=行为的亮点：

• 如果我们正在比较string和number，则在比较之前将 string 转换为 number。
• 如果我们比较布尔值和数字（0 或 1），那么它会将0 视为 false并将1 视为 true。
• 如果我们正在比较两个对象，那么操作员将检查两者是否引用同一个对象。如果是，则==运算符将返回 true，!=将返回 false，否则==将返回 false，!=将返回 true。
• 如果我们比较null和undefined，那么==运算符将返回 true，!=运算符将返回 false。

例子：

//示例 1: 比价字符串和数字
10 == '10'    //true
10 == '99'    //false
10 != '99'    //true
10 != '10'    //true

//示例 2: 比较布尔值和数字
true == 1    //true
true == 0    //false
false != 1   //true
false != 0   //false

//示例 3: 比较 null 和 undefined
let a = null;
let b;

console.log(a == b);
//output: true

//示例 4: 比较对象
let car1 = {
    name: "Maruti"
}

let car2 = {
    name: "Maruti"
}

console.log(car1 == car1);
//true

console.log(car1 == car2);
//false

console.log(car1 != car1);
//false

console.log(car1 != car2);
//true

示例 1： 在此示例中，第一个操作数是数字类型，第二个操作数是字符串类型。==运算符将字符串类型转换为数字。

第一个输出为真，因为 10 和 10 相等，因此==运算符输出为真，第二个输出为假，因为 10 和 99 不相等。

第三个输出为真，因为 10 和 99 不相等，因此!=运算符的输出为真，第四个输出为假，因为 10 和 10 相等。

示例 2： 在此示例中，第一个操作数是布尔类型，第二个操作数是数字类型（0 或 1）。==运算符将数字类型转换为布尔值。

第一个输出为真，因为真和 1 相等（因为 1 被认为是真，0 被认为是假），因此==运算符的输出为真，第二个输出为假，因为真和 0 不相等。

第三个输出为真为假，1 不相等（1 为真，0 为假），因此!=运算符的输出为真，第四个输出为假为假，0 相等。

示例 3： 它输出true，因为==运算符 null 和 undefined 的比较为 true。

示例 4： 在最后一个示例中，第一个输出为true，因为 car1 和 car1 引用同一个实例，而第二个输出为false，因为 car1 和 car2 引用不同的实例。

JavaScript中的===和!==是什么？

===运算符称为严格相等运算符（而! ==称为严格不等运算符）。===运算符遵循严格相等比较算法，即在比较它们的值之前不进行操作数的类型转换并且即使操作数的数据类型不同也返回 false。

句法

对于平等：

x === y

对于不平等：

x !== y

其中 x 和 y 是操作数，中间部分用于运算符。在相等比较的情况下，我们使用 === 运算符，在不等比较的情况下，我们使用 !== 运算符。

返回类型： 布尔值。它返回true或false。

===运算符比较操作数，如果两个操作数具有相同的数据类型并具有某个值，则返回true，否则返回false。

!==运算符比较操作数，如果两个操作数属于不同的数据类型或属于相同的数据类型但具有不同的值，则返回true 。如果两个操作数具有相同的数据类型并且具有相同的值，则返回false。

注意：与==运算符不同，===不进行类型转换。

例子：

let a = 10;
let b = '10';
let c = 10;

console.log(a===b); //false;
console.log(a===c); //true;

这里第一个输出为假，因为 a 是数字类型，而 b 是字符串类型，第二个输出为真，因为 a 和 c 具有相同的数据类型和值。

===和!==运算符遵循严格的相等比较算法来比较两个操作数。

以下是严格相等比较算法的一些亮点：

• 如果我们要比较的操作数属于不同的数据类型，则返回false。
• 如果我们要比较的两个操作数中的任何一个是NaN，那么它将返回false。
• 如果我们要比较的操作数是null或undefined，那么它将返回true。
• 如果我们要比较的操作数是对象，那么如果两者都引用同一个对象，它将返回true，否则将返回false。

例子： 

//示例 1: 当两个操作数是不同的数据类型
34 === '34'    //false
34 !== '34'    //true

//示例 2: 当其中一个操作数是 NaN
let a = NaN;
let b = 10;

a === b        //false
a !== b        //true

//示例 3: 当两操作数是 null 或 undefined
null === null             //true
undefined === undefined   //true
null === undefined        //false

//示例 4: 当两个操作数是一个对象
let car1 = {
    name: "Audi"
}

let car2 = {
    name: "Audi"
}

console.log(car1 === car1);
//true

console.log(car1 === car2);
//false

console.log(car1 !== car1);
//false

console.log(car1 !== car2);
//true

示例 1： 这里第一个操作数是数字数据类型，第二个操作数是字符串数据类型，所以===运算符返回false，!==运算符返回 true。

示例 2： 由于第一个操作数是NaN形式，所以===运算符返回false，!==运算符返回 true。

示例 3： 这里前两个比较输出true，因为两个操作数的类型相同且具有相同的值，但最后一个输出为false，因为一个操作数为 null，另一个undefined。

示例 4： 在最后一个示例中，第一个输出为true，因为 car1 和 car1 引用同一个实例，而第二个输出为false，因为 car1 和 car2 引用不同的实例。 

JavaScript 中 == 和 === 操作数的使用

在 Javascript 中 == 和 === 之间的区别中， == 和 === 运算符都用于比较操作数。

==和===操作数用于比较两个值是否相等。

==操作数松散地比较两个值，因此它可以用于操作数的数据类型不重要的情况。例如，想象一个表格条目，您在其中询问学生他们的卷号。有些人可能会以字符串形式输入，有些人会以数字形式输入。在这种情况下，我们可以使用==运算符在没有数据库的情况下验证数据。

===操作数严格比较两个值，因此它用于操作数的数据类型很重要的地方。想象一个在线编码竞赛，答案是字符串格式的数字。在这种情况下，我们将使用===运算符来比较和验证答案。 

Javascript中==和===的比较和区别

例子

以下是==运算符行为的一些示例：

console.log(2 == 2);
//true, 因为 2 和 2 是一样的

console.log(2 == '2');
//true, 因为字符串 '2' 在比较前转换成数字

console.log(false == false);
//true, 由于操作数一样

console.log( false == 0 );
//true, 由于 == 操作符进行类型转换，而 '0' 被认为是 false

let student1 = {
    name: 'John',
    class: 10
}

let student2 = {
    name: 'John',
    class: 10
}

let student3 = {
    name: 'Peter',
    class: 10
}

console.log(student1 == student1);
//true, 两操作数引用相同的对象

console.log(student1 == student2);
//false, 由于student1 和 student2 引用不同的对象

console.log(student1 == student3);
//false, 由于 student1 和 student3 引用不同的对象

以下是===运算符行为的一些示例：

console.log(2 === 2);
//true，因为2和2有相同的数据类型和数值

console.log(2 === '2');
//false, 因为 === 运算符不做类型转换，两者数值不同

console.log(false === false);
//true, 操作数有相同的数据类型和数值

console.log( false === 0 );
//false, 由于=== 运算符不转换类型，而两个操作数的数据类型不同

let student1 = {
    name: 'John',
    class: 10
}

let student2 = {
    name: 'John',
    class: 10
}

let student3 = {
    name: 'Peter',
    class: 10
}

console.log(student1 === student1);
//true, 两操作数引用相同的对象

console.log(student1 === student2);
//false, 由于student1 和 student2 引用不同的对象

console.log(student1 === student3);
//false, 由于 student1 和 student3 引用不同的对象

总结

==和===运算符用于检查两个操作数的相等性。

!=和!==运算符用于检查两个操作数的不等式。

==和!=是松散的相等运算符，即它们在比较之前对操作数执行类型转换。

===和!==是严格的相等运算符，即它们在没有任何类型转换的情况下比较操作数，并且即使数据类型不同也返回 false（在===运算符的情况下）。

==和!=运算符用于操作数的数据类型不是比较主要因素的情况，并且可以扭曲它以允许比较两个操作数。例如，==运算符可用于将学生的录取号码（通过表格获取，可以是字符串或数字类型）与存储在数据库中的录取号码（数字数据类型）进行验证。

===和!==运算符用于操作数的数据类型对比较很重要且无法更改以进行比较的情况。例如，在编码比赛中，答案可以是数字或字符串形式，但根据规则，仅对字符串类型的答案给予积分。在这种情况下，我们将使用===运算符将用户的答案与存储在我们数据库中的答案进行比较。

参考文章

• [示例]详解JS中=、==和===之间的区别
• 【实例】详解JS中==和===、!=和!==的使用区别

标签: ==  ===