> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go Bit Clear Assignment
The `&^=` operator is the bitwise clear (AND NOT) assignment operator in Go. It clears the bits of the left-hand operand based on the set bits (the `1`s) of the right-hand operand, and assigns the resulting value back to the left-hand operand.
```go theme={"dark"}
x &^= y
```
This operation is logically equivalent to `x = x &^ (y)`. The parentheses around `y` are critical because `&^` has a higher precedence than lower-precedence operators like `+` or `-`. For example, an assignment like `x &^= a + b` evaluates as `x = x &^ (a + b)`, not `(x &^ a) + b`.
Additionally, the Go specification guarantees that the expression `x` is evaluated only once. This is a vital distinction from manual expansion, ensuring safe and efficient execution even when `x` is a complex expression like a map index (`m[key] &^= y`), which explicitly lacks an addressable memory location in Go.
## Mechanics
The operator evaluates the binary representation of both operands bit by bit.
* If a bit in the right operand `y` is `1`, the corresponding bit in the left operand `x` is forced to `0`.
* If a bit in the right operand `y` is `0`, the corresponding bit in the left operand `x` remains unchanged.
**Truth Table for `x &^ (y)`:**
| Bit in `x` | Bit in `y` | Result in `x` |
| :--------: | :--------: | :-----------: |
| 0 | 0 | **0** |
| 0 | 1 | **0** |
| 1 | 0 | **1** |
| 1 | 1 | **0** |
## Code Visualization
To observe the bitwise manipulation, it is best to view the operands as binary literals:
```go theme={"dark"}
package main
import "fmt"
func main() {
// x = 10101010 (Decimal: 170)
var x uint8 = 0b10101010
// y = 00001111 (Decimal: 15)
var y uint8 = 0b00001111
// Apply bitwise clear assignment
x &^= y
// The lower 4 bits of y are 1, so the lower 4 bits of x are cleared to 0.
// The upper 4 bits of y are 0, so the upper 4 bits of x remain unchanged.
fmt.Printf("%08b\n", x) // Output: 10100000
}
```
## Type Constraints
Because `&^=` performs bitwise arithmetic, the Go compiler requires both operands to be of the same integer type (e.g., `int`, `uint8`, `int32`) or untyped constants representable by values of that type. It cannot be applied to floating-point numbers, complex numbers, or non-numeric types.
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
