Question Comment puis-je convertir un nombre float à un nombre entier en JavaScript?


Je voudrais convertir un float à un 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 une chaîne et l'analyse.


861
2018-02-27 20:15


origine


Réponses:


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

Positif
value = 5.5

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

Math.floor(value) // -6
Math.ceil(value)  // -5
Math.round(value) // -5
Math.trunc(value) // -5
parseInt(value)   // -5
value | 0         // -5
~~value           // -5
value >> 0        // -5
value >>> 0       // 4294967291
value - value % 1 // -5
Positif - Plus grand nombre
value = Number.MAX_SAFE_INTEGER/10 // 900719925474099.1

Math.floor(value) //  900719925474099
Math.ceil(value)  //  900719925474100
Math.round(value) //  900719925474099
Math.trunc(value) //  900719925474099
parseInt(value)   //  900719925474099
value | 0         //  858993459
~~value           //  858993459
value >> 0        //  858993459
value >>> 0       //  858993459
value - value % 1 //  900719925474099
Négatif - Plus grand nombre
value = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

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

1183
2018-02-27 20:21



Opérateur OU bit à bit

Un opérateur bit ou peut être utilisé pour tronquer les chiffres à virgule flottante et il fonctionne pour les points positifs ainsi que 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 de performance?

J'ai créé un Test JSPerf cela compare les performances entre:

  • Math.floor(val)
  • val | 0  au niveau du bit OU
  • ~~val  au niveau du bit NE PAS
  • parseInt(val)

cela ne fonctionne qu'avec des nombres positifs. Dans ce cas, vous êtes sûr d'utiliser les opérations au niveau du bit ainsi que Math.floor fonction.

Mais si vous avez besoin de votre code pour travailler avec des positifs ainsi que des négatifs, alors une opération au niveau du bit est la plus rapide (OR étant la préférée). Cet autre test JSPerf compare le même où il est assez évident que, en raison de la vérification des signes supplémentaires 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 de grands nombres seront convertis, par exemple:

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

263
2017-10-11 10:18



Note: Vous ne pouvez pas utiliser Math.floor() en remplacement de tronquer, parce que Math.floor(-3.1) = -4 et pas -3 !!

Un remplacement correct de tronquer serait:

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

    return Math.floor(value);
}

88
2017-10-14 16:17



Un double bitwise pas L'opérateur peut être utilisé pour tronquer les flotteurs. Les autres opérations que vous avez mentionnées sont disponibles Math.floor, Math.ceil, et Math.round.

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

Plus de détails avec l'aimable autorisation de James Padolsey.


40
2018-01-11 16:54



Pour tronquer:

var intvalue = Math.floor(value);

Pour rond:

var intvalue = Math.round(value);

36
2018-02-27 20:22



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

var intValue = parseInt(floatValue, 10);

22
2017-09-26 20:41



Bit shift par 0 qui équivaut à la division par 1

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

17
2017-07-25 07:33



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


7
2017-10-14 16:30