web-dev-qa-db-fra.com

Limitez le nombre de chiffres affichés après une décimale en javascript

Hay, j'ai des flotteurs comme ceux-ci

4.3455
2.768
3.67

et je veux les afficher comme ça

4.34
2.76
3.67

Je ne veux pas arrondir le nombre vers le haut ou vers le bas, limitez simplement le nombre de chiffres affichés après la décimale à 2.

javascriptfloating-pointdecimallimit
30
dotty

Vous recherchez toFixed :

var x = 4.3455;
alert(x.toFixed(2)); // alerts 4.35 -- not what you wanted!

... mais il semble que vous souhaitiez tronquer plutôt qu'arrondir, donc:

var x = 4.3455;
x = Math.floor(x * 100) / 100;
alert(x.toFixed(2)); // alerts 4.34
46
T.J. Crowder

Comme T.J a répondu, la méthode toFixed fera l'arrondi approprié si nécessaire. Il ajoutera également des zéros de fin, ce qui n'est pas toujours idéal.

(4.55555).toFixed(2);
//-> "4.56"

(4).toFixed(2);
//-> "4.00"

Si vous convertissez la valeur de retour en un nombre, ces zéros de fin seront supprimés. Il s'agit d'une approche plus simple que de faire vos propres calculs d'arrondi ou de troncature.

+parseFloat((4.55555).toFixed(2));
//-> 4.56

+parseFloat((4).toFixed(2));
//-> 4
10
C. J.

Si vous ne voulez pas arrondir à 2 décimales, utilisez toFixed() pour arrondir à n décimales et coupez toutes celles-ci sauf 2:

var num = 4.3455.toFixed(20);
alert(num.slice(0, -18));
//-> 4.34

Notez que cela a le léger inconvénient de l'arrondi lorsque le nombre de décimales passé à toFixed() est inférieur au nombre de décimales du nombre réel passé et que ces décimales sont de grands nombres. Par exemple, (4.99999999999).toFixed(10) Vous donnera 5.0000000000. Cependant, ce n'est pas un problème si vous pouvez vous assurer que le nombre de décimales sera inférieur à celui transmis à toFixed(). Cela rend cependant la solution de @ TJ un peu plus robuste.

6
Andy E

Attention! La solution actuellement acceptée échoue dans certains cas, par ex. avec 4.27, il renvoie à tort 4.26.

Voici une solution générale qui fonctionne toujours.

(Je devrais peut-être mettre cela en commentaire, mais au moment d'écrire ces lignes, je n'ai pas la réputation requise)

5
SC1000

Utilisez toPrecision :)

var y = 67537653.76828732668326;
y = (String(y).indexOf('.') !== -1) ? +y.toPrecision(String(y).indexOf('.') + 2) : +y.toFixed(2);
// => 67537653.76

Le 2 dans la deuxième ligne dicte le nombre de décimales, cette approche renvoie un nombre, si vous voulez une chaîne supprimez l'opérateur "+".

1
mmgc84

Bonnes nouvelles tout le monde! Depuis un moment il y a une alternative: toLocaleString ()

Bien qu'il ne soit pas exactement fait pour l'arrondi, il existe des arguments d'options utiles.

minimumIntegerDigits

Le nombre minimum de chiffres entiers à utiliser. Les valeurs possibles sont comprises entre 1> et 21; la valeur par défaut est 1.

minimumFractionDigits

Le nombre minimum de chiffres de fraction à utiliser.

Les valeurs possibles sont comprises entre 0> et 20; la valeur par défaut pour la mise en forme des nombres et des pourcentages simples est 0; t

La valeur par défaut pour le formatage des devises est le nombre de chiffres d'unité mineurs fournis par la liste des codes de devise ISO 4217 (2 si la liste ne fournit pas ces informations).

maximumFractionDigits

Nombre maximal de chiffres de fraction à utiliser.

Les valeurs possibles sont comprises entre 0> et 20; la valeur par défaut pour la mise en forme des nombres simples est la plus grande de minimumFractionDigits et 3

La valeur par défaut pour le formatage des devises est le plus grand de minimumFractionDigits et le nombre de chiffres d'unité mineurs fournis par la liste des codes de devise ISO 4217 (2 si la liste ne fournit pas ces informations); la valeur par défaut pour le formatage en pourcentage est la plus grande de minimumFractionDigits et 0.

minimumSignificantDigits

Le nombre minimum de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21; la valeur par défaut est 1.

maximumSignificantDigits

Le nombre maximum de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21; la valeur par défaut est 21.

Exemple d'utilisation: 

var bigNum = 8884858284485 * 4542825114616565
var smallNum = 88885 / 4545114616565

console.log(bigNum) // Output scientific

console.log(smallNum) // Output scientific

// String
console.log(
  bigNum.toLocaleString('fullwide', {useGrouping:false})
) 

// Return a string, rounded at 12 decimals
console.log(
  smallNum.toLocaleString('fullwide', {maximumFractionDigits:12})
)

// Return an Integer, rounded as need, js will convert it back to scientific!
console.log(
  +smallNum.toLocaleString('fullwide', {maximumFractionDigits:12})
)

// Return same Integer, don't use parseInt for precision!
console.log(
  parseInt(smallNum.toLocaleString('fullwide', {maximumFractionDigits:12}))
)

Mais cela ne correspond pas à la question, il arrondit:

function cutDecimals(number,decimals){
  return number.toLocaleString('fullwide', {maximumFractionDigits:decimals})
}

console.log(
  cutDecimals(4.3455,2),
  cutDecimals(2.768,2),
  cutDecimals(3.67,2)
)

La

1
NVRM