Comment convertir un nombre flottant en nombre entier en JavaScript?

Je voudrais convertir un flotteur en nombre entier en JavaScript. En fait, j'aimerais savoir comment faire les DEUX conversions standard: en tronquant et en arrondissant. Et efficacement, pas via la conversion en chaîne et l'analyse.

var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

Référence d'objet mathématique

Exemples

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

Math.floor(value) //  5            5            5
Math.ceil(value)  //  5            6            6
Math.round(value) //  5            5            6
Math.trunc(value) //  5            5            5
parseInt(value)   //  5            5            5
~~value           //  5            5            5
value | 0         //  5            5            5
value >> 0        //  5            5            5
value >>> 0       //  5            5            5
value - value % 1 //  5            5            5

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

Math.floor(value) // -5           -6           -6
Math.ceil(value)  // -5           -5           -5
Math.round(value) // -5           -5           -6
Math.trunc(value) // -5           -5           -5
parseInt(value)   // -5           -5           -5
value | 0         // -5           -5           -5
~~value           // -5           -5           -5
value >> 0        // -5           -5           -5
value >>> 0       // 4294967291   4294967291   4294967291
value - value % 1 // -5           -5           -5

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

Math.floor(value) //  900719925474099      900719925474099      900719925474099
Math.ceil(value)  //  900719925474099      900719925474100      900719925474100
Math.round(value) //  900719925474099      900719925474099      900719925474100
Math.trunc(value) //  900719925474099      900719925474099      900719925474099
parseInt(value)   //  900719925474099      900719925474099      900719925474099
value | 0         //  858993459            858993459            858993459
~~value           //  858993459            858993459            858993459
value >> 0        //  858993459            858993459            858993459
value >>> 0       //  858993459            858993459            858993459
value - value % 1 //  900719925474099      900719925474099      900719925474099

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

Math.floor(value) // -900719925474099     -900719925474100     -900719925474100
Math.ceil(value)  // -900719925474099     -900719925474099     -900719925474099
Math.round(value) // -900719925474099     -900719925474099     -900719925474100
Math.trunc(value) // -900719925474099     -900719925474099     -900719925474099
parseInt(value)   // -900719925474099     -900719925474099     -900719925474099
value | 0         // -858993459           -858993459           -858993459
~~value           // -858993459           -858993459           -858993459
value >> 0        // -858993459           -858993459           -858993459
value >>> 0       //  3435973837           3435973837           3435973837
value - value % 1 // -900719925474099     -900719925474099     -900719925474099

Opérateur OR au niveau du bit

Un opérateur au niveau du bit ou peut être utilisé pour tronquer les chiffres à virgule flottante et cela fonctionne pour les positifs comme pour les négatifs:

function float2int (value) {
    return value | 0;
}

Résultats

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

Comparaison des performances?

J'ai créé un test JSPerf qui compare les performances entre:

• Math.floor(val)
• val | 0 ^{au niveau du bit OU au niveau du}
• ~~val ^{au niveau du bit pas au niveau du}
• parseInt(val)

cela ne fonctionne qu'avec des nombres positifs. Dans ce cas, vous pouvez utiliser les opérations au niveau du bit et la Math.floorfonction en toute sécurité .

Mais si vous avez besoin de votre code pour travailler avec les positifs comme les négatifs , alors une opération au niveau du bit est la plus rapide (OU étant la préférée). Cet autre test JSPerf compare le même où il est assez évident qu'en raison du contrôle de signe supplémentaire, Math est maintenant le plus lent des quatre.

Remarque

Comme indiqué dans les commentaires, les opérateurs BITWISE fonctionnent sur des entiers 32 bits signés, donc les grands nombres seront convertis, par exemple:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

Remarque: Vous ne pouvez pas utiliser Math.floor()comme remplacement de tronquer, car Math.floor(-3.1) = -4et non-3 !!

Un remplacement correct pour tronquer serait:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

Un double opérateur pas au niveau du bit peut être utilisé pour tronquer les flottants. Les autres opérations que vous avez mentionnés sont disponibles à travers Math.floor, Math.ceilet Math.round.

> ~~2.5
2
> ~~(-1.4)
-1

Plus de détails gracieuseté de James Padolsey.

Pour tronquer:

var intvalue = Math.floor(value);

Pour ronde:

var intvalue = Math.round(value);

Vous pouvez utiliser la méthode parseInt pour aucun arrondi. Soyez prudent avec l'entrée utilisateur en raison des options de préfixe 0x (hex) et 0 (octal).

var intValue = parseInt(floatValue, 10);

Décalage de bits de 0, ce qui équivaut à une division de 1

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

Dans votre cas, lorsque vous voulez une chaîne à la fin (afin d'insérer des virgules), vous pouvez également simplement utiliser la Number.toFixed()fonction, cependant, cela effectuera l'arrondi.

Il y a de nombreuses suggestions ici. L'OR au niveau du bit semble de loin le plus simple. Voici une autre solution courte qui fonctionne également avec des nombres négatifs en utilisant l'opérateur modulo. Il est probablement plus facile à comprendre que le bit à bit OU:

intval = floatval - floatval%1;

Cette méthode fonctionne également avec des nombres de valeur élevée où ni '| 0' ni '~~' ni '>> 0' ne fonctionnent correctement:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

Pour tronquer :

// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted

Pour arrondir :

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

Une autre façon possible - utilisez l'opération XOR:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

La priorité des opérations au niveau du bit est inférieure à la priorité des opérations mathématiques, c'est utile. Essayez sur https://jsfiddle.net/au51uj3r/

Si regardez en natif Math objet en JavaScript, vous obtenez tout le tas de fonctions pour travailler sur les nombres et les valeurs, etc.

Fondamentalement, ce que vous voulez faire est assez simple et natif en JavaScript ...

Imaginez que vous avez le numéro ci-dessous:

const myValue = 56.4534931;

et maintenant si vous voulez l'arrondir au nombre le plus proche, faites simplement:

const rounded = Math.floor(myValue);

et vous obtenez:

56

Si vous voulez l'arrondir au nombre le plus proche, faites simplement:

const roundedUp = Math.ceil(myValue);

et vous obtenez:

57

De Math.roundmême, l'arrondir à un nombre supérieur ou inférieur dépend de celui qui est le plus proche du nombre de flots.

Vous pouvez également utiliser ~~derrière le nombre flottant, qui convertira un flotteur en nombre entier.

Vous pouvez l'utiliser comme ~~myValue...

Je veux juste souligner que monétairement, vous voulez arrondir, et non tronquer. Être hors d'un sou est beaucoup moins probable, car 4,999452 * 100 arrondi vous donnera 5, une réponse plus représentative.

Et en plus de cela, n'oubliez pas l'arrondi bancaire , qui est un moyen de contrer le biais légèrement positif que donne l'arrondi simple - votre application financière peut l'exiger.

Arrondi gaussien / banquier en JavaScript

Si vous utilisez angularjs, une solution simple comme suit dans la liaison de modèles HTML

{{val | number:0}}

il convertira val en entier

passer par ce lien docs.angularjs.org/api/ng/filter/number