Usando bitwise O 0 para floor un número

Esto es truncamiento en contraposición al piso. La respuesta de Howard es algo así como correcta; pero yo añadiría que Math.floor hace exactamente lo que se supone que hace con respecto a los números negativos. Matemáticamente, eso es lo que es un piso.

En el caso descrito anteriormente, el programador estaba más interesado en truncamiento o cortar el decimal completamente. Aunque, la sintaxis que usaron oscurece el hecho de que están convirtiendo el float a un int.

En ECMAScript 6, el equivalente de |0 es Matemáticas.trunc , más o menos debería decir:

Devuelve la parte integral de un número eliminando cualquier dígito fraccionario. Simplemente trunca el punto y los dígitos detrás de él, no importa si el argumento es un número positivo o un número negativo.

Math.trunc(13.37)   // 13
Math.trunc(42.84)   // 42
Math.trunc(0.123)   //  0
Math.trunc(-0.123)  // -0
Math.trunc("-1.123")// -1
Math.trunc(NaN)     // NaN
Math.trunc("foo")   // NaN
Math.trunc()        // NaN

Su primer punto es correcto. El número se convierte en un entero y, por lo tanto, se eliminan los dígitos decimales. Tenga en cuenta que Math.floor redondea al siguiente entero hacia menos infinito y por lo tanto da un resultado diferente cuando se aplica a números negativos.

• Las especificaciones dicen que se convierte en un entero:

  Sea lnum ToInt32(lval).

• Rendimiento: esto ha sido probado en jsperf antes.

Javascript representa Number como Números flotantes de 64 bits de doble precisión.

Math.floor funciona con esto en mente.

Las operaciones a nivel de bits funcionan en enteros de 32 bits firmados. los enteros firmados de 32 bits usan el primer bit como significante negativo y los otros 31 bits son el número. Debido a esto, el número mínimo y máximo permitido números firmados de 32 bits son -2,147,483,648 y 2147483647 (0x7FFFFFFFF), respectivamente.

Así que cuando estás haciendo | 0, estás esencialmente haciendo es & 0xFFFFFFFF. Esto significa que cualquier número que se represente como 0x80000000 (2147483648) o mayor volverá como un número negativo.

Por ejemplo:

 // Safe
 (2147483647.5918 & 0xFFFFFFFF) ===  2147483647
 (2147483647      & 0xFFFFFFFF) ===  2147483647
 (200.59082098    & 0xFFFFFFFF) ===  200
 (0X7FFFFFFF      & 0xFFFFFFFF) ===  0X7FFFFFFF

 // Unsafe
 (2147483648      & 0xFFFFFFFF) === -2147483648
 (-2147483649     & 0xFFFFFFFF) ===  2147483647
 (0x80000000      & 0xFFFFFFFF) === -2147483648
 (3000000000.5    & 0xFFFFFFFF) === -1294967296

También. Las operaciones bitwise no "floor". Ellos truncan, que es lo mismo que decir, redondean más cerca de 0. Una vez que vas alrededor de números negativos, Math.floor redondea hacia abajo mientras que comienza a redondear hacia arriba.

Como dije antes, Math.floor es más seguro porque funciona con números flotantes de 64 bits. Bitwise es más rápido, sí, pero limitado al alcance firmado de 32 bits.

Para resumir:

• Funciona de la misma manera si se trabaja desde 0 to 2147483647.
• Bitwise es 1 número apagado si se trabaja desde -2147483647 to 0.
• Bitwise es completamente diferente para números menores que -2147483648 y mayores que 2147483647.

Si realmente quieres ajustar el rendimiento y usar ambos:

function floor(n) {
    if (n >= 0 && n < 0x80000000) {
      return n & 0xFFFFFFFF;
    }
    if (n > -0x80000000 && n < 0) {
      return (n - 1) & 0xFFFFFFFF;
    }
    return Math.floor(n);
}

Solo para agregar Math.trunc funciona como operaciones bitwise. Así que puedes hacer esto:

function floor(n) {
    if (n > -0x80000000 && n < 0x80000000) {
      return n & 0xFFFFFFFF;
    }
    return Math.trunc(n);
}