卡卡網

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

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

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

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

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

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

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

句法

對于==：

x == y

對于!=：

x != y

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

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

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

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

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

什么是類型轉換？

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

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

例子：

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

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 不相同。

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

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

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

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

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

• 如果我們正在比較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 中 == 和 === 之間的區(qū)別中， == 和 === 運算符都用于比較操作數。

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

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

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

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

例子

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

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 引用不同的對象

總結

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

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

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

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

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

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

參考文章

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

標簽: ==  ===