Tronquer le tour de nombre entier en JavaScript?

Pour un script que je suis en train d'écrire, j'ai besoin d'afficher un nombre qui a été arrondis, mais non pas la virgule ou quoi que ce soit passé. J'ai obtenu vers le bas arrondi à la troisième place, mais je ne suis pas sûr de la façon d'aller sur l'insertion de la virgule et tout le passé, comme il ne semble pas que JavaScript a un substr fonction PHP de ne.

Toutes les recommandations?

D'arrondi et de troncature sont 2 opérations. Qui sont que vous essayez de faire?
.substring() est absolument une fonction en javascript.
LA MÉTHODE EST APPELÉE .toFixed()
n'utilisez pas de toFixed. il sera rond. par exemple (999/1000).toFixed(0) -> '1'. Comme @ryan dit dit d'utiliser les Mathématiques.trunc
Voici utile JSPerf: jsperf.com/different-ways-to-truncate/1

InformationsquelleAutor Eric | 2012-04-14

125

Si vous avez une chaîne, de l'analyser comme un entier:
```
var num = '20.536';
var result = parseInt(num, 10);  //20
```
Si vous avez un certain nombre, ECMAScript 6 offre Math.trunc pour complètement uniforme de troncature, 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 d'avoir toujours un nombre positif, bien sûr, vous pouvez 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 à l'aide de tout 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
```
- Les mathématiques.floor() va donner un mauvais résultat pour les nombres négatifs. Envisager mozey la réponse ci-dessous pour de meilleures alternatives.
- Merci, mais j'ai recommandé parseInt pour commencer. Envisager mozey de réponse lent, complexe des solutions de rechange.
- mozey de trunc2 est en fait la bonne option, plus il utilise la comparaison des entiers plutôt que le traitement de chaîne qui rendrait les choses beaucoup plus vite que parseInt, avec toujours de retourner le résultat correct.
- Eric parlé de la substr fonction, donc ma première option parlé de chaînes. Je suis bien conscient des problèmes liés à la parseInt sur un certain nombre (voir mon commentaire sur mozey de la réponse, qui est en fait surtout mal).
- Êtes-vous sûr de Math.trunc être pris en charge dans internet explorer 11? SOCIÉTÉ dit il n'y a pas d'IE de soutien. J'ai aussi essayé sous IE 11 et a obtenu "l'Objet ne prend pas en charge la propriété ou de la méthode 'tronc'".
- Ah, désolé, j'ai eu de Bord. Heureusement, il est facile de cale.
InformationsquelleAutor Ry-
16

Travis Pessetto réponse avec mozey de trunc2 fonction ont été les seules réponses correctes, compte tenu du JavaScript représente très petits ou très grands nombres à virgule flottante en notation scientifique.

Par exemple, parseInt(-2.2043642353916286e-15) ne sera pas analyser correctement entrée. Au lieu de retourner 0 il sera de retour -2.

C'est la bonne (et à mon humble avis les moins fous) façon de le faire:
```
function truncate(number)
{
    return number > 0
         ? Math.floor(number)
         : Math.ceil(number);
}
```
- Pour moi les Mathématiques.trunc(-2.2043642353916286 e-15) renvoie zéro. Je l'ai testé dans typescriptlang.org/play
InformationsquelleAutor BlinkyTop
14

Je vais ajouter ma solution ici. Nous pouvons utiliser étage lorsque les valeurs sont au-dessus de 0 et de l'ceil, lorsqu'ils sont inférieurs à zéro:
```
function truncateToInt(x)
{
    if(x > 0)
    {
         return Math.floor(x);
    }
    else
    {
         return Math.ceil(x);
    }
 }
```
Alors:
```
y = truncateToInt(2.9999); //results in 2
y = truncateToInt(-3.118); //results in -3
```
- Je ne comprends pas pourquoi cette réponse a été downvoted. C'est la seule façon correcte!
InformationsquelleAutor Travis Pessetto

Convertir le nombre en une chaîne de caractères et jeter tout ce qui est après la virgule.

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

trunc(-1.5) === -1

trunc(1.5) === 1

Modifier 2013-07-10

Comme l'a souligné minitech et à la réflexion de la méthode de chaîne semble un peu excessif. Afin de comparer les différentes méthodes présentées ici et d'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 comme suit:

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

Les Mathématiques.plancher /plafond méthode étant légèrement plus rapide que parseInt et mod. Chaîne des résultats médiocres par rapport aux autres méthodes.

parseInt et la chaîne de remplacement sera de retour les réponses incorrectes pour les nombres plus grands que 999999999999999900000.
mon take-away de cette expérience: à moins que la performance est un énorme problème, il suffit d'utiliser parseInt pour des raisons de simplicité, sinon de mettre en œuvre trunc3()

InformationsquelleAutor mozey

2

Utilisation Math.floor():
```
var f = 20.536;
var i = Math.floor(f);  //20
```
http://jsfiddle.net/J4UVV/1/
- Si vous utilisez un nombre négatif dire -20.536 alors vous obtiendrez le mauvais résultat pour la troncation, car les résultats -21 jsfiddle.net/zL1v5e2k
InformationsquelleAutor gilly3
0

Mathématiques.trunc() fonction supprime tous les chiffres fractionnaires.

Pour nombre positif, il se comporte exactement de la même que les Mathématiques.floor():
```
console.log(Math.trunc(89.13349)); //output is 89
```
Pour les nombres négatifs, il se comporte de même que les Mathématiques.ceil():
```
console.log(Math.trunc(-89.13349)); //output is -89
```
InformationsquelleAutor Asad Manzoor

Vous devez vous connecter pour publier un commentaire.