Welcher Gleichheitsoperator (== vs ===) sollte in JavaScript-Vergleichen verwendet werden?

Question

Ich benutze JSLint durch JavaScript zu gehen, und es werden viele Vorschläge zum Ersetzen von == (zwei Gleichheitszeichen) mit === (drei Gleichheitszeichen), wenn Sie z. B. Folgendes vergleichen idSele_UNVEHtype.value.length == 0 innerhalb eines if Erklärung.

Gibt es einen Leistungsvorteil durch den Austausch von == con === ?

Da es viele Vergleichsoperatoren gibt, wäre jede Leistungsverbesserung zu begrüßen.

Wenn keine Typkonvertierung stattfindet, gibt es dann einen Leistungsgewinn gegenüber == ?

Answer 1

JavaScript hat sowohl strikte als auch typkonvertierende Vergleiche. Ein strenger Vergleich (z. B., === ) ist nur wahr, wenn die Operanden vom gleichen Typ sind. Der häufiger verwendete abstrakte Vergleich (z. B. == ) konvertiert die Operanden in den gleichen Typ, bevor der Vergleich durchgeführt wird.

• Die Gleichheit ( == ) konvertiert die Operanden, wenn sie nicht vom gleichen Typ sind, und wendet dann einen strengen Vergleich an. Ist einer der beiden Operanden eine Zahl oder ein Boolescher Wert, werden die Operanden nach Möglichkeit in Zahlen umgewandelt; ist einer der beiden Operanden ein String, wird der String-Operand nach Möglichkeit in eine Zahl umgewandelt. Wenn beide Operanden Objekte sind, vergleicht JavaScript interne Referenzen, die gleich sind, wenn die Operanden auf dasselbe Objekt im Speicher verweisen.

  Syntax:

  x == y

  Beispiele:

  3 == 3     // true
  "3" == 3   // true
  3 == '3'   // true

• Die Identität/strenge Gleichheit( === ) gibt true zurück, wenn die Operanden streng gleich sind (siehe oben), ohne dass eine Typumwandlung stattfindet.

  Syntax:

  x === y

  Beispiele:

  3 === 3 // true

Als Referenz: _Vergleichsoperatoren_ (Mozilla-Entwickler-Netzwerk)

Answer 2

* Operatoren === vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

Answer 3

Wenn Sie eine Webanwendung oder eine gesicherte Seite erstellen, sollten Sie immer (nur wenn möglich)

===

denn es wird geprüft, ob es sich um denselben Inhalt und denselben Typ handelt!

wenn also jemand eintritt:

var check = 1;
if(check == '1') {
    //someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
}

sondern mit

var check = 1;
if(check === 1) {
    //some continued with a number (no string) for your script
} else {
    alert('please enter a real number');
}

ein Hacker wird niemals tiefer in das System eindringen, um Fehler zu finden und Ihre Anwendung oder Ihre Benutzer zu hacken

mein Punkt ist, dass die

===

bietet mehr Sicherheit für Ihre Skripte

Natürlich kann man auch mit anderen if-Anweisungen innerhalb des ersten Beispiels prüfen, ob die eingegebene Zahl gültig ist, ob es sich um eine Zeichenkette handelt, usw., aber das hier ist zumindest für mich einfacher zu verstehen und zu verwenden

Der Grund, warum ich dies gepostet habe, ist, dass das Wort "sicherer" oder "Sicherheit" in dieser Konversation nie gesagt wurde (wenn man sich iCloud.com ansieht, wird 2019 Mal === und 1308 Mal == verwendet, was auch bedeutet, dass man manchmal == anstelle von === verwenden muss, weil es sonst die Funktion blockiert, aber wie am Anfang gesagt, sollte man so oft wie möglich === verwenden)

Answer 4

Mein Denkprozess mit emacs org-mode und node.js, um einen Test durchzuführen.

| use ==     | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          | 

| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

Mein Testskript unten: run > node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}

Answer 5

=== kümmert sich darum, ob die Objekte dieselben sind. Deshalb, new String("Hello world") === "Hello world" gibt false zurück. Allerdings, == kümmert sich nicht darum, ob die Objekte gleich sind; es wandelt einfach ein Argument in den Typ des anderen um: Wenn die Umwandlung nicht möglich ist, wird false zurückgegeben. Dann new String("Hello world") == "Hello world" gibt true statt false zurück.