Używanie bitowego OR 0 do wpisywania liczby

Mój kolega natknął się na metodę wyprowadzania liczb zmiennoprzecinkowych za pomocą bitów lub:

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

Rozmawialiśmy o tym i zastanawialiśmy się nad kilkoma rzeczami.

• Jak to działa? Nasza teoria była taka, że ​​użycie takiego operatora rzutuje liczbę na liczbę całkowitą, usuwając w ten sposób część ułamkową
• Czy ma to jakieś zalety w stosunku do robienia Math.floor? Może to trochę szybciej? (gra słów nie przeznaczona)
• Czy ma to jakieś wady? Może w niektórych przypadkach to nie działa? Klarowność jest oczywista, ponieważ musieliśmy to rozgryźć i cóż, piszę to pytanie.

Dzięki.

Jak to działa? Nasza teoria była taka, że ​​użycie takiego operatora rzutuje liczbę na liczbę całkowitą, usuwając w ten sposób część ułamkową

Wszystkie operacje bitowe oprócz prawego przesunięcia bez znaku >>>, działają na 32-bitowych liczbach całkowitych ze znakiem. Zatem użycie operacji bitowych przekształci liczbę zmiennoprzecinkową w liczbę całkowitą.

Czy ma to jakieś zalety w stosunku do robienia Math.floor? Może to trochę szybciej? (gra słów nie przeznaczona)

http://jsperf.com/or-vs-floor/2 wydaje się nieco szybszy

Czy ma to jakieś wady? Może w niektórych przypadkach to nie działa? Klarowność jest oczywista, ponieważ musieliśmy to rozgryźć i cóż, piszę to pytanie.

• Nie przejdzie jsLint.
• Tylko 32-bitowe liczby całkowite ze znakiem
• Dziwne zachowanie porównawcze:, Math.floor(NaN) === NaNpodczas gdy(NaN | 0) === 0

Jest to obcięcie w przeciwieństwie do podłogi. Odpowiedź Howarda jest w pewnym sensie poprawna; Dodałbym jednak, że Math.floorrobi dokładnie to, co powinien, w odniesieniu do liczb ujemnych. Matematycznie taka jest podłoga.

W przypadku opisanym powyżej programista był bardziej zainteresowany obcięciem lub całkowitym odcięciem dziesiętnego. Chociaż zastosowana przez nich składnia przesłania fakt, że przekształcają zmiennoprzecinkowe na int.

W ECMAScript 6 odpowiednikiem |0jest Math.trunc , co powinienem powiedzieć:

Zwraca integralną część liczby poprzez usunięcie wszelkich cyfr ułamkowych. Po prostu obcina kropkę i cyfry za nią, bez względu na to, czy argument jest liczbą dodatnią czy ujemną.

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

Twój pierwszy punkt jest poprawny. Liczba jest rzutowana na liczbę całkowitą, a zatem usuwane są wszystkie cyfry dziesiętne. Zauważ, że Math.floorzaokrągla do następnej liczby całkowitej w kierunku minus nieskończoności, a zatem daje inny wynik, gdy zostanie zastosowany do liczb ujemnych.

JavaScript reprezentuje Numberjako zmiennoprzecinkowe liczby 64-bitowe Double Precision .

Math.floor działa z tą myślą.

Operacje bitowe działają w 32-bitowych podpisane liczb całkowitych. 32-bitowe liczby całkowite ze znakiem używają pierwszego bitu jako ujemnego znacznika, a pozostałe 31 bitów to liczba. Z tego powodu, minimalna i maksymalna liczba dozwolonych 32-bitowych liczb ze znakami wynosi odpowiednio -2 147 483 648 i 2147483647 (0x7FFFFFFFF).

Więc kiedy to robisz | 0, zasadniczo to robisz & 0xFFFFFFFF. Oznacza to, że każda liczba reprezentowana jako 0x80000000 (2147483648) lub wyższa zwróci liczbę ujemną.

Na przykład:

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

Również. Operacje bitowe nie „piętrzą”. Oni obciąć , który jest taki sam jak powiedzenie, że zaokrąglanie najbliżej 0. Po przejściu do liczb ujemnych Math.floorzaokrągla się w dół, a bitowe zaczyna zaokrąglać w górę .

Jak powiedziałem wcześniej, Math.floorjest bezpieczniejszy, ponieważ działa z liczbami zmiennoprzecinkowymi 64-bitowymi. Bitowe jest szybsze , tak, ale ograniczone do 32-bitowego podpisanego zakresu.

Podsumowując:

• Bitowe działa tak samo, jeśli pracujesz z 0 to 2147483647.
• Bitowa to 1 liczba wyłączona, jeśli pracujesz z -2147483647 to 0.
• Bitowa jest zupełnie inna dla liczb mniejszych -2147483648i większych niż 2147483647.

Jeśli naprawdę chcesz poprawić wydajność i użyć obu:

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

Tylko dodanie Math.truncdziała jak operacje bitowe. Możesz to zrobić:

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

• Specyfikacja mówi, że jest konwertowany na liczbę całkowitą:

  Niech lnum będzie ToInt32 (lval).

• Wydajność: zostało to wcześniej przetestowane w jsperf .

Uwaga: usunięto martwy link do specyfikacji