JS Bitwise operation

JavaScript Bitwise Operators and Operations

In JavaScript, a number is typically stored as a 64-bit floating-point number. However, bitwise operations are performed on a 32-bit binary number.

To perform a bitwise operation, JavaScript converts the number into a 32-bit binary number (signed), performs the operation at the binary level, and then converts the result back into a standard 64-bit JavaScript number.

Understanding JavaScript bitwise operators is crucial for low-level programming, performance optimizations, and manipulating binary data.

List of JavaScript Bitwise Operators

Here is a detailed explanation of each JavaScript bitwise operator, complete with syntax, examples, and truth tables.

1. Bitwise AND Operator (&)

The Bitwise AND operator is a binary operator (i.e., it accepts two operands). The Bitwise AND (&) returns 1 if both the corresponding bits of the operands are set (i.e., 1). It returns 0 in any other case.

let x = 5;  // Binary: 0101
let y = 3;  // Binary: 0011
console.log(x & y); // Output: 1 (Binary: 0001)

Truth Table for Bitwise AND:

2. Bitwise OR Operator (|)

The Bitwise OR operator is a binary operator. Bitwise OR (|) returns 1 if any of the corresponding bits of the operands is set (i.e., 1), and returns 0 only if both bits are 0.

let x = 5;  // Binary: 0101
let y = 3;  // Binary: 0011
console.log(x | y); // Output: 7 (Binary: 0111)

Truth Table for Bitwise OR:

3. Bitwise XOR Operator (^)

The Bitwise XOR (Exclusive OR) operator is a binary operator. Bitwise XOR (^) returns 1 if both the operands are different (one is 1 and the other is 0). It returns 0 if both bits are the same.

let x = 5;  // Binary: 0101
let y = 3;  // Binary: 0011
console.log(x ^ y); // Output: 6 (Binary: 0110)

Truth Table for Bitwise XOR:

4. Bitwise NOT Operator (~)

The Bitwise NOT operator is a unary operator (i.e., it accepts a single operand). Bitwise NOT (~) simply flips the bits of its operand: 0 becomes 1, and 1 becomes 0.

console.log(~10);  // Output: -11
console.log(~-10); // Output: 9

Truth Table for Bitwise NOT:

5. Left Shift Operator (<<)

The Left Shift (<<) is a binary operator. The first operand specifies the number, and the second operand specifies the number of bits to shift. Each bit is shifted towards the left, and 0 bits are added from the right. The excess bits shifted off to the left are discarded.

let a = 4; 
console.log(a << 1); // Output: 8
console.log(a << 4); // Output: 64

Example Breakdown:

(Note: Shifting left by 1 is mathematically equivalent to multiplying the number by 2.)

6. Sign Propagating Right Shift Operator (>>)

The Sign Propagating Right Shift (>>) is a binary operator. Each bit is shifted towards the right, and the overflowing bits on the right are discarded.

This is known as "Sign Propagating" because the new bits added from the left depend upon the sign of the original number (i.e., 0 is added if the number is positive, and 1 is added if the number is negative).

let a = 4; 
let b = -32; 
console.log(a >> 1); // Output: 2
console.log(b >> 4); // Output: -2

Example Breakdown:

7. Zero Fill Right Shift Operator (>>>)

The Zero Fill Right Shift (>>>) is a binary operator. Each bit is shifted towards the right, and the overflowing bits are discarded. Unlike the sign-propagating shift, a 0 bit is always added from the left regardless of the sign. Therefore, it is called the zero fill right shift.

let a = 4; 
let b = -1; 
console.log(a >>> 1); // Output: 2
console.log(b >>> 4); // Output: 268435455

Example Breakdown:

Summary of JavaScript Bitwise Operators

Below is a quick reference cheat sheet for the Bitwise Operators available in JavaScript:

Recommended Links

• JavaScript Operators Complete Reference
• JavaScript Cheat Sheet.