Comment convertir un nombre flottant en un nombre entier en JavaScript ?

Question

J'aimerais convertir un flottant en un nombre entier en JavaScript. En fait, j'aimerais savoir comment effectuer les DEUX conversions standard : en tronquant et en arrondissant. Et de manière efficace, pas en convertissant en une chaîne de caractères et en l'analysant.

Answer 1

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 de l'objet mathématique

---

Exemples

Positif

// 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

Négatif

// 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

Positif - Des chiffres plus importants

// 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

Négatif - Chiffres plus élevés

// 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

Answer 2

Opérateur OR par bit

L'opérateur bit à bit ou peut être utilisé pour tronquer les chiffres en virgule flottante et il fonctionne aussi bien pour les positifs que 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 par bit OU
• ~~val par bit PAS
• parseInt(val)

qui ne fonctionne qu'avec des nombres positifs. Dans ce cas, vous pouvez utiliser les opérations de type bitwise comme Math.floor fonction.

Mais si vous avez besoin que votre code travailler avec les points positifs comme avec les points négatifs alors une opération par bit est la plus rapide (OR étant la préférée). Cet autre test JSPerf compare les mêmes où il est assez évident qu'en raison de la vérification supplémentaire du signe Les mathématiques sont maintenant les plus lentes des quatre.

Note

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

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

Answer 3

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

Un remplacement correct de truncate serait :

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

    return Math.floor(value);
}

Answer 4

Un double pas par bit peut être utilisé pour tronquer les flottants. Les autres opérations que vous avez mentionnées sont disponibles via Math.floor , Math.ceil y Math.round .

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

Plus de détails à la courtoisie de James Padolsey.

Answer 5

Pour tronquer :

var intvalue = Math.floor(value);

Pour la ronde :

var intvalue = Math.round(value);