JSLint erwartete '===' und sah stattdessen '=='

Kürzlich habe ich einen Teil meines Codes über JSLint ausgeführt, als ich auf diesen Fehler stieß. Das, was ich an diesem Fehler lustig finde, ist, dass automatisch davon ausgegangen wird, dass alle == === sein sollten.

Macht das wirklich Sinn? Ich konnte viele Fälle sehen, in denen Sie den Typ nicht vergleichen möchten, und ich mache mir Sorgen, dass dies tatsächlich Probleme verursachen könnte.

Das Wort "Erwartet" würde bedeuten, dass dies JEDES Mal getan werden sollte ..... Das macht für mich keinen Sinn.

IMO, blind zu verwenden ===, ohne zu verstehen, wie die Typkonvertierung funktioniert, macht wenig Sinn.

Die Hauptangst gegenüber dem Operator "Gleich" ==besteht darin, dass die Vergleichsregeln in Abhängigkeit von den verglichenen Typen den Operator nicht transitiv machen können, beispielsweise wenn:

A == B AND
B == C

Garantiert das nicht wirklich:

A == C

Beispielsweise:

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

Der Operator Strict Equals ===ist nicht unbedingt erforderlich, wenn Sie Werte desselben Typs vergleichen. Dies ist das häufigste Beispiel:

if (typeof foo == "function") {
  //..
}

Wir vergleichen das Ergebnis des typeofOperators, der immer eine Zeichenfolge ist , mit einem Zeichenfolgenliteral ...

Oder wenn Sie beispielsweise die Regeln für Typzwang kennen, überprüfen Sie, ob etwas vorhanden ist nulloder nicht undefined:

if (foo == null) {
  // foo is null or undefined
}

// Vs. the following non-sense version:

if (foo === null || typeof foo === "undefined") {
  // foo is null or undefined
}

JSLint ist von Natur aus defensiver als die Javascript-Syntax zulässt.

Aus der JSLint-Dokumentation:

Die Operatoren ==und !=geben vor dem Vergleich Zwang ein. Das ist schlecht, weil es ' \t\r\n' == 0wahr ist. Dies kann Typfehler maskieren.

Verwenden Sie beim Vergleich mit einem der folgenden Werte die Operatoren ===oder !==(die keinen Typ erzwingen):0 '' undefined null false true

Wenn Sie sich nur darum kümmern, dass ein Wert wahr oder falsch ist , verwenden Sie die Kurzform. Anstatt

(foo != 0)

Sag nur

(foo)

und statt

(foo == 0)

sagen

(!foo)

Die ===und !==Operatoren werden bevorzugt.

Beachten Sie, dass JSLint die Vorstellung einer Person erzwingt, was gutes JavaScript sein sollte. Sie müssen immer noch den gesunden Menschenverstand verwenden, wenn Sie die vorgeschlagenen Änderungen implementieren.

Im Allgemeinen wird durch das Vergleichen von Typ und Wert Ihr Code sicherer (Sie werden nicht auf unerwartetes Verhalten stoßen, wenn die Typkonvertierung nicht das tut, was Sie denken).

Triple-Equal unterscheidet sich von Double-Equal, da Triple-Equal nicht nur überprüft, ob beide Seiten den gleichen Wert haben, sondern auch überprüft, ob sie denselben Datentyp haben.

So ("4" == 4)ist wahr, während ("4" === 4)falsch ist.

Triple-Equal läuft auch etwas schneller, da JavaScript keine Zeit mit Typkonvertierungen verschwenden muss, bevor Sie die Antwort erhalten.

JSLint zielt bewusst darauf ab, Ihren JavaScript-Code so streng wie möglich zu gestalten, um obskure Fehler zu reduzieren. Es wird diese Art von Dingen hervorgehoben, um zu versuchen, Sie dazu zu bringen, auf eine Weise zu codieren, die Sie dazu zwingt, Datentypen zu respektieren.

Das Gute an JSLint ist jedoch, dass es nur eine Anleitung ist. Wie sie auf der Website sagen, wird es Ihre Gefühle verletzen, selbst wenn Sie ein sehr guter JavaScript-Programmierer sind. Aber Sie sollten sich nicht verpflichtet fühlen, seinem Rat zu folgen. Wenn Sie gelesen haben, was es zu sagen hat, und Sie es verstehen, aber Sie sicher sind, dass Ihr Code nicht kaputt geht, müssen Sie nichts ändern.

Sie können JSLint sogar anweisen, Überprüfungskategorien zu ignorieren, wenn Sie nicht mit Warnungen bombardiert werden möchten, gegen die Sie nichts unternehmen werden.

Ein Zitat von http://javascript.crockford.com/code.html :

=== und! == Operatoren.

Es ist fast immer besser, die Operatoren === und! == zu verwenden. Die Operatoren == und! = Geben Zwang ein. Verwenden Sie insbesondere nicht ==, um mit falschen Werten zu vergleichen.

JSLint ist sehr streng, ihre 'webjslint.js' besteht nicht einmal ihre eigene Validierung.

Wenn Sie auf Falschheit testen möchten. JSLint erlaubt nicht

if (foo == null)

aber erlaubt

if (!foo)

Um diese Frage zu erklären und um zu erklären, warum NetBeans (ab) 7.3 diese Warnung anzeigt, ist dies ein Auszug aus der Antwort auf den NetBeans-Bug-Tracker, als jemand dies als Fehler meldete:

Es wird empfohlen, in JavaScript === anstelle von == zu verwenden.

Die Operatoren == und! = Geben vor dem Vergleich Zwang ein. Dies ist schlecht, da dadurch '\ t \ r \ n' == 0 wahr wird. Dies kann Typfehler maskieren. JSLint kann nicht zuverlässig feststellen, ob == korrekt verwendet wird. Daher ist es am besten, == und! = Überhaupt nicht zu verwenden und stattdessen immer die zuverlässigeren Operatoren === und! == Zu verwenden.

Referenz

Nun, es kann nicht wirklich Probleme verursachen, es gibt Ihnen nur Ratschläge. Nimm es oder lass es. Trotzdem bin ich mir nicht sicher, wie schlau es ist. Es kann durchaus Kontexte geben, in denen es nicht als Problem dargestellt wird.