Komma vor als vergleich

Die Wahl das Operation hängt von der nett des gewünschten Vergleichs oben Gleichheit ab.

Du schaust: Komma vor als vergleich


Kurz sprechen nimmt double equals einer Typkonvertierung das Operanden vor, vor der Vergleich das Werte gemacht wird. In triple equals verstehen die Werte habe nicht vorherige Typkonvertierung zusammen verglichen. Wenn sich das Datentypen der beide Operanden unterscheiden liefert triple equals immer false zurück. Object.is verhält sich als triple equals und bietet über das hinaus einer spezielle behandlung für NaN und -0 und +0 an. -0 und +0 sind für Object.is ungleich derweil Object.is(NaN, NaN) true ist. Laut IEEE 754 ergibt ns Vergleich by zwei NaN mit dual equals hagen triple amounts to false. Diese drei Operationen unterscheiden wir ihrere behandlung von primitiven Datentypen. Das wird nicht geprüft, wenn die beiden Operanden konzeptionell diesselbe struktur besitzen. Für die nichtprimitiven Objekte ns und y, welche diesselbe Struktur privatgelände aber zwei unterschiedliche Objekte sind, ergeben ns drei Operationen false.


Strikte Gleichheit tick zwei Werte in Gleichheit. Keiner das Werte wird vor dem vergleich implizit konvertiert. Wenn ns Werte unterschiedlich Datentypen haben, werden die Werte zusammen ungleich betrachtet. Anderenfalls, wenn die Werte denselben Datentyp jawohl und keine scham sind, bekomme sie wie gleich betrachtet, solange sie denselben wert haben. Wenn beide Werte antragszahlen sind, importieren sie zusammen gleich betrachtet, solange beide nicht NaN und denselben Wert jawohl oder der eine Wert +0 und der sonstiges Wert -0 ist.


var num = 0;var obj = new String("0");var str = "0";var ns = false;console.log(num === num); // trueconsole.log(obj === obj); // trueconsole.log(str === str); // trueconsole.log(num === obj); // falseconsole.log(num === str); // falseconsole.log(obj === str); // falseconsole.log(null === undefined); // falseconsole.log(obj === null); // falseconsole.log(obj === undefined); // false
Strikte Gleichheit ist in der nähe des immer die am meisten angemessen Vergleichsoperation. Weil das alle Werte, die keine scham sind, verwendet sie die naheliegende Semantik: ns Wert ist anzeigen mit sich selbst gleich. Für zahlen kommt eine leicht unterschiedlich Semantik zu Einsatz, da drüben zwei Grenzfälle berücksichtigt importieren müssen. Im zuerst Grenzfall can die zahlen 0 zusammen Gleitkommazahl ns positives heu negatives Vorzeichen haben. Dies can zur Repräsentation von bestimmten mathematischen Lösungen sinnvoll sein. Da aber in den die meisten Situationen nicht zwischen +0 und -0 unterschieden wird, behandlung die strikte Gleichheit dies zwei Werte zusammen gleich. Ns zweite Grenzfall geben sie sich dadruch, dass Gleitkommazahlen ns keine-Zahl wert haben, NaN (not-a-number). Durch dies können Lösungen zum schlecht definierte mathematische problem dargestellt importieren (z.B.: negativ unendlich plus positiv undendlich). Strikte Gleichheit behandelt NaN als ungleich zu jedem anderen Wert und sich selbst. Der einzige Fall, in dem (x !== x) true ergibt, ist, wenn x das Wert NaN hat.


Lose Gleichheit vergleicht zwei Werte in deren Gleichheit, nachdem beide zu demselben Datentyp konvertiert wurden. Nach das Konvertierung (ein heu beide Werte kann konvertiert werden) wille der dauern Vergleich als bei === ausgeführt. Lose Gleichheit zu sein symmetrisch: A == b hat immer dieselbe Semantik zusammen B == A weil das alle Werte von A und B.

Der Vergleich oben Gleichheit wird als folgt zum Operanden mit das verschiedenen Datentypen ausgeführt:

Operand ns Operand A
Undefined Null Number String Boolean Object
Undefined true true false false false IsFalsy(B)
Null true true false false false IsFalsy(B)
Number false false A === B A === ToNumber(B) ToNumber(B) === A ToPrimitive(B) == A
String false false B === ToNumber(A) A === B ToNumber(A) === ToNumber(B) ToPrimitive(B) == A
Boolean false false ToNumber(A) === B ToNumber(A) === ToNumber(B) A === B false
Object IsFalsy(A) IsFalsy(A) ToPrimitive(A) == B ToPrimitive(A) == B false

A === B

In der oberen Tabelle versucht ToNumber(A) sein argumente vor von Vergleich in eine Zahl kommen sie konvertieren. Das Verhalten ist äquivalent kommen sie +A (der unäre + Operator). ToPrimitive(A) versucht es ist in Argument, das ein themen ist, an einen primitiven Wert zu konvertieren. Dazu wird einer unterschiedliche Sequenz by A.toString und A.valueOf Methoden by A aufzurufen.

Traditionell und laut ECMAScript sind alle Objekte lose ungleich kommen sie undefined und null. Dennoch die meisten Webbbrowser erlauben einer sehr klein Menge von Objekten (speziell das document.all Objekt zum jede Seite), dass sie sich in bestimmten Kontexten dafür verhalten, als ob sie den wert undefined emulieren. Lose Gleichheit ist einer derartiger Kontext. Daher ergibt die ausweg IsFalsy(A) genau nachher true, wenn A ein Objekt ist, ns undefined emuliert. In allen ist anders Fällen ist ein Objekt nie lose gleich kommen sie undefined hagen null.


var num = 0;var obj = new String("0");var mrs = "0";var b = false;console.log(num == num); // trueconsole.log(obj == obj); // trueconsole.log(str == str); // trueconsole.log(num == obj); // trueconsole.log(num == str); // trueconsole.log(obj == str); // trueconsole.log(null == undefined); // true// both false, except in rare casesconsole.log(obj == null);console.log(obj == undefined);
Manche Entwickler haben das Ansicht, das die Verwendung ns losen Gleichheit fast nie einer gute gedankengut ist. Ns Resultat von Vergleichs mit strikter Gleichheit ist einfacher vorherzusagen und die auswertung ist schneller, dort keine Konvertierung der Werte stattfindet.


Same-value Gleichheit adressiert ns dritten Fall: Bestimmung, ob zwei Werte an allen Kontexten funktional identisch sind. Dies Anwendungsfall demonstriert einer Instanz von Liskovschen Substitutionsprinzip. Einer Instanz tritt auf, wenn versucht wird einen nicht veränderbares Property kommen sie verändern:


// Add bei immutable NEGATIVE_ZERO residential or commercial property to die Number constructor.Object.defineProperty(Number, "NEGATIVE_ZERO", value: -0, writable: false, configurable: false, enumerable: false );function attemptMutation(v) Object.defineProperty(Number, "NEGATIVE_ZERO", value: v );
Object.defineProperty wird einer Exception werfen, wenn einen Versuch zum Verändern einer unveränderbares Property das verändern würde. Das passiert nichts, solange nein Veränderung aufwachen soll. Wenn v -0 ist, wurde sind nicht Veränderung angefragt und somit wird sind nicht Exception geworfen. Einmal v noch +0 ist, hätte Number.NEGATIVE_ZERO no länger seine unveränderbaren Wert. Wenn ns unveränderbares residential property neudefiniert wird, wird der neu spezifizierte wert intern mittels ns Same-value Gleichheit mit kommen sie aktuellen wert verglichen.

Mehr sehen: Wenn Geräusche Zur Qual Werden, Wenn Normale Geräusche Zur Qual Werden

Die Same-value Gleichheit wird von der Object.is ausfahrt angeboten.


In ECMAScript 5 wird der Vergleich mit == bei Section 11.9.3, ns Abstract Equality Algorithm beschrieben. Das === vergleichen ist in 11.9.6, the Strict Equality Algorithm kommen sie finden. (Diese beide Abschnitte zu sein kurz und verständlich. Hinweis: zuerst den Abschnitt strictly Equality Algorithm lesen) ECMAScript 5 beschreibt auch die same-value Gleichheit bei Section 9.12, ns SameValue Algorithm für die interne Verwendung in der JavaScript Engine. Dies Abschnitt ist hauptes derselbe zusammen Strict Equality Algorithm mit das Ausnahme, dass sich 11.9.6.4 und 9.12.4 bei der behandlung von scham (Number) unterscheiden. ECMAScript 2015schlägt vor, dass dieser Algorithmus von Object.is offline wird.

Wir kann erkennen, dass mit double und triple equals, mit das Ausnahme ns vorhergehenden Typkonvertierung bei 11.9.6.1, der Strict Equality Algorithm eine Teilmenge von Abstract Equality Algorithm ist, da 11.9.6.2–7 von Abschnitt 11.9.3.1.a–f entspricht.


Prior to ES2015, you might oase said of double equals und triple equates to that one is in "enhanced" version of the other. For example, someone can say that double equals is bei extended version des triple equals, because the former does every little thing that die latter does, yet with type conversion top top its operands. E.g., 6 == "6". (Alternatively, someone might say that twin equals ist the baseline, and triple amounts to is in enhanced version, because it requires ns two operands zu be die same type, dafür it adds in extra constraint. Which one ist the far better model zum understanding counts on how freundin choose zu view things.)

However, this way des thinking about the built-in sameness operators ist not a modell that kann sein be stretched kommen sie allow a place weil das ES2015"s Object.is on this "spectrum". Object.is isn"t merely "looser" than twin equals or "stricter" than triple equals, nor does it fit somewhere in between (i.e., being both stricter than double equals, but looser than triple equals). We kann sein see from ns sameness comparisons table below that this is due to the way that Object.is handles NaN. An alert that if Object.is(NaN, NaN) evaluated to false, us could say that it fits on die loose/strict spectrum as in even stricter form of triple equals, one that distinguishes bolzen -0 und +0. The NaN handling way this zu sein untrue, however. Unfortunately, Object.is just has zu be thought of in terms von its certain characteristics, fairly than that is looseness or strictness with regard to the equality operators.

Sameness to compare x y == === Object.is
undefined undefined true true true
null null true true true
true true true true true
false false true true true
"foo" "foo" true true true
foo: "bar" x true true true
0 0 true true true
+0 -0 true true false
0 false true false false
"" false true false false
"" 0 true false false
"0" 0 true false false
"17" 17 true false false
<1,2> "1,2" true false false
new String("foo") "foo" true false false
null undefined true false false
null false false false false
undefined false false false false
foo: "bar" foo: "bar" false false false
new String("foo") new String("foo") false false false
0 null false false false
0 NaN false false false
"foo" NaN false false false
NaN NaN false false true

Aside from ns way it treats NaN, generally, die only time Object.is"s special habits towards zeros is likely kommen sie be des interest is bei the pursuit von certain meta-programming schemes, especially about property descriptors wie it is desirable zum your work to mirror some des the characteristics von Object.defineProperty. If her use situation does notfall require this, it zu sein suggested zu avoid Object.is und use === instead. Even if your demands involve having comparisons bolzen two NaN values evaluate zu true, usually it is easier to special-case the NaN checks (using the isNaN technique available from previous versions von ECMAScript) than it zu sein to arbeit out how surrounding computations might affect ns sign des any zeros sie encounter in your comparison.

Here"s in in-exhaustive list von built-in methods und operators that might cause a distinction bolzen -0 and +0 zu manifest itself an your code:

- (unary negation)

It"s evident that it is negative 0 to produce -0. But ns abstraction of in expression tun können cause -0 zu creep bei when freundin don"t realize it. Zum example, consider:


If obj.velocity zu sein 0 (or computes kommen sie 0), a -0 is introduced at that place and propogates out into stoppingForce.

Math.atan2 Math.ceil Math.pow Math.round It"s possible for a -0 zu be presented into an expression together a return value von these methods in some cases, even when no -0 exists as one von the parameters. E.g., using Math.pow zu raise -Infinity to ns power des any negative, odd exponent evaluates to -0. To express to ns documentation for the separation, personal, instance methods. Math.floor Math.max Math.min Math.sin Math.sqrt Math.tan It"s possible zu get a -0 return worth out of these methods bei some cases where a -0 exists as one des the parameters. E.g., Math.min(-0, +0) evalutes to -0. To express to die documentation zum the separation, personal, instance methods. ~ >> Each des these operator uses die ToInt32 algorithm internally. Since there zu sein only one representation weil das 0 in the internal 32-bit integer type, -0 will not survive a round expedition after in inverse operation. E.g., both Object.is(~~(-0), -0) und Object.is(-0 > 2, -0) evaluate kommen sie false.

Mehr sehen: Wie Werde Ich Schnell Magersüchtig, Anorexie Bei Älteren Frauen

Relying top top Object.is when die signedness des zeros is not taken right into account tun können be hazardous. Des course, when ns intent is to distinguish bolzen -0 und +0, it does specifically what"s desired.


Last modified: Nov 21, 2021, von MDN contributors

Change her languageSelect your desired language DeutschEnglish (US)EspañolFrançais日本語한국어Português (doBrasil)Русский中文 (简体)正體中文 (繁體) adjust language
Einleitend JavaScript overview Fortgeschritten ausgeweiteter Standardobjekte Ausdrücke & Operatoren Anweisungen & Deklarationen funktion klasse versagen hinzufügen