ToFixed () ve toPrecision () arasındaki fark?

JavaScript konusunda yeniyim ve yeni keşfettim toFixed()ve toPrecision()sayıları yuvarlamak için. Ancak ikisi arasındaki farkın ne olduğunu çözemiyorum.

Arasındaki fark nedir number.toFixed()ve number.toPrecision()?

toFixed(n)nondalık noktadan sonra uzunluk sağlar ; toPrecision(x)içerir xtoplam uzunluğu.

Referans w3schools: toFixed ve toPrecision

DÜZENLEME :
Bir süre önce w3schools'un tam olarak en iyi kaynak olmadığını öğrendim, ancak kzh'nin "hevesli" yorumunu görene kadar bu cevabı unuttum. İşte Mozilla Doc Merkezi'nden ek hakemler vardır içintoFixed() ve içintoPrecision() . Neyse ki hepimiz için, MDC ve w3schools bu durumda birbirleriyle aynı fikirde.

Tamlık için, toFixed()bunun eşdeğer olduğunu toFixed(0)ve toPrecision()biçimlendirme olmadan orijinal numarayı döndürdüğünü belirtmeliyim .

İlki size sabit sayıda ondalık basamak verirken, ikincisinin size sabit sayıda anlamlı basamak verdiğine inanıyorum.

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

Bundan başka, toPrecisionelde edecek bilimsel gösterim belirtilen hassas daha sayısında daha büyük bir tamsayı basamak varsa.

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

DÜZENLEME: Oh, JavaScript'te yeniyseniz, Douglas Crockford'un " JavaScript: The Good Parts " kitabını şiddetle tavsiye edebilirim .

Örnekler açıkça konuşur:

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

Bence bu en iyi bir örnekle yanıtlanır.

Aşağıdaki verilere sahip olduğunuzu varsayalım:

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

Bu ürünlerin her birini başlık ve biçimlendirilmiş fiyatla görüntülemek istiyorsunuz. Önce kullanmayı deneyelim toPrecision:

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

The price of Really Nice Pen is $150.00

İyi görünüyor, bu nedenle bunun diğer ürünler için de işe yarayacağını düşünebilirsiniz:

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

Çok iyi değil. Bunu, her ürün için anlamlı basamak sayısını değiştirerek düzeltebiliriz, ancak ürün dizisi üzerinde yineliyorsak, bu zor olabilir. Onun toFixedyerine kullanalım :

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

Bu beklediğinizi üretir. Hiçbir tahmin işi yoktur ve yuvarlama yoktur.

Sadece:

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

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

Belirli koşullar altında toPrecision()üstel gösterim döndürecektir, oysa toFixed()olmayacaktır.

Örneğin, a değişkenini şöyle düşünürüz, var a = 123.45 a.toPrecision (6) Çıktı 123.450 a.toFixed (6) Çıktı 123.450000 // ondalık noktadan sonraki 6 hane gibidir

Hem toPrecision()ve toFixed()dışarı yazdırmadan önce bir numara biçimlendirmek için tasarlanmış fonksiyonlardır. Yani ikisi de Stringdeğerleri döndürür .

Bir istisna var. Bu işlevleri, operatör önceliğinden dolayı negatif bir Sayı değişmezinde kullanırsanız, bir Sayı döndürülür. Bunun anlamı şudur toFixed()veya toPrecision()önce bir dize döndürecektir ve ardından -eksi operatörü dizeyi negatif bir değer olarak tekrar Sayıya dönüştürecektir. Bir örnek için lütfen aşağıya bakın.

toPrecision()StringNumber nesnesini sabit noktalı veya önemli basamaklara yuvarlanmış üstel gösterimde temsil eden bir döndürür . Dolayısıyla, 1'lik bir kesinlik istediğinizi belirtirseniz, 10'un üslerini gösteren bilimsel gösterimle birlikte ilk önemli sayıyı veya önemli sayı <0 ise ondalık noktasından önceki 0'ları döndürür.

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()StringNumber nesnesini sabit noktalı gösterimde, yukarı yuvarlanmış olarak temsil eden bir döndürür . Bu işlev yalnızca ondalık nokta sayılarıyla ilgilenir

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"

Yukarıda, bu işlevlerin negatif Sayı değişmez değerlerinde kullanılmasının operatör önceliğinden dolayı bir Dize değil, bir Sayı döndüreceği bir istisnadan bahsetmiştim. İşte bazı örnekler:

// 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

Eğlenceli gerçek: göründüğü gibi imzalı sıfırlar var -0.0456.toFixed(1)

Bakınız: +0 ve -0 aynı mı?