Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Less_than below:

Kleiner als (<) - JavaScript

Baseline Widely available

Der Kleiner-als (<)-Operator gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist, und false andernfalls.

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

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

• Zuerst werden Objekte in Primitives umgewandelt, indem ihre Methoden [Symbol.toPrimitive]() (mit dem Hinweis "number"), valueOf() und toString() 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 Zahl umgewandelt 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 Werte true und false werden in 1 bzw. 0 umgewandelt.
  • null wird in 0 umgewandelt.
  • undefined wird in NaN umgewandelt.
  • Zeichenketten werden basierend auf den von ihnen enthaltenen Werten umgewandelt und in NaN umgewandelt, wenn sie keine numerischen Werte enthalten.
• Wenn einer der Werte NaN ist, gibt der Operator false 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 Operatoren false 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 ein Syntaxfehler ausgelöst, wenn er an BigInt() übergeben wird).
• Wenn einer der Operanden in NaN umgewandelt wird. (Zum Beispiel Zeichenketten, die nicht in Zahlen umgewandelt werden können, oder undefined.)

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;

Hinweis: Ein beobachtbarer Unterschied zwischen < und > ist die Reihenfolge der Umwandlung, insbesondere wenn die Umwandlung in ein Primitive Nebeneffekte hat. Alle Vergleichsoperatoren wandeln den linken Operand vor dem rechten um.

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

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

"5" < 3; // false
"3" < 3; // false
"3" < 5; // true

"hello" < 5; // false
5 < "hello"; // false

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

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

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

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

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

Warnung: Dies kann eine Quelle der Verwirrung sein. Wenn Ihre Objekte eine benutzerdefinierte Logik für die Umwandlung in Primitives bereitstellen, stellen Sie sicher, dass sie idempotent ist: Mehrere Umwandlungen sollten denselben Wert zurückgeben.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4