String-Gleichheit in JavaScript prüfen

1. Wann man einen Operator für String-Gleichheit in JavaScript verwendet
2. Verstehen Sie die String-Gleichheit in JavaScript mit Beispielen

In JavaScript gibt es vier Operatoren, die Sie verwenden können, um die Zeichenkettengleichheit zu überprüfen. Diese Operatoren werden als Vergleichsoperatoren bezeichnet.

1. Strenge Gleichheit (===): Die Strenge Gleichheit (auch bekannt als der Dreifach-Gleichheits-Operator) prüft den Wert der Variablen und ihren Datentyp. Wenn beides gleich ist, dann gibt es nur true zurück, andernfalls gibt es false zurück.
2. Streng ungleich (!==): Dies ist das Gegenteil von Streng gleich. Wenn Wert oder Datentyp nicht übereinstimmen, wird true zurückgegeben; andernfalls false.
3. Gleich (==): Das doppelte Gleichheitszeichen prüft nur den Wert einer Variablen. Wenn der Wert übereinstimmt, wird true zurückgegeben, andernfalls wird false zurückgegeben. Der Variablentyp ist ihm egal.
4. Ungleich (!=): Dies ist das Gegenteil von Gleich (==). Sie gibt nur dann true zurück, wenn die Werte in den Variablen nicht übereinstimmen, unabhängig von ihrem Datentyp. Stimmen die Werte miteinander überein, dann wird false zurückgegeben.

Diese Operatoren werden nicht nur zur Prüfung der String-Gleichheit verwendet, sondern auch zur Prüfung der Gleichheit anderer Datentypen. Lassen Sie uns aus diesen vier Operatoren den besten für die Prüfung der String-Gleichheit je nach Anwendungsfall herausfinden.

Vielleicht haben Sie schon den 3. und 4. Operator gesehen, also == und !=, die auch in anderen Programmiersprachen recht häufig vorkommen. Aber die Funktionsweise in JavaScript unterscheidet sich ein wenig von anderen Sprachen.

Wann man einen Operator für String-Gleichheit in JavaScript verwendet

In Verbindung mit JavaScript sind nachfolgend einige Anwendungsfälle aufgeführt, in denen Sie einen der Operatoren === oder == verwenden können.

• Wenn ein Vergleichswert entweder true oder false sein könnte, verwenden Sie === und nicht ==.
• Wenn ein Vergleichswert einer dieser spezifischen Werte sein könnte (0, "" oder [] – leeres Array), verwenden Sie === anstelle von ==.
• In allen anderen Fällen können Sie == verwenden. Es ist nicht nur sicher, sondern vereinfacht auch Ihren Code und verbessert die Lesbarkeit.

Dieselben obigen Regeln gelten auch, wenn die Operatoren Streng ungleich (!==) und Nicht gleich (!=) verwendet werden. Um mehr über die spezifischen Regeln zu erfahren, können Sie den Abschnitt 11.9.3 der ES5-Spezifikation lesen.

Verstehen Sie die String-Gleichheit in JavaScript mit Beispielen

Nehmen wir einige Beispiele und verstehen diese Dinge im Detail.

In diesem Beispiel haben wir zwei Variablen genommen, name_1 und name_2. Beide nehmen "adam" als String-Wert. Wenden wir nun jeden der obigen Operatoren an und sehen wir uns die Ausgabe an, die wir erhalten.

Hier haben wir vier if- und else-Anweisungen verwendet, die jeweils unterschiedliche Vergleichsoperatoren darstellen. Da sowohl der Wert als auch der Datentyp für die Variablen name_1 und name_2 gleich sind, gibt der Operator Triple-Equals oder Strict-Equal (===) True als Ausgabe aus. Und das doppelte Gleiche == gibt auch True aus, da beide Variablen die gleichen Werte haben.

let name_1 = 'adam';
let name_2 = 'adam';

// Strict Equal
if (name_1 === name_2)
  console.log('True');
else
  console.log('False');

// Equal
if (name_1 == name_2)
  console.log('True');
else
  console.log('False');

// Strict not equal
if (name_1 !== name_2)
  console.log('True');
else
  console.log('False');

// Not equal
if (name_1 != name_2)
  console.log('True');
else
  console.log('False');

Ausgabe:

True
True
False
False

Wenn die Operatoren Streng ungleich (!==) und ungleich (!=) verwendet werden, geben beide als Ausgabe False aus, da der Wert selbst in beiden Variablen gleich ist.

Unten ist ein weiteres Beispiel, in dem wir eine Zeichenkette mit einer Ganzzahl vergleichen. Hier haben wir eine Variable str mit dem Wert "80", einen String-Wert. Wir haben eine weitere Variable, num, die einen ganzzahligen Wert von "80" enthält. Da diese beiden Variablen dieselben Werte mit unterschiedlichen Datentypen haben, sehen wir uns an, was passiert, wenn die verschiedenen Vergleichsoperatoren für sie verwendet werden.

let str = '80';
let num = 80;

// Strict Equal
if (str === num)
  console.log('True');
else
  console.log('False')

  // Equal
  if (str == num) console.log('True');
else console.log('False')

// Strict not equal
if (str !== num) console.log('True');
else console.log('False')

// Not equal
if (str != num) console.log('True');
else console.log('False')

Ausgabe:

False
True
True
False

Wie im ersten Beispiel haben wir auch vier if- und else-Anweisungen, die jeweils unterschiedliche Vergleichsoperatoren darstellen.

Wenn wir Strict-Equals oder Triple-Equals (===) verwenden, erhalten wir als Ausgabe False. Der Grund dafür ist, dass der Datentyp unterschiedlich ist, obwohl die Werte gleich sind. Aber wenn wir double equals (==) verwenden, erhalten wir True als Ausgabe, da double equals nur den Wert und nicht den Typ prüfen.

Und wenn wir Streng ungleich (!==) verwenden, erhalten wir True als Ausgabe, weil der String-Wert 80 nicht gleich dem ganzzahligen Wert 80 ist; daher gibt es True zurück.

Schließlich vergleicht der Ungleich-Operator (!=) nur den Wert der beiden Variablen. Die Werte müssen unterschiedlich sein, damit True ausgegeben wird. Da die Werte in diesem Fall gleich sind, wird False zurückgegeben.