mitmario.dev

Zahlen formatieren

JavaScript Im Browser 3 Min Lesezeit 4 BeispieleLektion 4 von 6

Eine Zahl im Speicher und eine Zahl auf dem Bildschirm sind zwei verschiedene Dinge. 1234.5 ist die eine, 1.234,50 € die andere, und um den Weg dazwischen geht es hier. Datum und Uhrzeit kommen erst in Abschnitt 19, denn dort gehören sie mit Date zusammen.

Nachkommastellen festzurren

toFixed und der Typwechsel
const wert = 2 / 3;
console.log("Roh:", wert);

// Auf zwei Nachkommastellen, gerundet.
console.log("Zwei Stellen:", wert.toFixed(2));

// Es füllt auch auf, wenn die Stellen fehlen.
console.log("Aufgefüllt:", (5).toFixed(2));

// Und jetzt der Punkt: das Ergebnis ist ein Text.
console.log("Typ:", typeof wert.toFixed(2));

// Damit rechnet man nicht mehr, sondern verkettet.
console.log("Plus 1:", wert.toFixed(2) + 1);

// Zurück in eine Zahl geht mit Number, siehe Lektion 2.7.
console.log("Wieder Zahl:", Number(wert.toFixed(2)) + 1);

// Der Punkt bleibt dabei ein Punkt. Ein deutsches Komma
// macht toFixed nicht daraus.

toFixed schneidet eine Zahl auf eine feste Zahl von Nachkommastellen und rundet dabei. Es füllt auch auf. Sind zwei Stellen verlangt, wird aus 5 ein 5.00, und für Preise ist das gewollt.

toFixed liefert einen Text. Das steht in keiner Fehlermeldung und fällt erst auf, wenn du damit weiterrechnest. wert.toFixed(2) + 1 verkettet dann, statt zu addieren, wie beim Plus mit Text in Abschnitt 2.

In der Eingabezeile der Console antwortet (5).toFixed(2) mit "5.00" in Anführungszeichen. An denen erkennst du den Text. In der eigenen Ausgabe steht dagegen 5.00 ohne alles, und daran siehst du nicht, was du in der Hand hast.

Zurück geht es mit Number. Die bessere Frage ist aber, ob man überhaupt hin musste. Ich formatiere erst ganz am Schluss, wenn etwas ausgegeben wird. Bis dahin rechne ich mit Zahlen, und das Problem stellt sich gar nicht.

Die Ungenauigkeit von Kommazahlen aus der Lektion über Zahlen trifft auch toFixed. (2.675).toFixed(2) ergibt "2.67" und nicht "2.68", weil 2.675 im Rechner ein winziges Stück kleiner ist. Und der Punkt bleibt ein Punkt. Eine deutsche Schreibweise kennt toFixed nicht, dafür gibt es weiter unten Intl.NumberFormat.

Runden bei negativen Zahlen

round, floor und ceil bei negativen Zahlen
// Bei positiven Zahlen ist alles wie erwartet.
console.log("round 2.5:", Math.round(2.5));
console.log("floor 2.5:", Math.floor(2.5));
console.log("ceil 2.5:", Math.ceil(2.5));

// Bei negativen Zahlen wird es interessant.
console.log("round -2.5:", Math.round(-2.5));
console.log("floor -2.5:", Math.floor(-2.5));
console.log("ceil -2.5:", Math.ceil(-2.5));

// Bei genau einem halben geht round zur größeren Zahl, nicht
// vom Nullpunkt weg. Deshalb wird aus -2.5 die -2 und nicht die -3.
console.log("round -2.4:", Math.round(-2.4));
console.log("round -2.6:", Math.round(-2.6));

Math.round rundet auf die nächste ganze Zahl, Math.floor immer ab und Math.ceil immer auf. Bei positiven Zahlen ist das unauffällig.

Bei negativen Zahlen überrascht Math.round. Aus -2.5 wird -2 und nicht -3, denn bei genau einem halben geht Math.round zur größeren Zahl und nicht von der Null weg. Bei 2.5 merkst du davon nichts, weil beide Regeln dasselbe Ergebnis haben. toFixed und Intl.NumberFormat halten es anders. Bei ihnen wird aus -2.5 eine -3.

Auch floor und ceil verhalten sich bei negativen Zahlen leicht anders, als man denkt. floor geht Richtung minus unendlich, aus -2.5 wird also -3.

Geld rechnet dieser Kurs ohnehin in Cent. Gerundet wird dann nur an einer Stelle, und diese Sonderfälle kommen selten vor.

Der richtige Weg

Intl.NumberFormat
const zahl = 1234567.891;

// Deutsche Schreibweise: Punkt als Tausendertrenner,
// Komma als Dezimaltrenner.
console.log("Deutsch:", new Intl.NumberFormat("de-DE").format(zahl));

// Zum Vergleich die englische, genau andersherum.
console.log("Englisch:", new Intl.NumberFormat("en-US").format(zahl));

// Feste Nachkommastellen, hier immer zwei.
const zweiStellen = new Intl.NumberFormat("de-DE", {
  minimumFractionDigits: 2,
  maximumFractionDigits: 2,
});
console.log("Zwei Stellen:", zweiStellen.format(1234.5));

// Währung: Zeichen und Stellung kommen aus der Sprache.
const euro = new Intl.NumberFormat("de-DE", {
  style: "currency",
  currency: "EUR",
});
console.log("Euro:", euro.format(1234.5));
console.log("Null Euro:", euro.format(0));

// Und Prozent, das rechnet gleich mal hundert.
const prozent = new Intl.NumberFormat("de-DE", { style: "percent" });
console.log("Prozent:", prozent.format(0.25));

Intl.NumberFormat ist der Teil des Browsers, der weiß, wie Zahlen in verschiedenen Sprachen geschrieben werden. Mit einer Sprachkennung (englisch locale), hier de-DE, legst du einen Formatierer an, den du danach beliebig oft benutzen kannst.

Aus dieser einen Angabe folgt alles Weitere. Der Tausenderpunkt, das Komma vor den Nachkommastellen und das Euro-Zeichen hinter der Zahl. Im Englischen ist es andersherum, und umbauen musst du dafür nichts.

Im zweiten Argument stellst du ein, was formatiert wird. minimumFractionDigits und maximumFractionDigits legen die Nachkommastellen fest. style: "currency" mit currency: "EUR" macht eine Währung daraus, und style: "percent" rechnet gleich mal hundert.

Ich lege den Formatierer einmal an und benutze ihn wieder, statt ihn in einer Schleife jedes Mal neu zu bauen.

Der Weg von Hand

Warum nicht von Hand
const euro = new Intl.NumberFormat("de-DE", {
  style: "currency",
  currency: "EUR",
});

// Der naive Weg mit replace sieht zuerst richtig aus.
function vonHand(zahl) {
  return zahl.toFixed(2).replace(".", ",") + " Euro";
}

console.log("Von Hand:", vonHand(19.9));
console.log("Fertig:", euro.format(19.9));

// Bei größeren Zahlen fehlt der Tausenderpunkt.
console.log("Von Hand:", vonHand(1234567.5));
console.log("Fertig:", euro.format(1234567.5));

// Das Leerzeichen vor dem Währungszeichen ist übrigens keines.
// Es ist ein geschütztes, damit die Zeile dort nicht umbricht.
const fertig = euro.format(19.9);
console.log("Gewöhnliches Leerzeichen darin:", fertig.includes(" "));
console.log("Zeichencode an Stelle 5:", fertig.charCodeAt(5));

Der naive Weg ist verlockend. toFixed(2), dann den Punkt gegen ein Komma tauschen, dann " Euro" anhängen. Drei Handgriffe, und bei 19,90 Euro stimmt es sogar.

Bei größeren Zahlen fehlt aber der Tausenderpunkt. Den müsstest du selbst einbauen, von rechts nach links in Dreiergruppen, und spätestens dann wird aus der einen Zeile eine Funktion mit einer Schleife. Danach kommen negative Zahlen, andere Währungen und Sprachen, in denen das Zeichen vorn steht.

Das geht alles. Nur hat es schon jemand gemacht, es ist im Browser eingebaut, und die Fassung dort kennt auch die Fälle, an die man selbst nicht denkt.

Einer davon steht am Ende des Beispiels. Zwischen Zahl und Euro-Symbol steht kein gewöhnliches Leerzeichen, sondern ein geschütztes mit dem Zeichencode 160, und an diesem Zeichen bricht die Zeile nicht um. Man sieht es nicht. Wer den formatierten Text später auf ein gewöhnliches Leerzeichen prüft, sucht lange.

In der Aufgabe bringen drei kleine Funktionen Zahlen in Form. Einmal als Euro, einmal mit zwei Nachkommastellen und einmal gerundet.

Zum Mitnehmen

toFixed liefert einen Text und keine Zahl, und Intl.NumberFormat setzt eine Zahl so, wie sie im Deutschen geschrieben wird. Gerechnet wird mit Zahlen, formatiert erst zur Ausgabe.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.