Overview of Go bitwise operators and their uses with binary examples, including AND OR XOR left and right shifts, plus practical use cases and code samples
Bitwise operators work directly on the binary representation of integer values, manipulating one bit at a time. In Go, these operators are essential for low-level programming, bit masks, flags, and efficient arithmetic (shifts are equivalent to multiplying/dividing by powers of two for non-negative integers). This guide covers the Go bitwise operators with clear binary demonstrations and runnable examples.
Bitwise AND (&)
Bitwise OR (|)
Bitwise XOR (^)
Left shift (<<)
Right shift (>>)
Use cases
Flags and bit masks (packing multiple boolean flags into one integer)
Performance-sensitive arithmetic (shift-based multiply/divide by powers of two)
Low-level protocol parsing, embedded and systems programming
Operator quick reference
Operator
Meaning
Example
&
Bitwise AND — 1 if both bits are 1
12 & 25 // 8
|
Bitwise OR — 1 if at least one bit is 1
12 | 25 // 29
^
Bitwise XOR — 1 if bits differ
12 ^ 25 // 21
<<
Left shift — shift bits left (multiply by 2^n for non-negative)
212 << 1 // 424
>>
Right shift — shift bits right (divide by 2^n for non-negative)
212 >> 2 // 53
Bitwise AND (&)
Bitwise AND compares each bit of two operands and yields 1 only when both corresponding bits are 1; otherwise the result bit is 0.Example: 12 & 25
package mainimport "fmt"func main() { var x, y int = 12, 25 z := x | y fmt.Println(z) // 29}
Bitwise XOR (^)
Bitwise XOR (exclusive OR) produces 1 when the corresponding bits differ, and 0 when they are the same.Binary demonstration for 12 ^ 25:
package mainimport "fmt"func main() { var x, y int = 12, 25 z := x ^ y fmt.Println(z) // 21}
Note: In Go, ^ is also the unary bitwise NOT (complement) when used with a single operand (for example ^x flips all bits of x). In the examples above ^ is used as a binary XOR operator.
Left shift (<<)
Left shifting moves bits to the left, inserting zeros on the right. For non-negative integers, shifting left by n is equivalent to multiplying by 2^n (subject to type limits and overflow).Example: 212 << 1Binary demonstration:
212 = 11010100212 << 1 = 110101000 = 424
Go example:
package mainimport "fmt"func main() { var x int = 212 z := x << 1 fmt.Println(z) // 424}
Run the program:
go run main.go# Output:# 424
Right shift (>>)
Right shifting moves bits to the right, discarding bits shifted out on the right. For unsigned or non-negative signed integers, right shifting by n is equivalent to integer division by 2^n, rounding down.Example: 212 >> 2Binary demonstration:
212 = 11010100212 >> 2 = 00110101 = 53
Go example:
package mainimport "fmt"func main() { var x int = 212 z := x >> 2 fmt.Println(z) // 53}
Be careful with signed integers and right shifts: the fill behavior for the leftmost bits (sign extension vs. zero fill) depends on the type and implementation. For predictable behavior, use unsigned integers (uint, uint32, uint64) when performing bit-level shifts.
