Eine kurze Diskussion zum Gleichheitsoperator in JavaScript: der Unterschied zwischen == und ===

Beim Programmieren stoßen wir häufig auf die Situation, zu beurteilen, ob zwei Variablen gleich sind. ECMAscript bietet zwei Gleichheitsoperatoren „==“ und „===“, um beide zu beurteilen Operationen geben einen booleschen Wert zurück. Im Allgemeinen nennen wir „==“ gleich und „===“ kongruent.

Wenn die Datentypen der beiden verglichenen Variablen konsistent sind, ist die Situation relativ einfach. Wenn jedoch die Variablentypen auf beiden Seiten des Operators inkonsistent sind oder sogar eine der Variablen ein Objekt ist Die Situation ist wie folgt kompliziert. Stellen Sie separat vor, was mit den Operationsergebnissen geschieht, wenn die Operandentypen unterschiedlich sind.

Der Fall des Kongruenzoperators „===“

Der Kongruenzoperator „===“ ist relativ einfach. Wenn Sie zur Beurteilung den Kongruenzoperator „===“ verwenden, prüfen Sie zunächst, ob die Datentypen der Operanden auf beiden Seiten des Operators konsistent sind. Wenn sie inkonsistent sind, wird „false“ direkt zurückgegeben gemacht werden.

Wenn es sich um einen Vergleich zweier boolescher Werte handelt, müssen beide Seiten von „===“ wahr oder falsch sein, bevor es „wahr“ zurückgeben kann, andernfalls wird „falsch“ zurückgegeben. Wenn es sich bei den beiden Vergleichen um Zahlen handelt Nur wenn „True“ nur dann zurückgegeben wird, wenn die beiden Zahlen gleich groß sind, andernfalls wird „False“ zurückgegeben.

Wenn die beiden zu vergleichenden Variablen Zeichenfolgen sind, vergleichen Sie zunächst die Längen der beiden Zeichenfolgen, um festzustellen, ob sie gleich sind. Wenn die Längen unterschiedlich sind, geben Sie „false“ zurück. Beginnen Sie mit der ersten Die beiden Variablen werden auf Gleichheit verglichen und bis zur letzten Ziffer fortgesetzt. Wenn eine der Ziffern nicht warten möchte, wird „false“ zurückgegeben, andernfalls wird „true“ zurückgegeben.

(Hinweis: Beim Zeichenfolgenvergleich werden Leerzeichen nicht ignoriert. Wenn Sie also zwei Zeichenfolgen vergleichen, um festzustellen, ob sie gleich sind, sollten Sie aus Sicherheitsgründen zuerst die Leerzeichen entfernen und dann beide Zeichenfolgen in Großbuchstaben oder Kleinbuchstaben umwandeln vergleichen).

Und null gibt nur true zurück, wenn null===null, andernfalls gibt es false zurück. Ebenso gibt undefiniert nur true zurück, wenn undefiniert===undefiniert, andernfalls wird es falsch zurückgegeben. Zum Beispiel:

true === 1    //false
"1" === 1    //false
 
//boolean的比较
true === true  //true
true === false  //false

//string的比较
"hello" === "helloworrld" //false
"hello" === "world" //false
"hello" === " hello" //false
"hello" === "hellO" //false
"hello" === "hello" //true

//number的比较
1 === 1  //true
1 === 1.0 //true
1 === 1.2 //false

//null和undefined的比较
undefined === undefined  //true
null === null       //true
undefined === null    //false,两者在"=="时才返回true

Wenn die beiden Operanden für den „===“-Vergleich keine Basistypwerte, sondern zwei Objekte sind, besteht die Grundlage für die Beurteilung zu diesem Zeitpunkt darin, zu beurteilen, ob die beiden Variablen „gleich“ sind. Objekt

var a,b,c;
a = b = {
	name : '柳轻侯',
	city : '南京'
};
c = {
	name : '柳轻侯',
	city : '南京'
};
a === b   //true
a === c   //false

Es reicht nicht aus, dass zwei Objekte „gleich aussehen“. Sie sind beide Objektinstanzen und haben die gleichen Eigenschaften und Werte, aber sie sind nicht das „gleiche“ Objekt, weil a und c zeigen tatsächlich auf zwei verschiedene Instanzen, sodass die beiden Objekte nicht deckungsgleich sind.

Aber a und b zeigen auf dasselbe Objekt. Mit anderen Worten, a und b sind unterschiedliche Aliase desselben Objekts. Sie zeigen tatsächlich auf genau dasselbe Objekt, also ist a === b. Die Vergleichsregeln für „!==" und „===" sind dieselben und werden hier nicht wiederholt.

Gleichheitsoperator "=="

Kongruenzoperator Wenn bei der Beurteilung die Typen der beiden Variablen unterschiedlich sind, wird direkt false zurückgegeben , aber im Gegensatz dazu wird bei der Beurteilung durch den Gleichheitsoperator „==“ eine implizite Typkonvertierung durchgeführt, wenn die Typen der beiden Variablen unterschiedlich sind, um die beiden zu vergleichenden Werte in denselben Typ umzuwandeln noch einmal verglichen, was sind also die Umrechnungsregeln?

Bei der Konvertierung verschiedener Datentypen befolgen die Gleichheits- und Ungleichheitsoperatoren die folgenden Grundregeln

• Wenn einer der Operanden ein boolescher Wert ist, wird er vor dem Vergleich mit dem booleschen Wert verglichen wird in einen Zahlenwert konvertiert, true wird in 1 konvertiert und false wird in 0 konvertiert;
• Wenn einer der Operanden vom Typ „String“ und der andere vom Typ „Zahl“ ist, wird der String-Typ in eine Zahl konvertiert vor dem Vergleich Der Typ wird dann beurteilt;
• Undefiniert und null werden zum Vergleich vor dem Vergleich nicht in andere Werte konvertiert;
• Wenn einer der Operanden ein Objekt und der andere ein ist Basistypwert, dann wird das Objekt vor dem Vergleich in einen Basistypwert konvertiert und anschließend werden nachfolgende Vergleiche gemäß den vorherigen Regeln durchgeführt

Die beiden Operanden folgen beim Vergleich den folgenden Regeln

• undefiniert und null sind gleich, das heißt: undefiniert == null;
• Wenn ein Operand NaN ist, wird false zurückgegeben. Auch wenn beide Operanden NaN sind, wird false zurückgegeben;
• Wenn die beiden Operanden Objekte sind, sind die Vergleichsregeln dieselben wie die Vergleichsregeln von "===", es sei denn, die beiden Operanden sind dasselbe Objekt, dann wird true zurückgegeben, andernfalls wird false zurückgegeben;

Hier ist zu beachten, dass NaN == NaN keine Zahl zurückgibt, was bedeutet, dass der Operand eine Nichtzahl ist. Der Wert von ist unbekannt Möglicherweise kann eine solche unbekannte Größe nicht einmal für spezifische Vergleiche verwendet werden. Wenn Sie den Wert zweier unbekannter Dinge nicht bestimmen können, können Sie natürlich nicht NaN == NaN sagen.

Da wir also nicht „==" zum Vergleichen verwenden können, wie können wir dann feststellen, ob eine Variable NaN ist? Da wir zur Bestimmung keine Gleichheit verwenden können, können wir genauso gut das Gegenteil tun und „!=" verwenden. Bestimmen Sie, ob eine Variable ungleich NaN ist. Zum Beispiel:

//如果需要判定一个变量是不是NaN,可以如下
//a是你需要判定的变量
if((typeof a === "number") && a != NaN ){  //此处需要注意，NaN也是number类型
	//TODO 
}

Häufige Vergleichssituationen und ihre Ergebnisse

null == undefined  // true 
"NaN" == NaN    // false 
5 == NaN      // false 
NaN == NaN     // false 
NaN != NaN     // true 
false == 0     // true 
true == 1      // true 
true == 2      // false 
undefined == 0   // false 
null == 0      // false
"5" == 5      // true

Analyse typischer Beispiele

![] == [] //true

这是一道比较容易令人困惑的题，按照正常的思维模式，对一个操作数逻辑取反，跟这个操作数本身的值是相对的，如果这个操作数本身的值是true,那么取反之后就是false，反之，如果这个操作数的值是false，那么对其逻辑取反之后就是true，无论如何也不会是同一个值，可是事实上却是![] == []。

首先，![]的值是false，因为这里[]被当成了一个数组的实例，是一个对象，而对象都是真值，对其取反，得到一个假值，也就是false。

其次看等号右边，[]是一个对象，要将其转为基本类型值，会先调用数组的valueOf方法，而数组的valueOf方法返回数组本身，没有得到一个基本值。

这时候要继续调用数组的toString方法，得到一个””空字符串，所以这时候也就变成了false == “”是否为真的问题了，而根据前面的规则，如果有一个操作数为boolean值，会将其转为数值，false转化为0。

进而，问题转化为0 == “”是否为真值的问题，当number和string比较时，会将string转为number，而””会转为0。最后，问题变演化成了0 == 0是否为真值，毋庸置疑，结果是true。

这里要注意的就是![]，它被当成了一个整体的逻辑值，是直接对对象进行取反，是一个假值，而不是先把[]转化为基本值再取反

小结

“==”在比较不同类型值得时候会进行隐式的类型转化，而”===”不会转化，全等一定相等，相等却不一定全等，这是一个充分不必要条件。

undefined和null相等而不全等，且在相等比较的时候不会转化为其他类型的值。NaN是不等于NaN 的，要判断某个变量是不是NaN，要用”!=”。对象和非对象在进行比较的时候会先转为基本类型值然后再根据上面的规则进行比较。

推荐教程：《JS教程》

Das obige ist der detaillierte Inhalt vonEine kurze Diskussion zum Gleichheitsoperator in JavaScript: der Unterschied zwischen == und ===. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!