卡卡網(wǎng)

在本文中，我們將詳細(xì)討論javascript中的等式和不等式運(yùn)算符，它們是松散相等 ( == ) 和嚴(yán)格相等運(yùn)算符 ( === )，我們還將學(xué)習(xí)javascript中==和===運(yùn)算符之間的區(qū)別。

在 Javascript 中，為了比較兩個(gè)值，我們使用比較運(yùn)算符。存在一種比較的特殊情況，其中比較兩個(gè)值并確定這些值是否相等（或不相等）。在這種情況下，我們可以在 javascript 中使用以下兩個(gè)運(yùn)算符：

• == 運(yùn)算符。
• === 運(yùn)算符。

注意：要檢查兩個(gè)值是否不相等，我們將第一個(gè)等號(hào) (=) 替換為感嘆號(hào) (!)。因此!=和!==運(yùn)算符分別用于檢查兩個(gè)值的不等性。

在了解 JavaScript 中 == 和 === 之間的區(qū)別之前，讓我們看看 JavaScript 中的 == 和 !== 運(yùn)算符是什么。

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

javascript 中的==和!=運(yùn)算符用于比較兩個(gè)值。==運(yùn)算符檢查兩個(gè)值是否相等。!=運(yùn)算符檢查兩個(gè)值是否不相等。它也被稱為松散相等運(yùn)算符，因?yàn)樗鼨z查抽象相等，即當(dāng)兩個(gè)操作數(shù)不是相同的數(shù)據(jù)類型時(shí)，它傾向于轉(zhuǎn)換操作數(shù)的數(shù)據(jù)類型以便進(jìn)行比較。

句法

對(duì)于==：

x == y

對(duì)于!=：

x != y

其中 x 和 y 是操作數(shù)，中間部分用于運(yùn)算符。在相等比較的情況下，我們使用 == 運(yùn)算符，在不等比較的情況下，我們使用 != 運(yùn)算符。

返回類型：布爾值。它要么返回true要么返回false。

如果兩個(gè)操作數(shù)具有相同的數(shù)據(jù)類型并且具有相同的值，或者如果它們具有不同的數(shù)據(jù)類型，但是它們中的任何一個(gè)都可以轉(zhuǎn)換為另一個(gè)操作數(shù)的數(shù)據(jù)類型并且具有相同的值，則==運(yùn)算符返回true 。如果兩個(gè)操作數(shù)的值不同，則返回false。

如果兩個(gè)操作數(shù)具有相同的數(shù)據(jù)類型和不同的值，或者如果兩者具有不同的數(shù)據(jù)類型并且它們都不能與另一個(gè)操作數(shù)的類型進(jìn)行比較，則! =運(yùn)算符返回true 。如果兩個(gè)操作數(shù)具有相同的數(shù)據(jù)類型并具有相同的值，或者兩者具有不同的數(shù)據(jù)類型但其中一個(gè)可以轉(zhuǎn)換為另一個(gè)操作數(shù)的數(shù)據(jù)類型并具有相同的值，則返回false。

注意： == 或 != 運(yùn)算符在比較元素之前對(duì)元素進(jìn)行類型轉(zhuǎn)換。

什么是類型轉(zhuǎn)換？

==和!=運(yùn)算符松散地比較兩個(gè)操作數(shù)，即在比較兩個(gè)操作數(shù)時(shí)，如果兩個(gè)操作數(shù)的數(shù)據(jù)類型不同，則運(yùn)算符傾向于將它們中的任何一個(gè)轉(zhuǎn)換為其他操作數(shù)的類型，然后比較它們的值。

這是 Javascript 中 == 和 === 之間最重要的區(qū)別之一。

例子：

如果我們要比較兩個(gè)值，一個(gè)字符串和另一個(gè)數(shù)字，那么它會(huì)將字符串值轉(zhuǎn)換為數(shù)字類型，然后比較值。

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

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

在上面的例子中，b被運(yùn)算符轉(zhuǎn)換為數(shù)字類型，然后與a進(jìn)行比較。由于a和b的數(shù)值相同，所以輸出true。

當(dāng)兩個(gè)操作數(shù)屬于同一類型時(shí) == 和 != 運(yùn)算符的行為

當(dāng)要比較的兩個(gè)操作數(shù)屬于同一類型時(shí)，==和!=運(yùn)算符的行為方式如下： 

如果兩者都是數(shù)字?jǐn)?shù)據(jù)類型，則==運(yùn)算符將在兩者保持相同值時(shí)返回 true，否則返回 false。!=運(yùn)算符反之亦然。

例子：

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

在上面的例子中，第一個(gè)輸出為真，因?yàn)?a 和 b 的值相同，第二個(gè)輸出為假，因?yàn)?a 和 c 有不同的符號(hào)。同樣，第三個(gè)輸出為真，因?yàn)?b 和 c 不相同，第四個(gè)輸出為真，因?yàn)?a 和 b 相同。

如果一個(gè)數(shù)字與 NaN 比較，它仍然會(huì)為==運(yùn)算符輸出 false。

如果兩個(gè)操作數(shù)都是字符串類型，那么只有當(dāng)?shù)谝粋€(gè)操作數(shù)的每個(gè)元素與第二個(gè)操作數(shù)的每個(gè)元素匹配時(shí)，==運(yùn)算符才會(huì)返回 true。!=運(yùn)算符反之亦然。

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

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

在上面的例子中，第一個(gè)輸出為真，因?yàn)?str1 和 str2完全相同，但第二個(gè)輸出為假，因?yàn)?str1 和 str3 不完全相同。第三個(gè)輸出為真，因?yàn)?str1 和 str3 不相同。

因此，我們可以得出結(jié)論，比較也是區(qū)分大小寫的。

如果兩個(gè)操作數(shù)都是布爾類型，那么==運(yùn)算符只有在兩個(gè)操作數(shù)都是true時(shí)才會(huì)返回 true ，否則它將返回 false 。!=運(yùn)算符反之亦然。

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

== 和 != 運(yùn)算符在兩個(gè)操作數(shù)的類型不同時(shí)的行為

當(dāng)操作數(shù)的類型不相同時(shí)，==和!=運(yùn)算符使用抽象相等比較算法來比較兩個(gè)兩個(gè)操作數(shù)。該算法放松了檢查，并在執(zhí)行任何操作之前嘗試將操作數(shù)修改為相同的類型。

以下是當(dāng)操作數(shù)類型不同時(shí)==和!=行為的亮點(diǎn)：

• 如果我們正在比較string和number，則在比較之前將 string 轉(zhuǎn)換為 number。
• 如果我們比較布爾值和數(shù)字（0 或 1），那么它會(huì)將0 視為 false并將1 視為 true。
• 如果我們正在比較兩個(gè)對(duì)象，那么操作員將檢查兩者是否引用同一個(gè)對(duì)象。如果是，則==運(yùn)算符將返回 true，!=將返回 false，否則==將返回 false，!=將返回 true。
• 如果我們比較null和undefined，那么==運(yùn)算符將返回 true，!=運(yùn)算符將返回 false。

例子：

//示例 1: 比價(jià)字符串和數(shù)字
10 == '10'    //true
10 == '99'    //false
10 != '99'    //true
10 != '10'    //true

//示例 2: 比較布爾值和數(shù)字
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: 比較對(duì)象
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： 在此示例中，第一個(gè)操作數(shù)是數(shù)字類型，第二個(gè)操作數(shù)是字符串類型。==運(yùn)算符將字符串類型轉(zhuǎn)換為數(shù)字。

第一個(gè)輸出為真，因?yàn)?10 和 10 相等，因此==運(yùn)算符輸出為真，第二個(gè)輸出為假，因?yàn)?10 和 99 不相等。

第三個(gè)輸出為真，因?yàn)?10 和 99 不相等，因此!=運(yùn)算符的輸出為真，第四個(gè)輸出為假，因?yàn)?10 和 10 相等。

示例 2： 在此示例中，第一個(gè)操作數(shù)是布爾類型，第二個(gè)操作數(shù)是數(shù)字類型（0 或 1）。==運(yùn)算符將數(shù)字類型轉(zhuǎn)換為布爾值。

第一個(gè)輸出為真，因?yàn)檎婧?1 相等（因?yàn)?1 被認(rèn)為是真，0 被認(rèn)為是假），因此==運(yùn)算符的輸出為真，第二個(gè)輸出為假，因?yàn)檎婧?0 不相等。

第三個(gè)輸出為真為假，1 不相等（1 為真，0 為假），因此!=運(yùn)算符的輸出為真，第四個(gè)輸出為假為假，0 相等。

示例 3： 它輸出true，因?yàn)?=運(yùn)算符 null 和 undefined 的比較為 true。

示例 4： 在最后一個(gè)示例中，第一個(gè)輸出為true，因?yàn)?car1 和 car1 引用同一個(gè)實(shí)例，而第二個(gè)輸出為false，因?yàn)?car1 和 car2 引用不同的實(shí)例。

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

===運(yùn)算符稱為嚴(yán)格相等運(yùn)算符（而! ==稱為嚴(yán)格不等運(yùn)算符）。===運(yùn)算符遵循嚴(yán)格相等比較算法，即在比較它們的值之前不進(jìn)行操作數(shù)的類型轉(zhuǎn)換并且即使操作數(shù)的數(shù)據(jù)類型不同也返回 false。

句法

對(duì)于平等：

x === y

對(duì)于不平等：

x !== y

其中 x 和 y 是操作數(shù)，中間部分用于運(yùn)算符。在相等比較的情況下，我們使用 === 運(yùn)算符，在不等比較的情況下，我們使用 !== 運(yùn)算符。

返回類型： 布爾值。它返回true或false。

===運(yùn)算符比較操作數(shù)，如果兩個(gè)操作數(shù)具有相同的數(shù)據(jù)類型并具有某個(gè)值，則返回true，否則返回false。

!==運(yùn)算符比較操作數(shù)，如果兩個(gè)操作數(shù)屬于不同的數(shù)據(jù)類型或?qū)儆谙嗤臄?shù)據(jù)類型但具有不同的值，則返回true 。如果兩個(gè)操作數(shù)具有相同的數(shù)據(jù)類型并且具有相同的值，則返回false。

注意：與==運(yùn)算符不同，===不進(jìn)行類型轉(zhuǎn)換。

例子：

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

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

這里第一個(gè)輸出為假，因?yàn)?a 是數(shù)字類型，而 b 是字符串類型，第二個(gè)輸出為真，因?yàn)?a 和 c 具有相同的數(shù)據(jù)類型和值。

===和!==運(yùn)算符遵循嚴(yán)格的相等比較算法來比較兩個(gè)操作數(shù)。

以下是嚴(yán)格相等比較算法的一些亮點(diǎn)：

• 如果我們要比較的操作數(shù)屬于不同的數(shù)據(jù)類型，則返回false。
• 如果我們要比較的兩個(gè)操作數(shù)中的任何一個(gè)是NaN，那么它將返回false。
• 如果我們要比較的操作數(shù)是null或undefined，那么它將返回true。
• 如果我們要比較的操作數(shù)是對(duì)象，那么如果兩者都引用同一個(gè)對(duì)象，它將返回true，否則將返回false。

例子： 

//示例 1: 當(dāng)兩個(gè)操作數(shù)是不同的數(shù)據(jù)類型
34 === '34'    //false
34 !== '34'    //true

//示例 2: 當(dāng)其中一個(gè)操作數(shù)是 NaN
let a = NaN;
let b = 10;

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

//示例 3: 當(dāng)兩操作數(shù)是 null 或 undefined
null === null             //true
undefined === undefined   //true
null === undefined        //false

//示例 4: 當(dāng)兩個(gè)操作數(shù)是一個(gè)對(duì)象
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： 這里第一個(gè)操作數(shù)是數(shù)字?jǐn)?shù)據(jù)類型，第二個(gè)操作數(shù)是字符串?dāng)?shù)據(jù)類型，所以===運(yùn)算符返回false，!==運(yùn)算符返回 true。

示例 2： 由于第一個(gè)操作數(shù)是NaN形式，所以===運(yùn)算符返回false，!==運(yùn)算符返回 true。

示例 3： 這里前兩個(gè)比較輸出true，因?yàn)閮蓚€(gè)操作數(shù)的類型相同且具有相同的值，但最后一個(gè)輸出為false，因?yàn)橐粋€(gè)操作數(shù)為 null，另一個(gè)undefined。

示例 4： 在最后一個(gè)示例中，第一個(gè)輸出為true，因?yàn)?car1 和 car1 引用同一個(gè)實(shí)例，而第二個(gè)輸出為false，因?yàn)?car1 和 car2 引用不同的實(shí)例。 

JavaScript 中 == 和 === 操作數(shù)的使用

在 Javascript 中 == 和 === 之間的區(qū)別中， == 和 === 運(yùn)算符都用于比較操作數(shù)。

==和===操作數(shù)用于比較兩個(gè)值是否相等。

==操作數(shù)松散地比較兩個(gè)值，因此它可以用于操作數(shù)的數(shù)據(jù)類型不重要的情況。例如，想象一個(gè)表格條目，您在其中詢問學(xué)生他們的卷號(hào)。有些人可能會(huì)以字符串形式輸入，有些人會(huì)以數(shù)字形式輸入。在這種情況下，我們可以使用==運(yùn)算符在沒有數(shù)據(jù)庫的情況下驗(yàn)證數(shù)據(jù)。

===操作數(shù)嚴(yán)格比較兩個(gè)值，因此它用于操作數(shù)的數(shù)據(jù)類型很重要的地方。想象一個(gè)在線編碼競賽，答案是字符串格式的數(shù)字。在這種情況下，我們將使用===運(yùn)算符來比較和驗(yàn)證答案。 

Javascript中==和===的比較和區(qū)別

例子

以下是==運(yùn)算符行為的一些示例：

console.log(2 == 2);
//true, 因?yàn)?nbsp;2 和 2 是一樣的

console.log(2 == '2');
//true, 因?yàn)樽址?'2' 在比較前轉(zhuǎn)換成數(shù)字

console.log(false == false);
//true, 由于操作數(shù)一樣

console.log( false == 0 );
//true, 由于 == 操作符進(jìn)行類型轉(zhuǎn)換，而 '0' 被認(rèn)為是 false

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

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

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

console.log(student1 == student1);
//true, 兩操作數(shù)引用相同的對(duì)象

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

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

以下是===運(yùn)算符行為的一些示例：

console.log(2 === 2);
//true，因?yàn)?和2有相同的數(shù)據(jù)類型和數(shù)值

console.log(2 === '2');
//false, 因?yàn)?=== 運(yùn)算符不做類型轉(zhuǎn)換，兩者數(shù)值不同

console.log(false === false);
//true, 操作數(shù)有相同的數(shù)據(jù)類型和數(shù)值

console.log( false === 0 );
//false, 由于=== 運(yùn)算符不轉(zhuǎn)換類型，而兩個(gè)操作數(shù)的數(shù)據(jù)類型不同

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

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

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

console.log(student1 === student1);
//true, 兩操作數(shù)引用相同的對(duì)象

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

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

總結(jié)

==和===運(yùn)算符用于檢查兩個(gè)操作數(shù)的相等性。

!=和!==運(yùn)算符用于檢查兩個(gè)操作數(shù)的不等式。

==和!=是松散的相等運(yùn)算符，即它們?cè)诒容^之前對(duì)操作數(shù)執(zhí)行類型轉(zhuǎn)換。

===和!==是嚴(yán)格的相等運(yùn)算符，即它們?cè)跊]有任何類型轉(zhuǎn)換的情況下比較操作數(shù)，并且即使數(shù)據(jù)類型不同也返回 false（在===運(yùn)算符的情況下）。

==和!=運(yùn)算符用于操作數(shù)的數(shù)據(jù)類型不是比較主要因素的情況，并且可以扭曲它以允許比較兩個(gè)操作數(shù)。例如，==運(yùn)算符可用于將學(xué)生的錄取號(hào)碼（通過表格獲取，可以是字符串或數(shù)字類型）與存儲(chǔ)在數(shù)據(jù)庫中的錄取號(hào)碼（數(shù)字?jǐn)?shù)據(jù)類型）進(jìn)行驗(yàn)證。

===和!==運(yùn)算符用于操作數(shù)的數(shù)據(jù)類型對(duì)比較很重要且無法更改以進(jìn)行比較的情況。例如，在編碼比賽中，答案可以是數(shù)字或字符串形式，但根據(jù)規(guī)則，僅對(duì)字符串類型的答案給予積分。在這種情況下，我們將使用===運(yùn)算符將用戶的答案與存儲(chǔ)在我們數(shù)據(jù)庫中的答案進(jìn)行比較。

參考文章

• [示例]詳解JS中=、==和===之間的區(qū)別
• 【實(shí)例】詳解JS中==和===、!=和!==的使用區(qū)別

標(biāo)簽: ==  ===