Différence entre toFixed() et toPrecision() ?

Question

Je suis novice en JavaScript et je viens de découvrir toFixed() y toPrecision() pour arrondir les chiffres. Cependant, je n'arrive pas à comprendre quelle est la différence entre les deux.

Quelle est la différence entre number.toFixed() y number.toPrecision() ?

Answer 1

Dans certaines circonstances, toPrecision() retournera la notation exponentielle, alors que toFixed() ne le fera pas.

Answer 2

toFixed(fractionDigits?) a été expliqué plus ou moins précisément dans d'autres réponses :

• il renvoie une représentation en chaîne du nombre avec fractionDigits [montant] chiffres après le point décimal :

Un exemple :

(-3).toFixed(1)     // '-3.0'
(-3).toFixed(0)     // '-3'
(-3).toFixed()      // '-3'
(-0.03).toFixed(1)  // '-0.0'

---

toPrecision(precision?) n'a pas été décrit correctement dans les réponses précédentes, il faut donc faire attention. J'ajouterais également un avertissement : je n'ai pas été en mesure d'assimiler les spécifications de l'UE. toPrecision Les points suivants sont donc basés sur une approche d'essai et d'erreur pour tester la mise en œuvre dans Node.js. Et ces étapes ne couvrent pas tous les cas de figure, par exemple si le nombre est NaN, ou si l'argument de précision n'est pas un entier, ou est <1 ou >100, etc. Ceci afin de ne pas rendre l'explication encombrée comme la spécification semble l'être.

* La numérotation des cas est conservée dans la liste, même si les cas peuvent sembler similaires les uns aux autres, ils doivent démontrer un comportement particulier.

1. il représente d'abord le nombre en notation exponentielle avec precision étant le nombre de chiffres dans le significand, comme

Cas 1 : 0.000004 → précision = 3 → 400 * 10^-8
Cas 2 : 0.0000004 → précision = 3 → 400 * 10^-9
Cas 3 : 123 → précision = 1 → 1.23 * 10^2
Cas 4 : 153 → précision = 1 → 1.53 * 10^2
Cas 5 : 1234.56 → précision = 3 → 123.456 * 10^1
Cas 6 : 1234.56 → précision = 5 → 12345.6 * 10^-1

2. puis il arrondit la partie significative

Cas 1 : 400 * 10^-8 → 400 * 10^-8 (aucune fraction n'était présente, aucun changement)
Cas 2 : 400 * 10^-9 → 400 * 10^-9 (même raisonnement que dans le cas 1)
Cas 3 : 1.23 * 10^2 → 1 * 10^2 ( 1.23 a été arrondie à 1 )
Cas 4 : 1.53 * 10^2 → 2 * 10^2 ( 1.53 arrondis à 2 )
Cas 5 : 123.456 * 10^1 → 123 * 10^1 (arrondis aussi)
Cas 6 : 12345.6 * 10^-1 → 12346 * 10^-1 (arrondis)

3. puis il produit une représentation sous forme de chaîne du nombre qui suit les règles :

3a) tous les chiffres du significande de l'étape 2 seront préservés

3b) La notation exponentielle est utilisée si precision < le nombre de chiffres avant le point (en représentation "normale", c'est-à-dire décimale)

Cas 3 : 1 * 10^2 → '1e+2' (le numéro est maintenant 100 (3 chiffres, précision 1, exposant utilisé)
Cas 4 : 2 * 10^2 → '2e+2' (le numéro est maintenant 200 (3 chiffres, précision 1, exposant utilisé)
Cas 5 : 123 * 10^1 → '1.23e+3' (le numéro est maintenant 1230 4 chiffres, la précision est de 3, l'exposant est utilisé ; notez que le significande a conservé tous les chiffres de l'étape 2 : 123 est devenu 1.23 )

3c) La notation exponentielle est utilisée si le nombre a la partie entière 0 et que le nombre de zéros juste après la virgule et avant le premier chiffre significatif (en notation "normale") est >5.

Cas 2 : 400 * 10^-9 → '4.00e-7' (le nombre est de 0,0000004, il a la valeur de 0 partie entière et il y a >5 zéros après le point décimal, Notez que les deux zéros de 400 * 10^-9 ont été préservés )

3d) La notation décimale est utilisée, si le nombre a la partie entière 0 et le nombre de zéros juste après le point décimal <= 5 mais les chiffres du significande de l'étape 2 seront préservés.

Cas 1 : 400 * 10^-8 → '0.00000400' (les deux zéros de la partie significande ont été préservés)

3e) La notation décimale est utilisée, si precision >= le nombre de chiffres avant le point en représentation décimale

Cas 6 : 12346 * 10^-1 → 1234.6 (la forme décimale du nombre de l'étape 2 est 1234.6, la précision est de 5, le nombre de chiffres avant la virgule est de 4, la chaîne utilise la notation décimale, tous les chiffres du significande de l'étape 2 ont été préservés)

console.log((0.000004).toPrecision(3));
console.log((0.0000004).toPrecision(3));
console.log((123).toPrecision(1));
console.log((153).toPrecision(1));
console.log((1234.56).toPrecision(3));
console.log((1234.56).toPrecision(5));

Answer 3

Par exemple, nous considérons la variable a comme, var a = 123.45 a.toPrecision(6) Le résultat est 123.450 a.toFixed(6) Le résultat est 123.450000 // 6 chiffres après la virgule.

Answer 4

Les deux sites toPrecision() y toFixed() sont des fonctions destinées à formater un nombre avant de l'imprimer. Elles renvoient donc toutes deux String valeurs.

Il y a une exception. Si vous utilisez ces fonctions sur un négatif Nombre littéral, en raison de la précédence des opérateurs, un nombre est renvoyé. Cela signifie que toFixed() o toPrecision() retournera d'abord une chaîne de caractères, puis la - L'opérateur moins convertira la chaîne de caractères en un nombre sous forme de valeur négative. Veuillez voir l'exemple ci-dessous.

toPrecision() renvoie un String représentant l'objet Number en notation à virgule fixe ou exponentielle arrondie aux chiffres significatifs. Ainsi, si vous spécifiez que vous souhaitez une précision de 1, l'objet renvoie le premier chiffre significatif ainsi que la notation scientifique pour indiquer les puissances de 10 ou les 0 précédents avant la virgule si le chiffre significatif est < 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() renvoie un String représentant l'objet Nombre en notation à virgule fixe, arrondi au chiffre supérieur. Cette fonction ne s'intéresse qu'aux nombres à virgule fixe.

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"

J'ai mentionné plus haut une exception où l'utilisation de ces fonctions sur des nombres littéraux négatifs renverra un nombre et non une chaîne de caractères en raison de la préséance des opérateurs. Voici quelques exemples :

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

Fait amusant : il y a des zéros signés, comme on peut le voir dans la section -0.0456.toFixed(1)

Voir : Est-ce que +0 et -0 sont identiques ?