User Name:


User Email:




This information will only be saved for the purposes of communicating with those who have provided this information voluntarily regarding our services.We will never sell your name or email address to anyone.
© 2018 - First Crazy Developer (Abhishek Kumar)
  

crazydeveloper Bitwise operators in JavaScript

The table below summarizes the bitwise operators in JavaScript:

OperatorUsageResult
Bitwise AND a & b Returns 1 for each bit position where both operands are 1
Bitwise OR a | b Returns 1 for each bit position where either operand is 1
Bitwise XOR a ^ b Returns 1 for each bit position where either but not both are 1
Left shift a << b Shifts in binary fashion all bits one position to the left; discarding the left bit and filling the right bit with 0.
Right shift a >> b Shifts in binary fashion all bits one position to the right, discarding the right bit. This operations maintains the original sign (+ or -).
0-fill right shift a >>> b Shifts in binary fashion all bits one position to the right, discarding the right bit and filling the left bit with 0.

JavaScript does not support an integer type. All numbers in JavaScript are stored in 64-bit floating point format i.e. double precision floating point. The bitwise operators that manipulate numbers at the bit level do not perform operations directly on this 64-bit floating-point representation. Instead, they coerce the numeric values to signed 32-bit integers, do the necessary operation, and again convert the result back to floating point format. This conversion has a performance impact.

You get the correct results for only up to 32 bits. During the conversion to 32-bit, the fractional part and any bits beyond the 32nd are dropped. If you have more bits than that, the value gets rounded to the nearest representable floating-point number.

  1. var a = 0xFFFFFFFFF; // => 36 bits all set to 1
  2. var b = 0xFFFFFFFFF; // => 36 bits all set to 1
  3. var c = a & b; // bitwise AND
  4. alert(c); // => -1

You may expect that c's value has all 36 bits set to 1 following the bitwise & operation, but because of the conversion to 32-bits that is not the case. JavaScript converts to 32-bit, executes the bitwise AND operation, and the resulting 32-bits are all set to 1 which is equal to -1.

Let's look at an example with floating point numbers:

  1. var a = 2.6; // represented as bits 0010, fractional part discarded
  2. var b = 6.2 // represented as bits 0110, fractional part discarded
  3. var c = a & b; // => bits 0010, which is equal to 2
  4. alert(c); // => 2

Strangely, if you use NaN, Infinity, or -Infinity as operands in bitwise operations, they are converted to 0.

In all C-like languages, bitwise operators are extremely fast. Until recently, they were slow in JavaScript but the latest versions of web browsers can JIT-compile JavaScript code. These operations have accelerated enough to be useful.

Bitwise manipulations are typically close to the hardware and therefore they don't come up very often in JavaScript programming.

A common mistake it to use bitwise & and | operators instead of logical && and || operators. This can lead to hard-to-detect bugs. Here is what may happen. Say we have a variable x with a value of 5 and you have mistakenly typed & instead of &&.

  1. var x = 5;
  2. if (x > 5 & x < 8) {
  3. alert(true);
  4. } else {
  5. alert(false);
  6. }

This is false, which is the same if you had typed the && operator: if (x<=5 && x>7). Although we are getting the expected result, we have improperly used a logical & operator which is intended for bit-level operations only. Again, be aware of this mistake as it can lead to difficult to find bugs.


crazydeveloper Home Page 23 April 2015

Become a Fan