Kleiner als (<)
Baseline
Weitgehend verfügbar
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Der Operator Kleiner als (<) gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist, andernfalls false.
Probieren Sie es aus
console.log(5 < 3);
// Expected output: false
console.log(3 < 3);
// Expected output: false
// Compare bigint to number
console.log(3n < 5);
// Expected output: true
console.log("aa" < "ab");
// Expected output: true
Syntax
x < y
Beschreibung
Die Operanden werden in mehreren Schritten der Typumwandlung verglichen. Der Ablauf lässt sich wie folgt zusammenfassen:
- Zunächst werden Objekte in primitive Werte umgewandelt. Dazu werden ihre Methoden
[Symbol.toPrimitive]()(mit"number"als Hint),valueOf()undtoString()in dieser Reihenfolge aufgerufen. Der linke Operand wird immer vor dem rechten umgewandelt. Obwohl[Symbol.toPrimitive]()mit dem Hint"number"aufgerufen wird (das heißt, eine Umwandlung des Objekts in eine Zahl wird leicht bevorzugt), wird der Rückgabewert nicht in eine Zahl umgewandelt, da Strings weiterhin gesondert behandelt werden. - Wenn beide Werte Strings sind, werden sie als Strings verglichen. Maßgeblich sind dabei die Werte der enthaltenen UTF-16-Codeeinheiten (nicht der Unicode-Codepunkte).
- Andernfalls versucht JavaScript, nicht numerische Typen in numerische Werte umzuwandeln:
- Die booleschen Werte
trueundfalsewerden in 1 beziehungsweise 0 umgewandelt. nullwird in 0 umgewandelt.undefinedwird inNaNumgewandelt.- Strings werden anhand ihres Inhalts umgewandelt. Enthalten sie keinen numerischen Wert, werden sie in
NaNumgewandelt.
- Die booleschen Werte
- Wenn einer der Werte
NaNist, gibt der Operatorfalsezurück. - Andernfalls werden die Werte als numerische Werte verglichen. BigInt- und Number-Werte können miteinander verglichen werden.
Andere Operatoren, darunter >, >= und <=, verwenden denselben Algorithmus wie <. In zwei Fällen geben alle vier Operatoren false zurück:
- Wenn einer der Operanden in einen BigInt umgewandelt wird, während der andere in einen String umgewandelt wird, der nicht in einen BigInt-Wert umgewandelt werden kann (und bei der Übergabe an
BigInt()einen Syntaxfehler auslöst). - Wenn einer der Operanden in
NaNumgewandelt wird. (Dies gilt beispielsweise für Strings, die nicht in Zahlen umgewandelt werden können, oder fürundefined.)
In allen anderen Fällen gelten für die vier Operatoren die folgenden Beziehungen:
x < y === !(x >= y);
x <= y === !(x > y);
x > y === y < x;
x >= y === y <= x;
Hinweis:
Ein beobachtbarer Unterschied zwischen < und > ist die Reihenfolge der Typumwandlung, insbesondere wenn die Umwandlung in einen primitiven Wert Nebenwirkungen hat. Alle Vergleichsoperatoren wandeln den linken Operanden vor dem rechten um.
Beispiele
>Vergleich von Strings mit Strings
"a" < "b"; // true
"a" < "a"; // false
"a" < "3"; // false
"\uD855\uDE51" < "\uFF3A"; // true
Vergleich von Strings mit Zahlen
"5" < 3; // false
"3" < 3; // false
"3" < 5; // true
"hello" < 5; // false
5 < "hello"; // false
"5" < 3n; // false
"3" < 5n; // true
Vergleich von Zahlen mit Zahlen
5 < 3; // false
3 < 3; // false
3 < 5; // true
Vergleich von Zahlen mit BigInt-Werten
5n < 3; // false
3 < 5n; // true
Vergleich von booleschen Werten, null, undefined und NaN
true < false; // false
false < true; // true
0 < true; // true
true < 1; // false
null < 0; // false
null < 1; // true
undefined < 3; // false
3 < undefined; // false
3 < NaN; // false
NaN < 3; // false
Vergleich mit Nebenwirkungen
Bei Vergleichen werden die Operanden immer in primitive Werte umgewandelt. Das bedeutet, dass dasselbe Objekt innerhalb eines Vergleichsausdrucks unterschiedliche Werte annehmen kann. Beispielsweise kann jeder von zwei Werten sowohl größer als auch kleiner als der jeweils andere sein.
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
Warnung: Das kann verwirrend sein. Wenn Ihre Objekte eine eigene Logik zur Umwandlung in primitive Werte bereitstellen, stellen Sie sicher, dass diese idempotent ist: Wiederholte Umwandlungen sollten denselben Wert zurückgeben.
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-relational-operators> |