Signatur
Beschreibung
Der Divisionsoperator / ist ein binärer arithmetischer Operator, der den Quotienten zweier Operanden berechnet. Der linke Operand ist der Dividend (die zu teilende Zahl), der rechte Operand ist der Divisor (die Zahl, durch die geteilt wird). Das Ergebnis ist eine JavaScript-Zahl vom Typ number (64-Bit-IEEE-754-Gleitkommazahl).
Im Gegensatz zu vielen anderen Programmiersprachen führt JavaScript die Division grundsätzlich als Gleitkomma-Division durch – auch bei zwei ganzzahligen Operanden. So ergibt 5 / 2 den Wert 2.5 und nicht 2. Soll das Ergebnis ganzzahlig sein, muss es explizit mit Math.trunc(), Math.floor() oder dem bitweisen OR-Trick (| 0) abgeschnitten werden.
Besondere Fälle zu beachten: Division durch 0 liefert nicht etwa einen Fehler, sondern Infinity (oder -Infinity bei negativem Dividend). Division von 0 durch 0 ergibt NaN. Nicht-numerische Operanden werden vor der Operation implizit in Zahlen konvertiert (via ToNumber). Wenn die Konvertierung scheitert, ist das Ergebnis NaN.
Der Operator folgt den üblichen Vorrang-Regeln: Er hat denselben Vorrang wie Multiplikation (*) und Modulo (%) und wird von links nach rechts ausgewertet (linksassoziativ). Addition und Subtraktion haben einen niedrigeren Vorrang, sodass 4 + 8 / 2 als 4 + (8 / 2) = 8 ausgewertet wird.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $dividend Pflicht | number | bigint | string | any | Der Dividend – die Zahl, die geteilt werden soll. Nicht-numerische Werte werden implizit mit ToNumber() konvertiert. BigInt-Werte sind erlaubt, müssen aber mit einem BigInt-Divisor kombiniert werden. |
|
| $divisor Pflicht | number | bigint | string | any | Der Divisor – die Zahl, durch die geteilt wird. Division durch 0 ergibt Infinity, -Infinity oder NaN; gemischte Typen (z. B. number und bigint) werfen einen TypeError. |
Rückgabewert
number (Gleitkomma) oder als bigint, wenn beide Operanden vom Typ bigint sind. Bei BigInt-Division wird das Ergebnis zur Null hin abgeschnitten (Trunkierung).Beispiele
Grundlegende Divisionsbeispiele
console.log(10 / 2); // 5
console.log(7 / 2); // 3.5 – Gleitkomma-Division!
console.log(-12 / 4); // -3
console.log(0.9 / 0.3); // 2.9999999999999996 – IEEE-754-UngenauigkeitSonderfälle: Division durch 0 und NaN
console.log(5 / 0); // Infinity
console.log(-5 / 0); // -Infinity
console.log(0 / 0); // NaN
console.log('abc' / 2); // NaN – Konvertierung schlägt fehlGanzzahlige Division mit Math.trunc()
const dividend = 17;
const divisor = 5;
const quotient = Math.trunc(dividend / divisor);
const remainder = dividend % divisor;
console.log(`${dividend} / ${divisor} = ${quotient} Rest ${remainder}`);
// Ausgabe: 17 / 5 = 3 Rest 2BigInt-Division (Trunkierung statt Gleitkomma)
const a = 17n;
const b = 5n;
console.log(a / b); // 3n – kein Rest, wird zur Null hin abgeschnitten
console.log(-17n / 5n); // -3nOperatorvorrang beachten
// Division hat höheren Vorrang als Addition
console.log(4 + 8 / 2); // 4 + 4 = 8
console.log((4 + 8) / 2); // 12 / 2 = 6
// Linksassoziativität bei gleicher Priorität
console.log(100 / 10 / 2); // (100 / 10) / 2 = 5// Wichtig · Fallstricke
IEEE-754-Gleitkomma-Ungenauigkeiten: Da JavaScript intern den 64-Bit-Gleitkommastandard IEEE 754 verwendet, können Divisionen dezimaler Zahlen zu unerwarteten Rundungsfehlern führen (z. B. 0.9 / 0.3 !== 3). Für präzise Berechnungen empfiehlt sich die Arbeit mit ganzen Zahlen (z. B. Cent statt Euro) oder eine Bibliothek wie decimal.js.
Gemischte Typen mit BigInt: Das Kombinieren von bigint und number in einer Division wirft einen TypeError. Beide Operanden müssen explizit in denselben Typ konvertiert werden: BigInt(5) / 2n oder Number(10n) / 2.
Implizite Typkonvertierung: Strings, die gültige Zahlen enthalten (z. B. "8"), werden automatisch konvertiert: "8" / 2 ergibt 4. Dies kann in dynamisch typisierten Kontexten zu schwer auffindbaren Fehlern führen – daher im Zweifel explizit mit Number() oder parseFloat() konvertieren.