Number.prototype.toExponential() — Methode · JavaScript-Referenz

Signatur

Number.prototype.toExponential(fractionDigits)

Beschreibung

toExponential() wandelt eine Zahl in die wissenschaftliche Schreibweise um: genau eine Ziffer vor dem Dezimalpunkt, danach die Nachkommastellen, dann e, ein Vorzeichen (+ oder -) und der Exponent zur Basis 10. Aus 123456 wird z. B. "1.23456e+5".

Mit dem Parameter fractionDigits legst du fest, wie viele Stellen nach dem Dezimalpunkt stehen sollen. Die Zahl wird dabei gerundet oder bei Bedarf mit Nullen aufgefüllt. Lässt du den Parameter weg, verwendet die Methode so viele Stellen, wie nötig sind, um den Wert eindeutig darzustellen.

Sinnvoll ist die Methode überall, wo sehr große oder sehr kleine Werte lesbar und mit einheitlicher Genauigkeit angezeigt werden sollen: physikalische Konstanten, Messwerte, Logausgaben, wissenschaftliche Tabellen oder Diagrammbeschriftungen. Das Ergebnis ist immer ein string. Mit Number() oder parseFloat() kannst du ihn wieder in eine Zahl umwandeln.

Parameter

Name	Typ	Default	Beschreibung
$fractionDigits	number \| undefined	undefined (so viele Stellen wie nötig)	Ganzzahl zwischen `0` und `100` (einschließlich): Anzahl der Stellen nach dem Dezimalpunkt. Nicht-ganzzahlige Werte werden abgeschnitten (`2.9` wird zu `2`). Außerhalb des Bereichs wird ein `RangeError` ausgelöst.

Rückgabewert

Typ

string

Beschreibung

Die Zahl in exponentieller Notation, z. B. "1.23e+5". Bei NaN, Infinity und -Infinity kommen die Zeichenketten "NaN", "Infinity" bzw. "-Infinity" zurück.

Beispiele

Grundlagen: mit und ohne fractionDigits

const n = 123456;

console.log(n.toExponential());   // so viele Stellen wie nötig
console.log(n.toExponential(2));  // 2 Nachkommastellen, gerundet
console.log(n.toExponential(7));  // mit Nullen aufgefüllt
console.log((0.00015).toExponential(1)); // negativer Exponent
console.log((-1234.5).toExponential(1)); // negatives Vorzeichen

1.23456e+5 1.23e+5 1.2345600e+5 1.5e-4 -1.2e+3

Messwerte einheitlich formatieren

const konstanten = {
  Avogadro: 6.02214076e23,
  Planck: 6.62607015e-34,
  Lichtgeschwindigkeit: 299792458
};

for (const [name, wert] of Object.entries(konstanten)) {
  console.log(`${name.padEnd(20)} ${wert.toExponential(3)}`);
}

Avogadro 6.022e+23 Planck 6.626e-34 Lichtgeschwindigkeit 2.998e+8

Zahlenliterale, Rückumwandlung und Fehlerfall

// Bei Ganzzahl-Literalen Klammern oder zwei Punkte verwenden:
console.log((77).toExponential());
console.log(77..toExponential());

// Zurück in eine Zahl umwandeln
const s = (98765).toExponential(2);
console.log(s, Number(s));

// Ungültiger Bereich
try {
  (1).toExponential(101);
} catch (err) {
  console.log(err.name);
}

7.7e+1 7.7e+1 9.88e+4 98800 RangeError

Rundungsverhalten und Sonderwerte

console.log((2.5).toExponential(0));    // exakt halb, wird aufgerundet
console.log((1.005).toExponential(2));  // Gleitkomma: 1.00499999...
console.log(NaN.toExponential(2));
console.log((-Infinity).toExponential());
console.log((0).toExponential(2));

3e+0 1.00e+0 NaN -Infinity 0.00e+0

// Wichtig · Fallstricke

Syntaxfalle bei Literalen: 77.toExponential() ist ein SyntaxError, weil der Punkt als Dezimalpunkt gelesen wird. Schreibe stattdessen (77).toExponential() oder 77..toExponential().
Gleitkomma-Rundung: Gerundet wird der tatsächlich gespeicherte Binärwert. Deshalb ergibt (1.005).toExponential(2) den Wert "1.00e+0" und nicht "1.01e+0". Für exakte Rundung im Geld- oder Finanzbereich brauchst du Ganzzahl-Arithmetik oder eine Dezimal-Bibliothek.
Wertebereich: Vor ES2018 war nur 0–20 erlaubt, heute sind es 0–100. Sehr alte Engines lösen deshalb schon bei Werten über 20 einen RangeError aus.
Präzision: Ein number hat nur rund 15–17 signifikante Stellen. Größere Werte für fractionDigits zeigen deshalb Binärartefakte statt echter Genauigkeit.
Kein Zahlentyp: Das Ergebnis ist ein string. Rechnen mit + verkettet also Zeichenketten. Wandle vorher mit Number() um.
Der Aufruf auf einem Nicht-Number-Wert (z. B. über call) löst einen TypeError aus. Auf BigInt gibt es die Methode nicht.
Die Ausgabe ist nicht lokalisiert, der Dezimaltrenner ist immer ein Punkt. Für eine lokalisierte wissenschaftliche Schreibweise gibt es Intl.NumberFormat mit { notation: "scientific" }.

Siehe auch

Number.prototype.toFixed() Number.prototype.toPrecision() Number.prototype.toString() Number.prototype.toLocaleString() Intl.NumberFormat parseFloat() Number