Różnica między toFixed () a toPrecision ()?

Jestem nowy w JavaScript i właśnie odkryłem toFixed()i toPrecision()zaokrąglałem liczby. Jednak nie mogę dowiedzieć się, jaka jest różnica między nimi.

Jaka jest różnica między number.toFixed()i number.toPrecision()?

toFixed(n)podaje ndługość po przecinku; toPrecision(x)zapewnia xcałkowitą długość.

Referencje w w3schools: toFixed i toPrecision

EDYCJA :
Dowiedziałem się jakiś czas temu, że w3schools nie jest najlepszym źródłem, ale zapomniałem o tej odpowiedzi, dopóki nie zobaczyłem „entuzjastycznego” komentarza kzh. Oto dodatkowe referencje z Mozilla Doc Center dlatoFixed() i dlatoPrecision() . Na szczęście dla nas wszystkich, MDC i w3schools zgadzają się ze sobą w tej sprawie.

Dla kompletności powinienem wspomnieć, że toFixed()jest równoważny toFixed(0)i toPrecision()po prostu zwraca oryginalną liczbę bez formatowania.

Uważam, że pierwszy daje stałą liczbę miejsc po przecinku, podczas gdy drugi daje stałą liczbę cyfr znaczących.

Math.PI.toFixed(2); // "3.14"
Math.PI.toPrecision(2); // "3.1"

Ponadto toPrecisionzwróci notację naukową, jeśli liczba zawiera więcej cyfr całkowitych niż określona dokładność.

(Math.PI * 10).toPrecision(2); // "31"
(Math.PI * 100).toPrecision(2); // "3.1e+2"

EDYCJA: Och, a jeśli dopiero zaczynasz korzystać z JavaScript, gorąco polecam książkę „ JavaScript: The Good Parts ” autorstwa Douglasa Crockforda.

Przykłady mówią jasno:

var A = 123.456789;

A.toFixed()      // 123
A.toFixed(0)     // 123
A.toFixed(1)     // 123.5
A.toFixed(2)     // 123.46
A.toFixed(3)     // 123.457
A.toFixed(4)     // 123.4568
A.toFixed(5)     // 123.45679
A.toFixed(6)     // 123.456789
A.toFixed(7)     // 123.4567890
A.toFixed(8)     // 123.45678900
A.toFixed(9)     // 123.456789000
A.toFixed(10)    // 123.4567890000
A.toFixed(11)    // 123.45678900000

A.toPrecision()      // 123.456789 
A.toPrecision(0)     // --- ERROR --- 
A.toPrecision(1)     // 1e+2
A.toPrecision(2)     // 1.2e+2
A.toPrecision(3)     // 123
A.toPrecision(4)     // 123.5
A.toPrecision(5)     // 123.46
A.toPrecision(6)     // 123.457
A.toPrecision(7)     // 123.4568
A.toPrecision(8)     // 123.45679
A.toPrecision(9)     // 123.456789
A.toPrecision(10)    // 123.4567890
A.toPrecision(11)    // 123.45678900

Myślę, że najlepiej odpowiedzieć na to przykład.

Załóżmy, że masz następujące dane:

var products = [
  {
    "title": "Really Nice Pen",
    "price": 150
  },
  {
    "title": "Golf Shirt",
    "price": 49.99
  },
  {
    "title": "My Car",
    "price": 1234.56
  }
]

Chcesz wyświetlić każdy z tych produktów z tytułem i sformatowaną ceną. Spróbujmy toPrecisionnajpierw użyć :

document.write("The price of " + products[0].title + " is $" + products[0].price.toPrecision(5));

The price of Really Nice Pen is $150.00

Wygląda dobrze, więc możesz pomyśleć, że będzie to działać również w przypadku innych produktów:

document.write("The price of " + products[1].title + " is $" + products[2].price.toPrecision(5));
document.write("The price of " + products[2].title + " is $" + products[2].price.toPrecision(5));

The price of Golf Shirt is $49.990
The price of My Car is $1234.6

Nie zbyt dobrze. Możemy to naprawić, zmieniając liczbę cyfr znaczących dla każdego produktu, ale jeśli będziemy iterować po tablicy produktów, może to być trudne. Użyjmy toFixedzamiast:

document.write("The price of " + products[0].title + " is $" + products[0].price.toFixed(2));
document.write("The price of " + products[1].title + " is $" + products[2].price.toFixed(2));
document.write("The price of " + products[2].title + " is $" + products[2].price.toFixed(2));

The price of Really Nice Pen is $150.00
The price of Golf Shirt is $49.99
The price of My Car is $1234.56

To daje to, czego się spodziewałeś. Nie wymaga zgadywania ani zaokrąglania.

Właśnie:

49.99.toFixed(5)
// → "49.99000"

49.99.toPrecision(5)
// → "49.990"

W pewnych okolicznościach toPrecision()zwróci notację wykładniczą, ale toFixed()nie zwróci.

Na przykład rozważamy zmienną a as, var a = 123.45 a.toPrecision (6) Wynik to 123.450 a.toFixed (6) Wynik ma postać 123.450000 // 6 cyfr po przecinku

Obie funkcje toPrecision()i toFixed()są przeznaczone do formatowania liczby przed jej wydrukowaniem. Więc oba zwracają Stringwartości.

Jest jeden wyjątek. Jeśli używasz tych funkcji na ujemnym literale Number, ze względu na pierwszeństwo operatorów zwracana jest liczba. Oznacza to, że toFixed()lub toPrecision()zwróci najpierw ciąg, a następnie -operator minus przekonwertuje ciąg z powrotem na liczbę jako wartość ujemną. Poniżej znajduje się przykład.

toPrecision()zwraca wartość Stringreprezentującą obiekt Number w notacji stałoprzecinkowej lub wykładniczej zaokrągloną do cyfr znaczących. Więc jeśli określisz, że chcesz mieć dokładność 1, zwraca pierwszą znaczącą liczbę wraz z notacją naukową wskazującą potęgi 10 lub poprzednie 0 przed przecinkiem, jeśli liczba znacząca jest <0.

const num1 = 123.4567;

// if no arguments are passed, it is similar to converting the Number to String
num1.toPrecision();   // returns "123.4567

// scientific notation is used when you pass precision count less than total
// number of digits left of the period
num1.toPrecision(2);  // returns "1.2e+2"

// last digit is rounded if precision is less than total significant digits
num1.toPrecision(4);  // returns "123.5"
num1.toPrecision(5);  // returns "123.46"

const largeNum = 456.789;
largeNum.toPrecision(2);  // returns "4.6e+2"

// trailing zeroes are added if precision is > total digits of the number or float
num1.toPrecision(9);  // returns "123.456700"

const num2 = 123;
num2.toPrecision(4);  // returns "123.0"

const num3 = 0.00123;
num3.toPrecision(4);  // returns "0.001230"
num3.toPrecision(5);  // returns "0.0012300"

// if the number is < 1, precision is by the significant digits
num3.toPrecision(1);  // returns "0.001"

toFixed()zwraca wartość Stringreprezentującą obiekt Number w notacji stałoprzecinkowej, zaokrągloną w górę. Ta funkcja dotyczy tylko liczb dziesiętnych

const num1 = 123.4567;

// if no argument is passed, the fractions are removed
num1.toFixed();  // returns "123"

// specifying an argument means you the amount of numbers after the decimal point
num1.toFixed(1);  // returns "123.5"
num1.toFixed(3);  // returns "123.457"
num1.toFixed(5);  // returns "123.45670"
num1.toFixed(7);  // returns "123.4567000"

// trying to operator on number literals
2.34.toFixed(1);  // returns "2.3"
2.toFixed(1);     // returns SyntaxError
(2).toFixed(1);   // returns "2.0"
(2.34e+5).toFixed(1);  // returns "234000.0"

Wspomniałem powyżej o wyjątku, w którym użycie tych funkcji na ujemnych literałach liczbowych zwróci Number, a nie String ze względu na pierwszeństwo operatorów. Oto kilka przykładów:

// Note: these are returning as Number
// toPrecision()
-123.45.toPrecision();  // returns -123.45
-123.45.toPrecision(2);  // returns -120
-123.45.toPrecision(4);  // returns -123.5
-2.34e+2.toPrecision(1);  // returns -200
-0.0456.toPrecision(1);  // returns -0.05
-0.0456.toPrecision(6);  // returns -0.0456

// toFixed()
-123.45.toFixed();  // returns -123.45
-123.45.toFixed(1);  // returns -123.5
-123.45.toFixed(4);  // returns -123.45
-0.0456.toFixed(1);  // returns -0
-0.0456.toFixed(6);  // -0.0456

Ciekawostka: widać zera ze znakiem -0.0456.toFixed(1)

Zobacz: Czy +0 i -0 to to samo?