What Are Bitwise Operations and When Would You Actually Use Them?

July 16, 2026 8 min read by Chunky Munster
bitwise operations — Chunky Munster

Bitwise operations are a way to work with the individual bits inside a number instead of treating the number as one lump. They’re useful when a value needs to carry multiple yes/no states, when you want to mask off part of a number, or when you need to nudge bits around for performance or protocol work. If you want to test the logic without hand-counting binary, try our free bitwise calculator.

What bitwise operations actually do

Computers store integers in binary, so every number is really a row of 0s and 1s. A bitwise operator reads those bits position by position and applies a rule to each pair. That is different from arithmetic, where 5 + 3 means “turn two values into a third value,” not “inspect their binary structure.”

The core operators are simple once you stop pretending they’re magic:

That sounds abstract until you treat a number like a compact switch panel. One integer can encode several independent flags: read access, write access, admin access, debug mode, archived state, and so on. Instead of storing six separate booleans, you can pack them into one value and toggle them with bitwise operations.

Why developers still use them

Bitwise work shows up in places where binary layout matters. Think network protocols, file formats, embedded systems, graphics flags, permissions, and low-level parsing. If you’re reading a header byte, checking a mask, or packing several values into one field, bitwise operations are the blunt instrument that happens to fit the job.

They also show up in code that needs to be small and fast. That does not mean every use is a micro-optimisation stunt. It usually means the data is already structured as bits, so using normal arithmetic would be the wrong shape of tool.

A few common examples:

One place where the idea feels especially familiar is text and encoding work. If you have ever looked at how computers store text as 0s and 1s, you have already seen the same underlying mechanic: data gets packed into bits, and sometimes you need to pull part of it back out.

How the main operators behave

Here’s the useful mental model: treat each bit as a tiny yes/no answer. & asks “is this bit set in both numbers?” | asks “is it set in either?” ^ asks “is it set in exactly one?”

That makes masking straightforward. If you want to check whether a specific flag is present, you AND the value with a mask that has only that bit turned on. If the result is non-zero, the flag was there.

// Check whether bit 3 is set in flags = 0b10110100
const flags = 0b10110100;
const mask = 0b00001000;

const isSet = (flags & mask) !== 0; // false

Shifts are mostly about moving bits around. Left shift often looks like multiplying by powers of two in unsigned contexts, because you are moving all bits one place left and filling the right side with zeroes. Right shift usually halves values in a similar sense, though signed numbers can get messy because some languages preserve the sign bit.

~ is the operator that tends to trip people up first. It flips every bit, so in languages with fixed-width signed integers, the result can look strange if you expected a simple “inverse.” That’s normal; the operator is doing exactly what it says, just not what beginners usually imagine.

When bitwise operations are the right move

Use them when the data itself is bit-packed or when the operation is really about binary structure. That includes permissions, masks, protocol flags, and hardware registers. It also includes any time you want to extract, combine, or test a subset of bits without converting everything into another format first.

They are not a general replacement for normal logic. If you are deciding whether a user can access a page, a boolean field is usually clearer than a bit mask unless you have a real reason to compress the state. Clarity beats cleverness unless the binary layout matters.

Good reasons to reach for bitwise operations:

  1. You are dealing with packed flags or flags stored in a single integer.
  2. You need to test a specific bit or range of bits.
  3. You are parsing a byte or word from a binary protocol.
  4. You need to set, clear, or toggle individual flags efficiently.

Bad reasons include “it looks low-level so it must be faster” and “I want to be fancy.” Modern compilers are good, and your future self is not impressed by unreadable code. If the intent is simple state logic, simple code wins.

Common patterns: set, clear, toggle, test

Most bitwise code falls into four patterns. Once you know these, the rest is just reading and writing masks without getting lost in the weeds.

The mask is the whole game. If you want bit 4, the mask is 1 << 4. If you want bits 2 through 5, you build a wider mask and use AND to pull those bits out. Bitwise work gets much less mysterious when you stop thinking in decimal and start thinking in masks.

For binary-heavy workflows, a companion tool can help make the number shape visible. Our guide to binary, octal, decimal, and hexadecimal is a useful side quest if you want to stop doing base conversion in your head.

A Worked Example

Say you have a permission byte where each bit means something different:

bit 0 = read
bit 1 = write
bit 2 = execute
bit 3 = admin

Current value: 0b0101

That value means read and execute are on, while write and admin are off. In decimal, it is just 5, which is why bitmasks can look boring until you decode them.

Now walk through the common actions:

// Masks
const READ    = 0b0001;
const WRITE   = 0b0010;
const EXECUTE = 0b0100;
const ADMIN   = 0b1000;

let perms = 0b0101;

// Test
const canWrite = (perms & WRITE) !== 0; // false

// Set write
perms = perms | WRITE; // 0b0111

// Clear execute
perms = perms & ~EXECUTE; // 0b0011

// Toggle admin
perms = perms ^ ADMIN; // 0b1011

If you prefer to see the same thing in a more visual way, plug the values into the bitwise calculator and compare the intermediate results. The important part is not memorising the hex or binary form. It is learning how each operator changes the bits.

One practical trick: name your masks after meaning, not after the literal number. READ is better than 0b0001 in the body of your code. The value can stay low-level; the intent should stay readable.

Where bitwise math can bite you

The main traps are signed integers, operator precedence, and assuming all languages behave the same. In some languages, right shift on a negative number preserves the sign bit. In others, there are separate logical and arithmetic shifts, which matters a lot when you are working with binary data instead of plain numbers.

Precedence also matters. flags & mask === 0 may not mean what you think unless you use parentheses, because the comparison and bitwise operators do not all bind the same way. When in doubt, write (flags & mask) === 0 and move on with your life.

Another classic mistake is using bitwise operators where logical operators belong. In JavaScript, for example, && and || are not the same as & and |. One works with truthiness; the other works on binary representations.

So the rule is simple: use bitwise operations when you mean bits. Use normal boolean logic when you mean truth values. Mixing the two is how you get bugs that look like haunted arithmetic.

Frequently Asked Questions

What are bitwise operations used for?

They are used for working with individual bits inside numbers. Common cases include permissions, feature flags, binary masks, protocol fields, and low-level data parsing. If you need to set, clear, toggle, or test a specific bit, bitwise operations are the native tool for the job.

What is the difference between bitwise and logical operators?

Bitwise operators act on binary digits inside integers. Logical operators act on boolean truth values, usually with short-circuit behavior. For example, & compares bits, while && evaluates whether two expressions are both true.

How do you check if a bit is set?

Use AND with a mask that contains the bit you care about: (value & mask) !== 0. If the result is non-zero, that bit was present. This pattern is the standard way to test a flag in packed binary data.

Why is XOR so useful?

XOR is useful because it toggles bits cleanly and detects differences between two values. It is often used to flip flags, compare values, or swap two integers in toy examples. In real code, its main value is usually in masks and binary workflows, not party tricks.

Wrapping Up

Bitwise operations are not mysterious once you treat them as bit-level switches instead of regular arithmetic. They matter when your data is already packed into bits, when a mask is the cleanest way to express intent, or when you need to inspect a binary format without hand-waving over the details.

If you are decoding flags, testing masks, or trying to figure out why a shift behaved oddly, the fastest way to sanity-check the result is to work it through visually. Give the bitwise calculator a spin, compare the inputs and outputs, and let the binary do what binary does.

If you want the next step, build a tiny permission system or parse a one-byte flag field by hand. That usually makes the whole topic click faster than reading another wall of theory.

// try the tool
bitwise calculator →
// related reading
What Is ASCII85 and When Would You Actually Use It? What Is Octal Notation and When Would You Actually Encounter It? What Does Bitwise NOT Actually Do to a Number?
← all posts