Truncar/redondear el número entero en JavaScript?

Question

Para un script que estoy escribiendo, necesito mostrar un número que ha sido redondeado, pero no el decimal ni nada que lo haya pasado. He llegado al tercer lugar para redondearlo, pero no estoy seguro de cómo hacer para dejar caer el decimal y todo lo que haya pasado, ya que no parece que JavaScript tenga una función substr como PHP.

¿Alguna recomendación?

Answer 1

Si usted tiene una cadena, analizarlo como un entero:

var num = '20.536'; 
var result = parseInt(num, 10); // 20 

De lo contrario, ECMAScript 6 ofertas Math.trunc de truncamiento completamente consistente, que ya están disponibles en Firefox 24+ y Edge:

var num = -2147483649.536; 
var result = Math.trunc(num); // -2147483649 

Si no puede confiar en eso y siempre tendrá un número positivo, puede simplemente usar Math.floor:

var num = 20.536; 
var result = Math.floor(num); // 20 

Y, por último, si tiene un número en [− 2147483648, 2147483647], puede truncar a 32 bits utilizando cualquier operador bit a bit. | 0 es común, y >>> 0 se puede utilizar para obtener un entero sin signo de 32 bits:

var num = -20.536; 
var result = num | 0; // -20 

Answer 2

Uso Math.floor():

var f = 20.536; 
var i = Math.floor(f); // 20 

http://jsfiddle.net/J4UVV/1/

Answer 3

convertir el número en una cadena y tirar todo después del decimal.

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

trunc(-1.5) === -1 

trunc(1.5) === 1 

Editar 2013-07-10

Como ha señalado MiniTech ya segunda vista del método de cadena parece un poco excesivo. Así que la comparación de los diferentes métodos que se indican aquí y en otros lugares:

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"); 

Los resultados, que pueden variar basado en el hardware, son los siguientes:

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

El método/ceil Math.floor ser marginalmente más rápido que parseInt y mod. La cadena tiene un rendimiento bajo en comparación con los otros métodos.

Answer 4

Voy a agregar mi solución aquí. Podemos usar baja cuando los valores están por encima de 0 y ceil cuando son menos que cero:

function truncateToInt(x) 
{ 
    if(x > 0) 
    { 
     return Math.floor(x); 
    } 
    else 
    { 
     return Math.ceil(x); 
    } 
} 

continuación:

y = truncateToInt(2.9999); // results in 2 
y = truncateToInt(-3.118); //results in -3 

Answer 5

respuesta de

Travis Pessetto junto con la función de Mozey trunc2 eran las únicas respuestas correctas, teniendo en cuenta cómo JavaScript representa números de coma flotante muy pequeños o muy grandes en notación científica. Por ejemplo, parseInt(-2.2043642353916286e-15) no analizará correctamente esa entrada.En lugar de devolver 0, devolverá -2.

Esta es la forma correcta (y en mi humilde opinión el menos loco) para hacerlo:

function truncate(number) 
{ 
    return number > 0 
     ? Math.floor(number) 
     : Math.ceil(number); 
}