Epsilon-Vergleich in JavaScript: Wann und wie man mit Gleitkomma-Genauigkeit umgeht

Published on 19. Dezember 2025

In der Welt der Programmierung ist es alltäglich, dass man mit Zahlen arbeitet – oft mit Gleitkommanummern (Floating-Point-Zahlen). Doch bei genauem Hinsehen zeigt sich, dass JavaScript (und viele andere Sprachen) mit diesen Zahlen nicht immer so präzise umgehen können wie man es erwarten würde. Ein klassisches Beispiel dafür ist die Aussage:

console.log(0.1 + 0.2 === 0.3); // false

Das mag zunächst verwirrend sein – aber es ist ein wichtiger Mechanismus, den wir verstehen und korrekt anwenden müssen. In diesem Blog-Post erfährst du alles über Epsilon-Vergleiche in JavaScript: Wie sie funktionieren, warum sie nötig sind, welche Best Practices es gibt und wie du sie effektiv einsetzen kannst.

Was ist ein Epsilon-Vergleich?

Ein Epsilon-Vergleich ist eine Methode zur Prüfung von Gleichheit zwischen zwei Gleitkommazahlen, bei der ein kleiner Toleranzwert (der sogenannte Epsilon) verwendet wird. Statt a === b zu prüfen, vergleicht man:

Math.abs(a - b) < epsilon

Dieser Ansatz berücksichtigt die begrenzte Genauigkeit von Gleitkomma-Zahlen und verhindert falsche Negativ-Ergebnisse bei Berechnungen, die aufgrund von Rundungsfehlern nicht exakt sind.

Warum funktioniert 0.1 + 0.2 === 0.3 nicht wie erwartet?

Um zu verstehen, warum JavaScript manchmal „falsche“ Ergebnisse liefert, betrachten wir die interne Darstellung von Gleitkommazahlen.

IEEE 754-Standard

JavaScript verwendet den IEEE 754-Standard für Gleitkommaarithmetik (auch bekannt als Double Precision). Bei dieser Darstellung werden Dezimalzahlen nicht immer exakt gespeichert. Zum Beispiel:

console.log(0.1); // 0.1
console.log(0.2); // 0.2
console.log(0.3); // 0.3

// Aber:
console.log(0.1 + 0.2); // 0.30000000000000004

Der Grund dafür liegt daran, dass die Dezimalzahlen 0.1 und 0.2 nicht als endliche Binärzahlen dargestellt werden können. Daher entstehen kleine Rundungsfehler, die sich bei Berechnungen summieren.

📐 Epsilon-Werte: Wie groß sollte er sein?

Die Wahl des Epsilon-Werts ist entscheidend:

Epsilon-WertVerwendungszweck
1e-10Allgemeine Berechnungen
1e-15Sehr präzise Berechnungen
Number.EPSILONNatürliche, standardisierte Toleranz

Beispiel mit Number.EPSILON

function nearlyEqual(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}

console.log(nearlyEqual(0.1 + 0.2, 0.3)); // true

Number.EPSILON ist definiert als der kleinste Wert, der zur Zahl 1 addiert werden kann, um einen anderen Wert zu erhalten. Es ist also die natürliche Toleranz für Gleitkomma-Vergleiche in JavaScript.

🧪 Anwendungsfälle für Epsilon-Vergleiche

Epsilon-Vergleiche sind besonders nützlich in folgenden Szenarien:

1. Mathematische Berechnungen

Bei Trigonometrie, Wurzelberechnungen oder anderen mathematischen Funktionen kann es zu Rundungsfehlern kommen.

const result = Math.sin(Math.PI / 2);
console.log(result === 1); // false – stattdessen:
console.log(Math.abs(result - 1) < Number.EPSILON); // true

2. Koordinaten- und Grafikberechnungen

In Spielen oder Visualisierungen werden oft Positionen mit Gleitkommazahlen berechnet, wo kleine Abweichungen unerwünscht sind.

const pointA = { x: 0.1 + 0.2, y: 0.3 };
const pointB = { x: 0.3, y: 0.3 };

function pointsEqual(a, b) {
  return Math.abs(a.x - b.x) < Number.EPSILON && 
         Math.abs(a.y - b.y) < Number.EPSILON;
}

console.log(pointsEqual(pointA, pointB)); // true

3. Tests und Unit-Testing

In automatisierten Tests ist es wichtig, dass Gleitkomma-Vergleiche robust sind.

test("should calculate correct sum", () => {
  const actual = 0.1 + 0.2;
  const expected = 0.3;

  expect(Math.abs(actual - expected) < Number.EPSILON).toBe(true);
});

Best Practices beim Epsilon-Vergleich

1. Nutze Number.EPSILON statt fester Werte

// ❌ Vermeide feste Werte
if (Math.abs(a - b) < 0.0000000001) { ... }

// Bessere Lösung
if (Math.abs(a - b) < Number.EPSILON) { ... }

2. Erstelle eine Hilfsfunktion

function isEqual(a, b, epsilon = Number.EPSILON) {
  return Math.abs(a - b) < epsilon;
}

// Nutze sie einfach:
isEqual(0.1 + 0.2, 0.3); // true

3. Verwende Epsilon-Vergleiche bei Vergleichsoperationen

function compare(a, b) {
  const diff = a - b;

  if (Math.abs(diff) < Number.EPSILON) return 0;   // gleich
  return diff > 0 ? 1 : -1;                        // größer/kleiner
}

4. Sei konsistent in deinem Code

Wähle einen Standard-Epsilon-Wert für dein Projekt und verwende ihn überall.

🚨 Typische Fehler und deren Lösungen

Fehler 1: Direkter Vergleich mit === oder ==

// ❌ Falscher Ansatz
if (0.1 + 0.2 === 0.3) {
  console.log("Gleich");
}

Lösung: Verwende Epsilon-Vergleich:

// Korrekt
const epsilon = Number.EPSILON;
if (Math.abs(0.1 + 0.2 - 0.3) < epsilon) {
  console.log("Gleich");
}

Fehler 2: Verwendung von zu großem Epsilon

// ❌ Zu groß – falsche Ergebnisse
function equals(a, b) {
  return Math.abs(a - b) < 1e-5; // Zu groß!
}

equals(0.1 + 0.2, 0.3); // true, aber nicht immer zuverlässig

Lösung: Nutze Number.EPSILON oder einen kleineren Wert:

// Bessere Toleranz
function equals(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}

Fehler 3: Epsilon-Vergleich bei negativen Zahlen

// ❌ Kann Probleme verursachen
console.log(Math.abs(-0.1 + 0.2 - 0.1)); // Geringe Differenz, aber manchmal ungenau

Lösung: Beachte die Vorzeichen und nutze immer absolute Werte.

🔍 Wie funktioniert der interne Mechanismus?

JavaScript speichert Gleitkommazahlen in Binärform nach IEEE 754. Diese Form hat eine begrenzte Anzahl an Bits für Mantisse und Exponent, was zu Rundungsfehlern führt:

// Beispiele für ungenaue Darstellungen:
console.log(0.1);     // Intern: 0.1000000000000000055511151231257827021181583404541015625
console.log(0.2);     // Intern: 0.200000000000000011102230246251565404236316680908203125
console.log(0.3);     // Intern: 0.299999999999999988897769753748434595763683319091796875

Das bedeutet, dass 0.1 + 0.2 nicht exakt 0.3 ergibt.

🧰 Nützliche Tools und Bibliotheken

Wenn du häufig mit Gleitkomma-Zahlen arbeitest, kann es hilfreich sein, Bibliotheken wie:

  • decimal.js: Für präzise Dezimalberechnungen
  • big.js: Gleichwertig zu decimal.js, aber leichter
  • mathjs: Umfassende Mathematikbibliothek mit exakten Vergleichen

Beispiel mit decimal.js:

const Decimal = require('decimal.js');
const a = new Decimal(0.1);
const b = new Decimal(0.2);
console.log(a.plus(b).equals(0.3)); // true

🧪 Zusammenfassung: Wann und wie du Epsilon-Vergleiche einsetzen solltest

SituationLösung
Mathematische BerechnungenNutze Math.abs(a - b) < Number.EPSILON
Koordinaten- oder PixelvergleicheVerwende Epsilon-Vergleich mit Number.EPSILON
Unit TestsImplementiere eine nearlyEqual()-Funktion
Große ZahlenAchte auf relative Fehler, nicht nur absolute
NegativzahlenNutze immer Math.abs()

💡 Fazit

Epsilon-Vergleiche sind ein entscheidender Aspekt bei der Arbeit mit Gleitkomma-Zahlen in JavaScript. Sie helfen dir, Rundungsfehler zu umgehen und dein Programm stabiler zu machen – besonders in Bereichen wie Grafik, Spieleentwicklung oder wissenschaftliche Berechnungen.

Wenn du beim Umgang mit Zahlen immer wieder auf unerwartete Ergebnisse stößt, ist es Zeit, den Epsilon-Vergleich ins Spiel zu bringen. Mit ein paar Zeilen Code kannst du deine Anwendung robust und zuverlässig machen – ohne komplexe Bibliotheken oder umfangreiche Umstrukturierungen.

Previous

Next