Bitwise AND, OR & XOR Explained

Bitwise operators work on the individual bits of a number rather than its value as a whole. They're the foundation of flags, masks and low-level optimisation, and a bitwise calculator lets you watch them work bit by bit.

Truth tables

NOT flips every bit; XNOR is the negation of XOR (1 when the bits match).

Worked examples

Using 12 (1100) and 10 (1010):

  1100   (12)        1100   (12)        1100   (12)
AND 1010   (10)     OR 1010   (10)    XOR 1010   (10)
  ----               ----               ----
  1000   = 8         1110   = 14        0110   = 6

Bitwise operators in code

The truth tables above show what each operator does in the abstract. Here is the same pair, 12 and 10, run through AND, OR, XOR, NOT, and a left and right shift, in four languages. Every number below was run, not guessed.

Python

a = 12
b = 10

print(a & b)    # AND
print(a | b)    # OR
print(a ^ b)    # XOR
print(~a)       # NOT
print(a << 1)   # left shift
print(a >> 1)   # right shift

Output, in order: 8, 14, 6, -13, 24, 6.

JavaScript

const a = 12;
const b = 10;

console.log(a & b);   // AND
console.log(a | b);   // OR
console.log(a ^ b);   // XOR
console.log(~a);      // NOT
console.log(a << 1);  // left shift
console.log(a >> 1);  // right shift

Output, in order: 8, 14, 6, -13, 24, 6, run through Node.

C

#include <stdio.h>

int main(void) {
    int a = 12, b = 10;
    printf("%d\n", a & b);   /* AND */
    printf("%d\n", a | b);   /* OR */
    printf("%d\n", a ^ b);   /* XOR */
    printf("%d\n", ~a);      /* NOT */
    printf("%d\n", a << 1);  /* left shift */
    printf("%d\n", a >> 1);  /* right shift */
    return 0;
}

Output, in order: 8, 14, 6, -13, 24, 6, on the 32-bit two's complement int every common compiler uses.

Java

public class Bitwise {
    public static void main(String[] args) {
        int a = 12, b = 10;
        System.out.println(a & b);   // AND
        System.out.println(a | b);   // OR
        System.out.println(a ^ b);   // XOR
        System.out.println(~a);      // NOT
        System.out.println(a << 1);  // left shift
        System.out.println(a >> 1);  // right shift
    }
}

Output, in order: 8, 14, 6, -13, 24, 6. Java's int is defined as a 32-bit signed two's complement number, so this never changes between machines.

NOT is the one that surprises people. It does not turn 1100 into 0011: it flips every bit, including the one that marks the sign, so the result reads as negative. NOT 12 is -13 in all four languages, not 3. Python stores whole numbers at any size rather than a fixed 32 bits, but it still defines NOT as -x-1 for the same reason, so ~12 comes out to -13 there too. The two's complement walkthrough works through why, bit by bit. Try it: Not(12d) in BASE-N mode → lands on -13.

A left shift moves every bit one place up and fills the gap with a 0, the same as multiplying by 2: 12 << 1 is 24. A right shift does the opposite, the same as dividing by 2 and dropping the remainder: 12 >> 1 is 6. WideMath's BASE-N mode has no shift key, so these two stay in the code snippets above rather than the calculator.

Bit masking

A mask is a second number chosen for its bit pattern, not its value. Pairing a mask with AND or OR covers three of the four classic bit idioms: test, set and clear. The fourth, toggle, gets its own section next because XOR works differently from the other three.

Toggling bits

Toggle is XOR with a mask: any bit that is 1 in the mask flips in the target, and every other bit stays put. XOR is its own opposite, so toggling the same bit twice always returns the original number, which is why it fits a switch you flip from more than one place in a program.

XOR tricks

XOR has two well known uses beyond masking, and both lean on the same two facts: a number XOR itself is 0, and a number XOR 0 is unchanged.

a, b = 5, 9
a ^= b
b ^= a
a ^= b
print(a, b)   # 9 5

nums = [4, 1, 2, 1, 2]
unique = 0
for n in nums:
    unique ^= n
print(unique)   # 4

On the calculator

Press MODE, choose BASE-N, then SHIFT and 3 to open the logical-operations menu: 1 for AND, 2 for OR, 3 for XOR, 4 for XNOR, 5 for Not(, or 6 for Neg( (two's complement). A number keeps its base no matter which display is active: type 10d for decimal, 1010b for binary, 1Fh for hex or 17o for octal, then switch to BIN to watch the result bit by bit. To build the operands first, see the decimal to binary conversion guide, and for the whole mode the binary, octal & hex calculator pillar guide.

Frequently asked questions

Sources

The language behavior and the swap trick above, checked against their own documentation:

• MDN Web Docs: Bitwise AND (JavaScript)
• Python documentation: binary bitwise operations
• The Java Language Specification: primitive types (int is a 32 bit signed two's complement integer)
• cppreference: C bitwise operators
• Wikipedia: Two's complement
• Wikipedia: XOR swap algorithm