Comment puis-je supprimer la partie décimale du numéro JavaScript?

J'ai les résultats d'une division et je souhaite supprimer la partie décimale du nombre résultant.

Comment puis-je faire ceci?

Vous pourriez utiliser ...

• Math.trunc() (tronçon fractionné, voir aussi ci-dessous)
• Math.floor() (arrondir vers le bas)
• Math.ceil() (rassembler)
• Math.round() (arrondi à l'entier le plus proche)

... en fonction de la façon dont vous souhaitez supprimer la décimale.

Math.trunc()n'est pas encore pris en charge sur toutes les plates-formes (à savoir IE), mais vous pouvez facilement utiliser un polyfill en attendant.

Une autre méthode pour tronquer la partie fractionnaire avec un excellent support de plate-forme consiste à utiliser un opérateur au niveau du bit (.eg |0). L'effet secondaire de l'utilisation d'un opérateur au niveau du bit sur un nombre est qu'il traitera son opérande comme un entier signé de 32 bits, supprimant ainsi la composante fractionnaire. Gardez à l'esprit que cela réduira également les nombres supérieurs à 32 bits.

Vous pouvez également parler de l'inexactitude de l'arrondi décimal avec l'arithmétique à virgule flottante.

Lecture obligatoire - Ce que tout informaticien devrait savoir sur l'arithmétique à virgule flottante .

Vous pouvez également utiliser des opérateurs au niveau du bit pour tronquer la décimale.

par exemple

var x = 9 / 2;
console.log(x); // 4.5

x = ~~x;
console.log(x); // 4

x = -3.7
console.log(~~x) // -3
console.log(x | 0) // -3
console.log(x << 0) // -3

Les opérations au niveau du bit sont considérablement plus efficaces que les fonctions mathématiques. L'opérateur double non au niveau du bit semble également légèrement surperformer les opérations x | 0et au niveau du x << 0bit d'une quantité négligeable.

// 952 milliseconds
for (var i = 0; i < 1000000; i++) {
    (i * 0.5) | 0;
}

// 1150 milliseconds
for (var i = 0; i < 1000000; i++) {
    (i * 0.5) << 0;
}

// 1284 milliseconds
for (var i = 0; i < 1000000; i++) {
    Math.trunc(i * 0.5);
}

// 939 milliseconds
for (var i = 0; i < 1000000; i++) {
    ~~(i * 0.5);
}

Il convient également de noter que l'opérateur non au niveau du bit a priorité sur les opérations arithmétiques, vous devrez donc peut-être entourer les calculs de parenthèses pour obtenir le résultat souhaité:

x = -3.7

console.log(~~x * 2) // -6
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7

console.log(~~(x * 2)) // -7
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7

Plus d'informations sur l'opérateur double pas au niveau du bit peuvent être trouvées sur Double bit au sens NON (~~)

Vous pourriez aussi faire

parseInt(a/b)

u peut également afficher un certain nombre de chiffres après le point décimal (ici 2 chiffres) en utilisant le code suivant:

var num = (15.46974).toFixed(2)
console.log(num) // 15.47
console.log(typeof num) // string

Utilisez la Math.round()fonction.

Math.round(65.98) // will return 66 
Math.round(65.28) // will return 65

Utilisez Math.round().

(La réponse d'Alex est meilleure; j'ai fait une supposition :)

Avec ES2015 , Math.trunc () est disponible.

Math.trunc(2.3)                       // 2
Math.trunc(-2.3)                      // -2
Math.trunc(22222222222222222222222.3) // 2.2222222222222223e+22
Math.trunc("2.3")                     // 2
Math.trunc("two")                     // NaN
Math.trunc(NaN)                       // NaN

Il n'est pas pris en charge dans IE11 ou inférieur, mais fonctionne dans Edge et dans tous les autres navigateurs modernes.

Si vous ne vous souciez pas du rouding, convertissez simplement le nombre en une chaîne, puis supprimez tout après la période, y compris la période. Cela fonctionne qu'il y ait une décimale ou non.

const sEpoch = ((+new Date()) / 1000).toString();
const formattedEpoch = sEpoch.split('.')[0];

toFixed se comportera comme rond.

Pour un comportement de type plancher, utilisez%:

var num = 3.834234;
var floored_num = num - (num % 1); // floored_num will be 3

Voici le compressif dans l'explication détaillée à l'aide des messages ci-dessus:

1. Math.trunc (): il est utilisé pour supprimer les chiffres qui sont suivis d'un point. Il se transforme implicitement. Mais, non pris en charge dans IE.

Exemple:

Math.trunc (10.5) // 10

Math.trunc (-10,5) // -10

Autre manière alternative: utilisation de l'opérateur non au niveau du bit:

Exemple:

x = 5,5

~~ x // 5

2. Math.floor (): Il est utilisé pour donner la valeur entière minimum possible. Il est pris en charge dans tous les navigateurs.

Exemple:

Plancher mathématique (10,5) // 10

Plancher mathématique (-10,5) // -11

3. Math.ceil (): il est utilisé pour donner la valeur entière la plus élevée possible. Il est pris en charge dans tous les navigateurs.

Exemple:

Math.ceil (10.5) // 11

Math.ceil (-10.5) // -10

4. Math.round (): il est arrondi à l'entier le plus proche. Il est pris en charge dans tous les navigateurs.

Exemple:

Math.round (10.5) // 11

Math.round (-10.5) // -10

Math.round (10.49) // 10

Math.round (-10.51) // -11

Pour une implémentation ES6, utilisez quelque chose comme ceci:

const millisToMinutesAndSeconds = (millis) => {
  const minutes = Math.floor(millis / 60000);
  const seconds = ((millis % 60000) / 1000).toFixed(0);
  return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
}

C'est pour ceux qui veulent empêcher les utilisateurs d'entrer des nombres décimaux

<input id="myInput" onkeyup="doSomething()" type="number" />

<script>
    function doSomething() {

        var intNum = $('#myInput').val();

        if (!Number.isInteger(intNum)) {
            intNum = Math.round(intNum);
        }

        console.log(intNum);
    }
</script>

Vous pouvez utiliser .toFixed (0) pour supprimer la partie décimale complète ou fournir le nombre d'arguments jusqu'à lequel vous voulez que la décimale soit tronquée.

Remarque: toFixed convertira le nombre en chaîne.

Par exemple:

var x = 9.656;
x.toFixed(0);           // returns 10
x.toFixed(2);           // returns 9.66
x.toFixed(4);           // returns 9.6560
x.toFixed(6);           // returns 9.656000 

ou

parseInt("10");         // returns 10
parseInt("10.33");      // returns 10
parseInt("10 20 30");   // returns 10
parseInt("10 years");   // returns 10
parseInt("years 10");   // returns NaN