Dlaczego javascript 0.1 + 0.2 nie daje 0.3? Odpowiedź, która zaskoczy każdego programistę!

Wielu programistów, szczególnie tych, którzy dopiero zaczynają swoją przygodę z JavaScript, napotyka zagadkę: dlaczego 0.1 + 0.2 w JavaScript nie daje oczekiwanego wyniku 0.3? To pytanie może wywołać zdziwienie, zwłaszcza gdy po raz pierwszy zetkniemy się z tym dziwnym przypadkiem. Okazuje się, że odpowiedź tkwi w specyfice reprezentacji liczb zmiennoprzecinkowych w komputerach. Jeśli jesteś ciekaw, dlaczego tak się dzieje, zapraszam do lektury!

Czym są liczby zmiennoprzecinkowe?

W matematyce, liczby zmiennoprzecinkowe to liczby, które mają część dziesiętną, czyli tzw. "część ułamkową". W JavaScript oraz innych językach programowania, takie liczby są reprezentowane w sposób binarny, co może prowadzić do pewnych niedokładności, zwłaszcza gdy liczby są zaokrąglane lub obliczane z dużą precyzją.

Reprezentacja liczb zmiennoprzecinkowych w komputerze jest zgodna ze standardem IEEE 754. Oznacza to, że liczby są zapisywane w postaci binarnej, a ich precyzja jest ograniczona do pewnej liczby bitów. Choć dla większości zastosowań liczby zmiennoprzecinkowe w JavaScript działają bez problemów, w przypadku operacji takich jak 0.1 + 0.2 mogą wystąpić pewne niedokładności.

Dlaczego 0.1 + 0.2 nie równa się 0.3?

Jeśli spróbujesz obliczyć 0.1 + 0.2 w JavaScript, wynik może cię zaskoczyć:

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

Zamiast oczekiwanego wyniku 0.3, otrzymujemy wartość 0.30000000000000004. Skąd się to bierze?

Problem wynika z faktu, że liczba 0.1 oraz liczba 0.2 nie mogą być dokładnie zapisane w systemie binarnym. W JavaScript, który opiera się na standardzie IEEE 754, niektóre liczby dziesiętne, takie jak 0.1, mają swoją reprezentację binarną, która nie jest w stanie wyrazić ich dokładnie. Zatem, kiedy próbujemy dodać te liczby, wynik również jest przybliżony, a nie idealny.

Jak to działa w praktyce? Przykłady

Aby zobaczyć ten problem w praktyce, wypróbujmy następujące obliczenie:

console.log(0.1 + 0.2); // Oczekiwany wynik: 0.3, rzeczywisty wynik: 0.30000000000000004
console.log(0.2 + 0.1); // Oczekiwany wynik: 0.3, rzeczywisty wynik: 0.30000000000000004
console.log(0.3 - 0.1); // Oczekiwany wynik: 0.2, rzeczywisty wynik: 0.2
console.log(0.1 + 0.2 === 0.3); // Wynik: false

Jak widać, operacje arytmetyczne na liczbach zmiennoprzecinkowych mogą prowadzić do małych błędów zaokrągleń. Ponadto, porównanie 0.1 + 0.2 === 0.3 zwraca false, ponieważ w rzeczywistości 0.1 + 0.2 daje wynik 0.30000000000000004, który jest nieco większy od 0.3.

Jak radzić sobie z tym problemem?

Chociaż jest to typowy problem związany z reprezentacją liczb zmiennoprzecinkowych, istnieją różne sposoby, aby go rozwiązać lub obejść:

1. Zaokrąglanie wyników

Jednym z najprostszych rozwiązań jest zaokrąglanie wyników obliczeń do określonej liczby miejsc po przecinku. Możemy to zrobić za pomocą funkcji toFixed(), która pozwala na zaokrąglenie liczby do żądanej liczby miejsc po przecinku. Na przykład:

let wynik = 0.1 + 0.2;
let zaokraglony_wynik = wynik.toFixed(1); // Wynik: "0.3" (string)
console.log(zaokraglony_wynik);

Funkcja toFixed() zwraca wynik w postaci łańcucha znaków, więc warto pamiętać, że jeśli potrzebujemy go jako liczbę, należy użyć funkcji parseFloat():

let zaokraglony_wynik_float = parseFloat(zaokraglony_wynik);
console.log(zaokraglony_wynik_float); // Wynik: 0.3

2. Użycie bibliotek do precyzyjnych obliczeń

Jeśli potrzebujemy dużej precyzji, możemy skorzystać z bibliotek takich jak Decimal.js lub Big.js, które oferują dokładniejsze obliczenia na liczbach zmiennoprzecinkowych. Biblioteki te pozwalają na przechowywanie liczb z wyższą precyzją oraz wykonanie obliczeń, które nie wprowadzają błędów zaokrągleń.

let Decimal = require('decimal.js');
let wynik = new Decimal(0.1).plus(0.2);
console.log(wynik.toString()); // Wynik: "0.3"

3. Porównywanie liczb z tolerancją błędu

Jeśli chcesz porównać liczby zmiennoprzecinkowe, zamiast bezpośredniego porównania, możesz sprawdzić, czy różnica między nimi mieści się w akceptowalnym zakresie błędu. Na przykład:

let wynik1 = 0.1 + 0.2;
let wynik2 = 0.3;
let tolerance = 0.0000001;

if (Math.abs(wynik1 - wynik2) < tolerance) {
    console.log("Liczby są równe w ramach tolerancji");
} else {
    console.log("Liczby są różne");
}

W ten sposób możesz zminimalizować wpływ błędów zaokrągleń przy porównywaniu liczb zmiennoprzecinkowych.

Podsumowanie

Chociaż dla wielu programistów problem 0.1 + 0.2 w JavaScript może być zaskakujący, jest to po prostu wynik ograniczeń związanych z reprezentacją liczb zmiennoprzecinkowych w systemie binarnym. Na szczęście istnieje wiele sposobów, by radzić sobie z tym problemem, takich jak zaokrąglanie wyników, używanie specjalnych bibliotek lub porównywanie liczb z tolerancją błędu. Pamiętaj, że w programowaniu często liczy się nie tylko rozwiązanie problemu, ale również zrozumienie, dlaczego coś działa w określony sposób. Dzięki temu możemy tworzyć bardziej precyzyjne i niezawodne aplikacje!