Usando OR bit a bit para somar um número

Um colega meu encontrou um método para calcular números flutuantes usando um bit a bit ou:

var a = 13.6 | 0; //a == 13

Estávamos conversando sobre isso e imaginando algumas coisas.

• Como funciona? Nossa teoria era que o uso de um operador desse tipo lança o número para um número inteiro, removendo a parte fracionária
• Tem alguma vantagem sobre fazer Math.floor ? Talvez seja um pouco mais rápido? (trocadilho não pretendido)
• Tem alguma desvantagem? Talvez não funcione em alguns casos? A clareza é óbvia, já que tínhamos que descobrir, e bem, estou escrevendo essa pergunta.

Obrigado.

Como funciona? Nossa teoria era que o uso de um operador desse tipo lança o número para um número inteiro, removendo a parte fracionária

Todas as operações bit a bit, exceto shift direito não assinado >>>, funcionam em números inteiros de 32 bits assinados. Portanto, o uso de operações bit a bit converterá um float em um número inteiro.

Tem alguma vantagem sobre o Math.floor? Talvez seja um pouco mais rápido? (trocadilho não pretendido)

http://jsperf.com/or-vs-floor/2 parece um pouco mais rápido

Tem alguma desvantagem? Talvez não funcione em alguns casos? A clareza é óbvia, já que tínhamos que descobrir, e bem, estou escrevendo essa pergunta.

• Não passará jsLint.
• Somente números inteiros assinados de 32 bits
• Estranho comportamento comparativo:, Math.floor(NaN) === NaNenquanto(NaN | 0) === 0

Isso é truncamento em oposição ao revestimento. A resposta de Howard é meio correta; Mas eu acrescentaria que Math.floorfaz exatamente o que é suposto com relação a números negativos. Matematicamente, é isso que é um piso.

No caso descrito acima, o programador estava mais interessado em truncar ou cortar o decimal completamente. Embora a sintaxe que eles usaram oculte o fato de que eles estão convertendo o float em um int.

No ECMAScript 6, o equivalente a |0é Math.trunc , devo dizer:

Retorna a parte integral de um número removendo quaisquer dígitos fracionários. Apenas trunca o ponto e os dígitos por trás dele, não importa se o argumento é um número positivo ou 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

Seu primeiro ponto está correto. O número é convertido em um número inteiro e, portanto, qualquer dígito decimal é removido. Observe que isso Math.floorarredonda para o próximo número inteiro no sentido de menos infinito e, portanto, fornece um resultado diferente quando aplicado a números negativos.

Javascript representa Numbercomo números flutuantes de precisão dupla de 64 bits .

Math.floor trabalha com isso em mente.

As operações bit a bit funcionam em números inteiros assinados de 32 bits . Inteiros com sinal de 32 bits usam o primeiro bit como significante negativo e os outros 31 bits são o número. Por esse motivo, os números mínimo e máximo permitidos para números assinados de 32 bits são -2.147.483.648 e 2147483647 (0x7FFFFFFFF), respectivamente.

Então, quando você está fazendo | 0, você está essencialmente fazendo é& 0xFFFFFFFF . Isso significa que qualquer número representado como 0x80000000 (2147483648) ou superior retornará como um número negativo.

Por exemplo:

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

Além disso. As operações bit a bit não "atendem". Eles truncam , o que é o mesmo que dizer, eles se aproximam mais 0. Depois de ir ao redor para números negativos, Math.floorrodadas para baixo , enquanto start bit a bit arredondamento para cima .

Como eu disse antes, Math.flooré mais seguro porque opera com números flutuantes de 64 bits. Bitwise é mais rápido , sim, mas limitado ao escopo assinado de 32 bits.

Para resumir:

• Bitwise funciona da mesma forma se você trabalhar 0 to 2147483647.
• Bitwise é um número desativado se você trabalha -2147483647 to 0.
• Bitwise é completamente diferente para números menores que -2147483648e maiores que 2147483647.

Se você realmente deseja ajustar o desempenho e usar os dois:

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

Apenas para adicionar Math.trunctrabalhos como operações bit a bit. Então você pode fazer isso:

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

• As especificações dizem que é convertido em um número inteiro:

  Seja lnum o ToInt32 (lval).

• Desempenho: isso já foi testado no jsperf .

nota: link morto para especificação removida