Unterschied zwischen toFixed () und toPrecision ()?

Ich bin neu in JavaScript und habe gerade entdeckt toFixed()und toPrecision()Zahlen gerundet. Ich kann jedoch nicht herausfinden, was der Unterschied zwischen den beiden ist.

Was ist der Unterschied zwischen number.toFixed()und number.toPrecision()?

toFixed(n)gibt die nLänge nach dem Dezimalpunkt an; toPrecision(x)bietet xGesamtlänge.

Ref bei w3schools: toFixed und toPrecision

EDIT :
Ich habe vor einiger Zeit erfahren, dass w3schools nicht gerade die beste Quelle ist, aber ich habe diese Antwort vergessen, bis ich den "enthusiastischen" Kommentar von kzh sah. Hier finden Sie zusätzliche Referenzen aus dem Mozilla Doc Center fürtoFixed() und fürtoPrecision() . Zum Glück für uns alle sind sich MDC und w3schools in diesem Fall einig.

Der Vollständigkeit halber sollte ich erwähnen, dass toFixed()dies der ursprünglichen Nummer ohne Formatierung entspricht toFixed(0)und diese toPrecision()nur zurückgibt.

Ich glaube, dass Ersteres Ihnen eine feste Anzahl von Dezimalstellen gibt, während Letzteres Ihnen eine feste Anzahl von signifikanten Stellen gibt.

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

Darüber hinaus toPrecisionergibt sich eine wissenschaftliche Notation, wenn die Zahl mehr ganzzahlige Ziffern als die angegebene Genauigkeit enthält.

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

EDIT: Oh, und wenn Sie neu in JavaScript sind, kann ich das Buch " JavaScript: The Good Parts " von Douglas Crockford sehr empfehlen .

Beispiele sprechen klar:

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

Ich denke, dies lässt sich am besten mit einem Beispiel beantworten.

Angenommen, Sie haben folgende Daten:

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

Sie möchten jedes dieser Produkte mit dem Titel und dem formatierten Preis anzeigen. Versuchen wir es toPrecisionzuerst:

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

The price of Really Nice Pen is $150.00

Sieht gut aus, also könnte man denken, dass dies auch für die anderen Produkte funktioniert:

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

Nicht so gut. Wir können dies beheben, indem wir die Anzahl der signifikanten Stellen für jedes Produkt ändern. Wenn wir jedoch die Produktreihe durchlaufen, kann dies schwierig sein. Verwenden wir toFixedstattdessen:

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

Dies ergibt das, was Sie erwartet haben. Es gibt keine Vermutungen und keine Rundungen.

Gerade:

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

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

Gibt unter bestimmten Umständen toPrecision()die Exponentialschreibweise zurück, während dies toFixed()nicht der Fall ist .

Zum Beispiel betrachten wir die Variable a als, var a = 123,45 a.toPrecision (6) Die Ausgabe ist 123.450 a.toFixed (6) Die Ausgabe ist wie 123.450000 // 6 Stellen nach dem Dezimalpunkt

Beides toPrecision()und toFixed()sind Funktionen zum Formatieren einer Zahl vor dem Ausdrucken. Also kehren beide zurückString Werte zurück.

Es gibt eine Ausnahme. Wenn Sie diese Funktionen für ein negatives Zahlenliteral verwenden, wird aufgrund der Priorität des Operators eine Zahl zurückgegeben. Dies bedeutet, dass toFixed()oder toPrecision()zuerst eine Zeichenfolge und dann die zurückgegeben wird- Minusoperator die Zeichenfolge dann wieder in eine Zahl als negativen Wert konvertiert. Ein Beispiel finden Sie weiter unten.

toPrecision()Gibt eine StringDarstellung des Number-Objekts in Festkomma- oder Exponentialschreibweise zurück, die auf signifikante Stellen gerundet ist. Wenn Sie also angeben, dass Sie eine Genauigkeit von 1 wünschen, wird die erste signifikante Zahl zusammen mit der wissenschaftlichen Notation zurückgegeben, um die Potenzen von 10 oder die vorherigen Nullen vor dem Dezimalpunkt anzugeben, wenn die signifikante Zahl <0 ist.

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()Gibt eine StringDarstellung des Number-Objekts in Festkomma-Notation, aufgerundet, zurück. Diese Funktion kümmert sich nur um die Dezimalstellen

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"

Ich habe oben eine Ausnahme erwähnt, bei der die Verwendung dieser Funktionen für negative Zahlenliterale aufgrund der Priorität des Operators eine Zahl und keine Zeichenfolge zurückgibt. Hier sind einige Beispiele:

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

Unterhaltsame Tatsache: Es gibt vorzeichenbehaftete Nullen, wie von -0.0456.toFixed(1)

Siehe: Sind +0 und -0 gleich?