web-dev-qa-db-fra.com

Tronquer/arrondir un nombre entier en JavaScript?

Pour un script que j'écris, j'ai besoin d'afficher un nombre qui a été arrondi, mais pas la décimale ni quoi que ce soit après. J'ai fini par arrondir à la troisième place, mais je ne suis pas sûr de savoir comment supprimer simplement la décimale et tout ce qui la dépasse, car il ne semble pas que JavaScript ait une fonction substr comme PHP. Est-ce que.

Des recommandations?

javascriptdecimalrounding
57
Eric

Si vous avez une chaîne , analysez-la comme un entier:

var num = '20.536';
var result = parseInt(num, 10);  // 20

Si vous avez un numéro , ECMAScript 6 offre Math.trunc pour une troncature totalement cohérente, déjà disponible dans Firefox 24+ et Edge:

var num = -2147483649.536;
var result = Math.trunc(num);  // -2147483649

Si vous ne pouvez pas compter sur cela et que vous aurez toujours un nombre positif, vous pouvez bien sûr simplement utiliser Math.floor:

var num = 20.536;
var result = Math.floor(num);  // 20

Et enfin, si vous avez un nombre dans [−2147483648, 2147483647], vous pouvez tronquer à 32 bits en utilisant n’importe quel opérateur au niveau du bit. | 0 est commun, et >>> 0 peut être utilisé pour obtenir un entier 32 bits non signé:

var num = -20.536;
var result = num | 0;  // -20
115
Ry-

La réponse de Travis Pessetto et la fonction trunc2 de mozey étaient les seules réponses correctes, compte tenu de la façon dont JavaScript représente des nombres en virgule flottante très petits ou très grands en notation scientifique.

Par exemple, parseInt(-2.2043642353916286e-15) n'analysera pas correctement cette entrée. Au lieu de renvoyer 0, il renverra -2.

C'est la bonne façon (et à mon humble avis, le moins fou) de le faire:

function truncate(number)
{
    return number > 0
         ? Math.floor(number)
         : Math.ceil(number);
}
16
BlinkyTop

Je vais ajouter ma solution ici. Nous pouvons utiliser plancher lorsque les valeurs sont supérieures à 0 et ceil quand elles sont inférieures à zéro:

function truncateToInt(x)
{
    if(x > 0)
    {
         return Math.floor(x);
    }
    else
    {
         return Math.ceil(x);
    }
 }

Ensuite:

y = truncateToInt(2.9999); // results in 2
y = truncateToInt(-3.118); //results in -3
13
Travis Pessetto

Convertissez le nombre en chaîne et jetez tout après la décimale.

trunc = function(n) { return Number(String(n).replace(/\..*/, "")) }

trunc(-1.5) === -1

trunc(1.5) === 1

Edit 2013-07-10

Comme le soulignent Minitech et à bien y penser, la méthode des chaînes semble un peu excessive. Donc, en comparant les différentes méthodes listées ici et ailleurs:

function trunc1(n){ return parseInt(n, 10); }
function trunc2(n){ return n - n % 1; }
function trunc3(n) { return Math[n > 0 ? "floor" : "ceil"](n); }
function trunc4(n) { return Number(String(n).replace(/\..*/, "")); }

function getRandomNumber() { return Math.random() * 10; }

function test(func, desc) {
    var t1, t2;
    var ave = 0;
    for (var k = 0; k < 10; k++) {
        t1 = new Date().getTime();
        for (var i = 0; i < 1000000; i++) {
            window[func](getRandomNumber());
        }
        t2 = new Date().getTime();
        ave += t2 - t1;
    }
    console.info(desc + " => " + (ave / 10));
}

test("trunc1", "parseInt");
test("trunc2", "mod");
test("trunc3", "Math");
test("trunc4", "String");

Les résultats, qui peuvent varier en fonction du matériel, sont les suivants:

parseInt => 258.7
mod      => 246.2
Math     => 243.8
String   => 1373.1

La méthode Math.floor/ceil est légèrement plus rapide que parseInt et mod. La chaîne fonctionne mal par rapport aux autres méthodes.

9
mozey

Utilisez Math.floor() :

var f = 20.536;
var i = Math.floor(f);  // 20

http://jsfiddle.net/J4UVV/1/

2
gilly3

Math.trunc () function supprime tous les chiffres fractionnaires.

Pour un nombre positif, il se comporte exactement comme Math.floor ():

console.log(Math.trunc(89.13349)); // output is 89

Pour les nombres négatifs, il se comporte comme Math.ceil ():

console.log(Math.trunc(-89.13349)); //output is -89
0
Asad Manzoor