Ist die Verwendung von == in JavaScript jemals sinnvoll?

In JavaScript schrieb Douglas Crockford:

JavaScript hat zwei Gruppen von Gleichheitsoperatoren: ===und !==und ihre bösen Zwillinge ==und !=. Die Guten arbeiten so, wie Sie es erwarten würden. Wenn die beiden Operanden vom selben Typ sind und denselben Wert haben, dann ===produziert trueund !==produziert false. Die bösen Zwillinge tun das Richtige, wenn die Operanden vom selben Typ sind, aber wenn sie von unterschiedlichem Typ sind, versuchen sie, die Werte zu erzwingen. Die Regeln, nach denen sie das tun, sind kompliziert und nicht zu merken. Dies sind einige der interessanten Fälle:

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

Der Mangel an Transitivität ist alarmierend. Mein Rat ist, niemals die bösen Zwillinge zu benutzen. Verwenden Sie stattdessen immer ===und !==. Alle soeben gezeigten Vergleiche ergeben falsemit dem ===Bediener.

Gibt es in Anbetracht dieser eindeutigen Beobachtung jemals einen Zeitpunkt, zu dem die Verwendung ==tatsächlich angemessen sein könnte?

Ich werde dafür ein Argument vorbringen ==

Douglas Crockford, den Sie zitiert haben, ist bekannt für seine vielen und oft sehr nützlichen Meinungen. Obwohl ich in diesem speziellen Fall mit Crockford zusammen bin, ist es erwähnenswert, dass dies nicht die einzige Meinung ist. Es gibt andere wie den Sprachschöpfer Brendan Eich, bei denen das große Problem nicht auffällt ==. Das Argument sieht ungefähr so ​​aus:

JavaScript ist eine Verhaltenssprache. Dinge werden basierend auf dem behandelt, was sie können und nicht auf ihrem tatsächlichen Typ. Aus diesem Grund können Sie die .mapMethode eines Arrays in einer NodeList oder in einem jQuery-Auswahlsatz aufrufen. Das ist auch der Grund, warum Sie 3 - "5"etwas Sinnvolles tun und zurückbekommen können - weil "5" wie eine Zahl wirken kann.

Wenn Sie eine ==Gleichheit ausführen, vergleichen Sie den Inhalt einer Variablen und nicht ihren Typ . Hier sind einige Fälle, in denen dies nützlich ist:

• Lesen einer Zahl vom Benutzer - Lesen .valueeines Eingabeelements im DOM? Kein Problem! Sie müssen nicht damit beginnen, es zu gießen oder sich über seine Art Gedanken zu machen - Sie können ==es sofort zu Zahlen verarbeiten und etwas Sinnvolles zurückbekommen.
• Müssen Sie nach dem Vorhandensein einer deklarierten Variablen suchen? - Sie können == nulles, da verhaltensbezogen nullnichts da ist und undefiniert auch nichts da ist.
• Müssen Sie überprüfen, ob Sie eine aussagekräftige Eingabe von einem Benutzer erhalten haben? - Überprüfen Sie, ob die Eingabe mit dem ==Argument falsch ist. Es werden Fälle behandelt, in denen der Benutzer nichts oder nur Leerzeichen für Sie eingegeben hat. Dies ist wahrscheinlich das, was Sie benötigen.

Schauen wir uns Crockfords Beispiele an und erklären wir sie wie folgt:

'' == '0'           // got input from user vs. didn't get input - so false
0 == ''             // number representing empty and string representing empty - so true
0 == '0'            // these both behave as the number 0 when added to numbers - so true    
false == 'false'    // false vs got input from user which is truthy - so false
false == '0'        // both can substitute for 0 as numbers - so again true

false == undefined  // having nothing is not the same as having a false value - so false
false == null       // having empty is not the same as having a false value - so false
null == undefined   // both don't represent a value - so true

' \t\r\n ' == 0     // didn't get meaningful input from user vs falsey number - true 

Grundsätzlich ==ist es so konzipiert, dass es darauf basiert, wie sich Primitive in JavaScript verhalten, und nicht darauf, was sie sind . Ich persönlich bin mit diesem Standpunkt zwar nicht einverstanden, aber es ist auf jeden Fall sinnvoll, dies zu tun - insbesondere, wenn Sie dieses Paradigma der Behandlung von Typen auf der Grundlage von Verhaltensweisen in der gesamten Sprache anwenden.

^{* Einige mögen die häufigere strukturelle Typisierung des Namens bevorzugen, aber es gibt einen Unterschied - sie ist nicht wirklich daran interessiert, den Unterschied hier zu diskutieren.}

Es stellt sich heraus, dass jQuery das Konstrukt verwendet

if (someObj == null) {
  // do something
}

ausführlich, als Abkürzung für den entsprechenden Code:

if ((someObj === undefined) || (someObj === null))  {
  // do something
}

Dies ist eine Konsequenz der ECMAScript-Sprachspezifikation § 11.9.3, Der abstrakte Gleichheitsvergleichsalgorithmus , in der unter anderem angegeben ist, dass

1.  If Type(x) is the same as Type(y), then  
    a.  If Type(x) is Undefined, return true.  
    b.  If Type(x) is Null, return true.

und

2.  If x is null and y is undefined, return true.
3.  If x is undefined and y is null, return true.

Diese besondere Technik ist häufig genug , dass JSHint eine hat Flagge speziell dafür.

Das Überprüfen von Werten auf nulloder undefinedist eine Sache, wie bereits ausführlich erläutert wurde.

Es gibt eine andere Sache, wo es ==glänzt:

Sie können Vergleiche >=wie folgt definieren (die Leute beginnen normalerweise mit, >aber ich finde das eleganter):

• a > b <=> a >= b && !(b >= a)
• a == b <=> a >= b && b >= a
• a < bund a <= bwerden als Übung dem Leser überlassen.

Wie wir wissen, in JavaScript "3" >= 3und "3" <= 3, von denen Sie erhalten 3 == "3". Sie können darauf hinweisen, dass es eine schreckliche Idee ist, einen Vergleich zwischen Zeichenfolgen und Zahlen zuzulassen, indem Sie die Zeichenfolge analysieren. Aber da dies ist der Weg , es funktioniert, ==ist absolut der richtige Weg , diese Beziehung Operator zu implementieren.

Das wirklich Gute daran ==ist, dass es mit allen anderen Beziehungen konsistent ist. Anders ausgedrückt, wenn Sie folgendes schreiben:

function compare(a, b) {
  if (a > b) return 1;
  if (a < b) return -1;
  return 0;
}

Sie verwenden implizit ==bereits.

Nun zu der ziemlich verwandten Frage: War es eine schlechte Wahl, Zahlen- und Zeichenfolgenvergleich so zu implementieren, wie er implementiert ist? Für sich genommen scheint es ziemlich dumm zu sein. Aber im Zusammenhang mit anderen Teilen von JavaScript und dem DOM ist es relativ pragmatisch, wenn man bedenkt, dass:

• Attribute sind immer Zeichenfolgen
• Schlüssel sind immer Zeichenfolgen (der Anwendungsfall ist, dass Sie Objecteine Karte mit geringer Dichte von Ints zu Werten verwenden).
• Benutzereingabe- und Formularsteuerungswerte sind immer Zeichenfolgen (auch wenn die Quelle übereinstimmt input[type=number])

Aus einer ganzen Reihe von Gründen war es sinnvoll, Zeichenfolgen bei Bedarf wie Zahlen zu verhalten. Und unter der Annahme, dass der Zeichenfolgenvergleich und die Zeichenfolgenverkettung unterschiedliche Operatoren haben (z. B. ::für die Verkettung und eine Vergleichsmethode (bei der Sie alle möglichen Parameter in Bezug auf die Groß- und Kleinschreibung verwenden können und was nicht)), wäre dies in der Tat weniger verwirrend. Aber diese Überladung des Operators ist wahrscheinlich in der Tat, wo das "Java" in "JavaScript" herkommt;)

Als professioneller Mathematiker sehe ich in Javscripts Gleichheitsoperator == (auch als "abstrakter Vergleich", "lose Gleichheit" bezeichnet ) einen Versuch, eine Äquivalenzbeziehung zwischen Entitäten aufzubauen , die Reflexivität , Symmetrie und Transitivität einschließt . Leider schlagen zwei dieser drei grundlegenden Eigenschaften fehl:

==ist nicht reflexiv :

A == A kann falsch sein, z

NaN == NaN // false

==ist nicht transitiv :

A == Bund B == Czusammen nicht implizieren A == C, z

'1' == 1 // true
1 == '01' // true
'1' == '01' // false

Nur symmetrische Eigenschaften bleiben erhalten:

A == Bimpliziert B == A, welcher Verstoß wohl auf jeden Fall undenkbar ist und zu ernsthaften Aufständen führen würde;)

Warum sind Äquivalenzbeziehungen wichtig?

Denn das ist die wichtigste und häufigste Art von Beziehung, die durch zahlreiche Beispiele und Anwendungen gestützt wird. Die wichtigste Anwendung ist die Zerlegung von Entitäten in Äquivalenzklassen , was selbst eine sehr bequeme und intuitive Art ist, Beziehungen zu verstehen. Und das Versäumnis, Äquivalenz zu sein, führt zum Fehlen von Äquivalenzklassen, was wiederum zu einem Mangel an Intuitivität und unnötiger Komplexität führt, die allgemein bekannt sind.

Warum ist es so schrecklich, ==für eine Nichtäquivalenzbeziehung zu schreiben ?

Weil es unsere Vertrautheit und Intuition bricht, ist buchstäblich jedes interessante Verhältnis von Ähnlichkeit, Gleichheit, Kongruenz, Isomorphismus, Identität usw. eine Äquivalenz.

Typkonvertierung

Anstatt sich auf eine intuitive Äquivalenz zu verlassen, führt JavaScript die Typkonvertierung ein:

Der Gleichheitsoperator konvertiert die Operanden, wenn sie nicht vom gleichen Typ sind, und wendet dann einen strengen Vergleich an.

Aber wie ist die Typkonvertierung definiert? Über eine Reihe komplizierter Regeln mit zahlreichen Ausnahmen?

Versuch, eine Äquivalenzbeziehung aufzubauen

Boolesche. Klar trueund falsesind nicht gleich und sollten in verschiedenen Klassen sein.

Zahlen. Glücklicherweise ist die Gleichheit von Zahlen bereits klar definiert, wobei zwei verschiedene Zahlen niemals in derselben Äquivalenzklasse liegen. In der Mathematik ist das so. In JavaScript ist der Begriff der Zahl etwas deformiert durch Anwesenheit des exotischere -0, Infinityund -Infinity. Unsere mathematische Intuition schreibt vor, dass 0und -0sollte in der gleichen Klasse sein (in der Tat -0 === 0ist true), während jede der Unendlichkeiten eine eigene Klasse ist.

Zahlen und Boolesche Werte. Wo setzen wir angesichts der Zahlenklassen Boolesche Werte? falsewird ähnlich 0, wohingegen truewird ähnlich, 1aber keine andere Zahl:

true == 1 // true
true == 2 // false

Gibt es hier eine Logik, mit der man sich truezusammensetzen kann 1? Zugegebenermaßen 1wird unterschieden, aber so ist -1. Ich persönlich sehe keinen Grund , zu konvertieren truezu 1.

Und es wird noch schlimmer:

true + 2 // 3
true - 1 // 0

Also truewird in der Tat in 1unter allen Zahlen umgerechnet ! Ist es logisch Ist es intuitiv? Die Antwort bleibt als Übung;)

Aber was ist damit:

1 && true // true
2 && true // true

Der einzige boolean xmit x && trueWesen trueist x = true. Was beweist, dass beide 1und 2(und jede andere Zahl als 0) konvertieren zu true! Was es zeigt, ist, dass unsere Konvertierung eine andere wichtige Eigenschaft versagt - die Bijektion . Dies bedeutet, dass zwei verschiedene Entitäten in dieselbe konvertiert werden können. Was für sich genommen kein großes Problem sein muss. Das große Problem entsteht, wenn wir diese Umrechnung verwenden, um ein Verhältnis von "Gleichheit" oder "loser Gleichheit" zu beschreiben, wie immer wir es nennen wollen. Aber eines ist klar - es wird keine Äquivalenzbeziehung sein und es wird nicht intuitiv über Äquivalenzklassen beschrieben.

Aber können wir es besser machen?

Zumindest mathematisch - auf jeden Fall ja! Eine einfache Äquivalenzbeziehung zwischen booleans und Zahlen kann mit nur konstruiert werden falseund 0in der gleichen Klasse. Das false == 0wäre also die einzige nicht triviale lose Gleichheit.

Was ist mit Streichern?

Wir können Zeichenfolgen von Leerzeichen am Anfang und am Ende abschneiden, um sie in Zahlen umzuwandeln, und wir können Nullen vor ihnen ignorieren:

'   000 ' == 0 // true
'   0010 ' == 10 // true

Wir erhalten also eine einfache Regel für einen String - schneiden Sie die Leerzeichen und Nullen vor. Entweder erhalten wir eine Zahl oder eine leere Zeichenkette. In diesem Fall konvertieren wir in diese Zahl oder Null. Oder wir bekommen keine Zahl, in diesem Fall konvertieren wir nicht und bekommen keine neue Beziehung.

Auf diese Weise könnten wir tatsächlich eine perfekte Äquivalenzbeziehung für die Gesamtmenge der Booleschen Werte, Zahlen und Zeichenfolgen erhalten! Ausgenommen, dass ... JavaScript-Designer offensichtlich eine andere Meinung haben:

' ' == '' // false

Die beiden Zeichenfolgen, in die beide konvertieren, 0sind also plötzlich nicht mehr ähnlich! Warum oder warum? Nach der Regel sind Strings genau dann lose gleich, wenn sie genau gleich sind! Diese Regel bricht nicht nur die Transitivität, wie wir sehen, sondern ist auch überflüssig! Was bringt es, einen anderen Operator ==zu erstellen , um ihn genau mit dem anderen Operator zu identisch zu machen ===?

Fazit

Der lose Gleichheitsoperator ==hätte sehr nützlich sein können, wenn er sich an einige grundlegende mathematische Gesetze gehalten hätte. Aber wie es leider nicht tut, leidet seine Nützlichkeit.

Ja, ich habe einen Anwendungsfall dafür gefunden, nämlich wenn Sie einen Schlüssel mit einem numerischen Wert vergleichen:

for (var key in obj) {
    var some_number = foo(key, obj[key]);  // or whatever -- this is just an example
    if (key == some_number) {
        blah();
    }
}

Ich denke, es ist viel natürlicher, den Vergleich key == some_numberals als Number(key) === some_numberoder als durchzuführen key === String(some_number).

Ich bin heute auf eine ziemlich nützliche Anwendung gestoßen. Wenn Sie aufgefüllte Zahlen wie 01normale Ganzzahlen vergleichen möchten , ==funktioniert dies einwandfrei. Zum Beispiel:

'01' == 1 // true
'02' == 1 // false

Es erspart Ihnen das Entfernen der 0 und die Umwandlung in eine Ganzzahl.

Ich weiß, dass dies eine späte Antwort ist, aber es scheint einige mögliche Verwirrung darüber zu geben, nullund undefinedwelche IMHO das ==Böse macht , umso mehr, als der Mangel an Transitivität, der schlimm genug ist. Erwägen:

p1.supervisor = 'Alice';
p2.supervisor = 'None';
p3.supervisor = null;
p4.supervisor = undefined;

Was bedeuten diese?

• p1 hat einen Vorgesetzten, dessen Name "Alice" ist.
• p2 hat einen Supervisor, dessen Name "None" ist.
• p3hat ausdrücklich, eindeutig, keinen Vorgesetzten .
• p4kann oder kann einen Vorgesetzten haben. Wir wissen es nicht, es ist uns egal, wir sollten es nicht wissen (Datenschutzfrage?), Da es uns nichts angeht.

Wenn Sie verwenden ==, sind Sie in Konflikt geraten nullund undefineddas ist völlig unangemessen. Die beiden Begriffe bedeuten ganz verschiedene Dinge! Zu sagen, dass ich keinen Vorgesetzten habe, nur weil ich mich geweigert habe zu sagen, wer mein Vorgesetzter ist, ist falsch!

Ich verstehe , gibt es Programmierer , die nicht über diesen Unterschied kümmern zwischen nullund undefinedoder wählen Sie diese Begriffe anders zu verwenden. Und wenn Ihre Welt nicht verwendet nullund undefinedrichtig, oder Sie mögen Ihre eigene Interpretation zu diesen Bedingungen geben, soll es so sein. Das halte ich allerdings nicht für eine gute Idee.

Übrigens , ich habe kein Problem damit nullund undefinedbeide sind falsch! Es ist vollkommen in Ordnung zu sagen

if (p.supervisor) { ... }

und dann nullund undefinedwürde dazu führen, dass der Code, der den Supervisor verarbeitet, übersprungen wird. Das ist richtig, weil wir keinen Vorgesetzten kennen oder haben. Alles gut. Aber die beiden Situationen sind nicht gleich . Deshalb ==ist falsch. Auch hier können die Dinge falsch sein und im Enten-Tipp-Sinne verwendet werden, was sich hervorragend für dynamische Sprachen eignet. Es ist richtig, JavaScript, Pythonic, Rubyish, etc. Aber auch diese Dinge sind nicht gleich.

Und verstehen Sie mich auf nicht-Transitivität nicht gestartet: "0x16" == 10, 10 == "10"aber nicht "10" == "0x16". Ja, JavaScript ist schwach typisiert. Ja, es ist Zwang. Aber Zwang sollte niemals für Gleichheit gelten.

Crockford hat übrigens starke Meinungen. Aber weißt du was? Er ist hier richtig!

FWIW Ich verstehe, dass es Situationen gibt und ich persönlich darauf gestoßen bin, in denen ==es zweckmäßig ist! Als würde man eine Zeichenfolge für Zahlen nehmen und beispielsweise mit 0 vergleichen. Dies ist jedoch Hack. Sie haben Bequemlichkeit als Kompromiss für ein ungenaues Modell der Welt.

TL; DR: Falschheit ist ein großartiges Konzept. Es sollte sich nicht auf die Gleichstellung erstrecken.