卡卡網(wǎng)

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

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

• == 運算符。
• === 運算符。

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

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

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

javascript 中的==和!=運算符用于比較兩個值。==運算符檢查兩個值是否相等。!=運算符檢查兩個值是否不相等。它也被稱為松散相等運算符，因為它檢查抽象相等，即當兩個操作數(shù)不是相同的數(shù)據(jù)類型時，它傾向于轉換操作數(shù)的數(shù)據(jù)類型以便進行比較。

句法

對于==：

x == y

對于!=：

x != y

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

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

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

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

注意： == 或 != 運算符在比較元素之前對元素進行類型轉換。

什么是類型轉換？

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

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

例子：

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

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

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

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

當兩個操作數(shù)屬于同一類型時 == 和 != 運算符的行為

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

如果兩者都是數(shù)字數(shù)據(jù)類型，則==運算符將在兩者保持相同值時返回 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 相同。

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

如果兩個操作數(shù)都是字符串類型，那么只有當?shù)谝粋€操作數(shù)的每個元素與第二個操作數(shù)的每個元素匹配時，==運算符才會返回 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 不相同。

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

如果兩個操作數(shù)都是布爾類型，那么==運算符只有在兩個操作數(shù)都是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

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

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

以下是當操作數(shù)類型不同時==和!=行為的亮點：

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

例子：

//示例 1: 比價字符串和數(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: 比較對象
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： 在此示例中，第一個操作數(shù)是數(shù)字類型，第二個操作數(shù)是字符串類型。==運算符將字符串類型轉換為數(shù)字。

第一個輸出為真，因為 10 和 10 相等，因此==運算符輸出為真，第二個輸出為假，因為 10 和 99 不相等。

第三個輸出為真，因為 10 和 99 不相等，因此!=運算符的輸出為真，第四個輸出為假，因為 10 和 10 相等。

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

第一個輸出為真，因為真和 1 相等（因為 1 被認為是真，0 被認為是假），因此==運算符的輸出為真，第二個輸出為假，因為真和 0 不相等。

第三個輸出為真為假，1 不相等（1 為真，0 為假），因此!=運算符的輸出為真，第四個輸出為假為假，0 相等。

示例 3： 它輸出true，因為==運算符 null 和 undefined 的比較為 true。

示例 4： 在最后一個示例中，第一個輸出為true，因為 car1 和 car1 引用同一個實例，而第二個輸出為false，因為 car1 和 car2 引用不同的實例。

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

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

句法

對于平等：

x === y

對于不平等：

x !== y

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

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

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

!==運算符比較操作數(shù)，如果兩個操作數(shù)屬于不同的數(shù)據(jù)類型或屬于相同的數(shù)據(jù)類型但具有不同的值，則返回true 。如果兩個操作數(shù)具有相同的數(shù)據(jù)類型并且具有相同的值，則返回false。

注意：與==運算符不同，===不進行類型轉換。

例子：

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

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

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

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

以下是嚴格相等比較算法的一些亮點：

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

例子： 

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

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

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

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

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

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

示例 3： 這里前兩個比較輸出true，因為兩個操作數(shù)的類型相同且具有相同的值，但最后一個輸出為false，因為一個操作數(shù)為 null，另一個undefined。

示例 4： 在最后一個示例中，第一個輸出為true，因為 car1 和 car1 引用同一個實例，而第二個輸出為false，因為 car1 和 car2 引用不同的實例。 

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

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

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

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

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

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

例子

以下是==運算符行為的一些示例：

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

console.log(2 == '2');
//true, 因為字符串 '2' 在比較前轉換成數(shù)字

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

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, 兩操作數(shù)引用相同的對象

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

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

以下是===運算符行為的一些示例：

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

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

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

console.log( false === 0 );
//false, 由于=== 運算符不轉換類型，而兩個操作數(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ù)引用相同的對象

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

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

總結

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

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

==和!=是松散的相等運算符，即它們在比較之前對操作數(shù)執(zhí)行類型轉換。

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

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

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

參考文章

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

標簽: ==  ===