Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

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

js
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() und toString() 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 true und false werden in 1 beziehungsweise 0 umgewandelt.
    • null wird in 0 umgewandelt.
    • undefined wird in NaN umgewandelt.
    • Strings werden anhand ihres Inhalts umgewandelt. Enthalten sie keinen numerischen Wert, werden sie in NaN umgewandelt.
  • Wenn einer der Werte NaN ist, gibt der Operator false zurü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 NaN umgewandelt wird. (Dies gilt beispielsweise für Strings, die nicht in Zahlen umgewandelt werden können, oder für undefined.)

In allen anderen Fällen gelten für die vier Operatoren die folgenden Beziehungen:

js
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

js
"a" < "b"; // true
"a" < "a"; // false
"a" < "3"; // false

"\uD855\uDE51" < "\uFF3A"; // true

Vergleich von Strings mit Zahlen

js
"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

js
5 < 3; // false
3 < 3; // false
3 < 5; // true

Vergleich von Zahlen mit BigInt-Werten

js
5n < 3; // false
3 < 5n; // true

Vergleich von booleschen Werten, null, undefined und NaN

js
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.

js
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

Browser-Kompatibilität

Siehe auch