DerKleiner-als (<)-Operator gibttrue zurück, wenn der linke Operand kleiner als der rechte Operand ist, undfalse andernfalls.

Probieren Sie es aus

console.log(5 < 3);// Expected output: falseconsole.log(3 < 3);// Expected output: false// Compare bigint to numberconsole.log(3n < 5);// Expected output: trueconsole.log("aa" < "ab");// Expected output: true

Syntax

x < y

Beschreibung

Die Operanden werden mit mehreren Runden der Typumwandlung verglichen, die wie folgt zusammengefasst werden können:

• Zuerst werden Objektein Primitives umgewandelt, indem ihre Methoden[Symbol.toPrimitive]() (mit dem Hinweis"number"),valueOf() undtoString() in dieser Reihenfolge aufgerufen werden. Der linke Operand wird immer vor dem rechten umgewandelt. Beachten Sie, dass obwohl[Symbol.toPrimitive]() mit dem Hinweis"number" aufgerufen wird (was bedeutet, dass eine leichte Präferenz besteht, dass das Objekt zu einer Zahl wird), der Rückgabewert nicht in eine Zahlumgewandelt wird, da Zeichenketten weiterhin speziell behandelt werden.
• Wenn beide Werte Zeichenketten sind, werden sie als Zeichenketten verglichen, basierend auf den Werten der von ihnen enthaltenen UTF-16-Codeeinheiten (nicht Unicode-Codepunkten).
• Andernfalls versucht JavaScript, nicht-numerische Typen in numerische Werte umzuwandeln:
  • Die booleschen Wertetrue undfalse werden in 1 bzw. 0 umgewandelt.
  • null wird in 0 umgewandelt.
  • undefined wird inNaN umgewandelt.
  • Zeichenketten werden basierend auf den von ihnen enthaltenen Werten umgewandelt und inNaN umgewandelt, wenn sie keine numerischen Werte enthalten.
• Wenn einer der WerteNaN ist, gibt der Operatorfalse zurück.
• Andernfalls werden die Werte als numerische Werte verglichen. BigInt- und Zahlenwerte können miteinander verglichen werden.

Andere Operatoren, darunter>,>= und<=, verwenden denselben Algorithmus wie<. Es gibt zwei Fälle, in denen alle vier Operatorenfalse zurückgeben:

• Wenn einer der Operanden in einen BigInt umgewandelt wird, während der andere in eine Zeichenkette umgewandelt wird, die nicht in einen BigInt-Wert konvertiert werden kann (es wird einSyntaxfehler ausgelöst, wenn er anBigInt() übergeben wird).
• Wenn einer der Operanden inNaN umgewandelt wird. (Zum Beispiel Zeichenketten, die nicht in Zahlen umgewandelt werden können, oderundefined.)

Für alle anderen Fälle haben die vier Operatoren die folgenden Beziehungen:

x < y === !(x >= y);x <= y === !(x > y);x > y === y < x;x >= y === y <= x;

Beispiele

Vergleich von Zeichenkette zu Zeichenkette

"a" < "b"; // true"a" < "a"; // false"a" < "3"; // false"\uD855\uDE51" < "\uFF3A"; // true

Vergleich von Zeichenkette zu Zahl

"5" < 3; // false"3" < 3; // false"3" < 5; // true"hello" < 5; // false5 < "hello"; // false"5" < 3n; // false"3" < 5n; // true

Vergleich von Zahl zu Zahl

5 < 3; // false3 < 3; // false3 < 5; // true

Vergleich von Zahl zu BigInt

5n < 3; // false3 < 5n; // true

Vergleich von Boolean, null, undefined, NaN

true < false; // falsefalse < true; // true0 < true; // truetrue < 1; // falsenull < 0; // falsenull < 1; // trueundefined < 3; // false3 < undefined; // false3 < NaN; // falseNaN < 3; // false

Vergleich mit Nebeneffekten

Vergleiche zwingen always ihre Operanden in Primitives um. Dies bedeutet, dass dasselbe Objekt innerhalb eines Vergleichsausdrucks unterschiedliche Werte haben kann. Zum Beispiel können Sie zwei Werte haben, die beide größer und kleiner als der andere sind.

class Mystery {  static #coercionCount = -1;  valueOf() {    Mystery.#coercionCount++;    // The left operand is coerced first, so this will return 0    // Then it returns 1 for the right operand    return Mystery.#coercionCount % 2;  }}const l = new Mystery();const r = new Mystery();console.log(l < r && r < l);// true

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Größer als (>)
• Größer oder gleich (>=)
• Kleiner oder gleich (<=)