JavaScript's bit operators operate by converting numbers into 32-bit binary sequences and are suitable for underlying data processing, performance optimization, and specific algorithms. 1. & (And): Return 1 only if both digits are 1; 2. | (or): Return 1 if either is 1; 3. ^ (exclusive OR): Return 1 only if digits are 1; 4. ~ (non): Inverse bit by bit; 5. > (symbol extension right shift): Move right and keep the sign bit; 7. >>> (zero fill right shift): Move right and fill zero. Common uses include logo bit management, performance optimization, encryption, game development, etc. Notes include: the value will be converted to 32-bit signed integers, floating-point numbers will be truncated, and binary output should be used to observe the results during debugging. Although daily development is rarely used, it is very critical in specific scenarios such as protocol analysis, compression, and high-frequency trading, and it is often seen in coding interviews.

Bitwise operators in JavaScript might seem a bit obscure if you're used to working with regular arithmetic or logical operations, but they're powerful tools when you need to work directly with binary numbers. These operators treat their operators as sequences of 32 bits (zeros and ones), rather than decimal or floating-point numbers.

What Do Bitwise Operators Actually Do?

JavaScript bitwise operators perform operations on the binary representations of numbers — meaning each number is treated as a set of 32 bits. This can be useful for tasks like low-level manipulation, performance optimizations, or even some clever tricks in algorithms.

Here are the main bitwise operators:

• & (AND): Returns a 1 in each bit position where both bits are 1
• | (OR): Returns a 1 in each bit position where at least one bit is 1
• ^ (XOR): Returns a 1 in each bit position where only one bit is 1
• ~ (NOT): Inverts the bits of its operand
• (Left shift): Shifts bits to the left, filling in zeros from the right
• (Sign-propagating right shift): Shifts bits to the right, preserving the sign bit
• (Zero-fill right shift): Shifts bits to the right, filling in zeros from the left

Even though JavaScript uses floating-point numbers, these operators temporarily convert them into signed 32-bit integers for processing, then convert them back.

Common Use Cases for Bitwise Operators

You don't use bitwise operators every day in most web development tasks, but here are situations where they come in handy:

• Flags and settings : You can store multiple boolean flags in a single integer. For example, using 4 bits, you could represent four different options — each either on or off.
• Performance optimization : Some older engines were faster with bit shifts than with multiplication/division by powers of two.
• Cryptography or hashing : Algorithms sometimes rely on bitwise operations for mixing bits thoroughly.
• Game development or simulations : Managing states efficiently, especially in systems that require compact data structures.

For example, if you want to check whether a specific flag is active in a status byte:

 const FLAG_READ = 0b0001;
const FLAG_WRITE = 0b0010;

let permissions = FLAG_READ | FLAG_WRITE; // 0b0011

if (permissions & FLAG_READ) {
  console.log("Read permission granted");
}

Gotchas and Things to Watch Out For

Working with bitwise operators in JavaScript has a few quirks:

• All numbers are treated as 32-bit signed integers during bitwise operations. So if you have a number larger than 231 - 1, it wraps around or becomes negative due to two's complement representation.
• The operator gives an unsigned result, while preserves the sign. That means -1 >> 1 will still be -1 , but -1 >>> 1 becomes a large positive number.
• Bitwise operations may not work as expected with floats since they get truncated to integers.

If you're debugging unexpected results, remember: always log values ??in binary format ( toString(2) ) to see what's happening under the hood.

When Should You Actually Use Them?

Honestly, unless you're dealing with things like protocol parsing, compression, or performance-sensitive code, bitwise operators won't be your daily bread and butter. But knowing how they work gives you another tool in your toolkit — especially when space or speed really matters.

They also pop up in coding interviews sometimes, so being comfortable with them can give you an edge.

Basically that's it.

The above is the detailed content of What are bitwise operators in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!