# BITOP

> Perform bitwise operations between strings.

The `BITOP` command in Redis is used to perform bitwise operations on multiple keys (or Redis strings) and store the result in a destination key. It supports standard logical operations (AND, OR, XOR, NOT) and advanced operations (DIFF, DIFF1, ANDOR, ONE) for complex bit manipulation.


## Arguments

<ParamField body="operation" type="AND | OR | XOR | NOT | DIFF | DIFF1 | ANDOR | ONE | and | or | xor | not | diff | diff1 | andor | one" required>
   Specifies the type of bitwise operation to perform (case-insensitive):
   
   **Standard Operations:**
   - `AND` or `and`: Bitwise AND
   - `OR` or `or`: Bitwise OR
   - `XOR` or `xor`: Bitwise XOR
   - `NOT` or `not`: Bitwise NOT
   
   **Advanced Operations (Redis 8.2+):**
   - `DIFF` or `diff`: A bit is set only if it's set in all source bitmaps
   - `DIFF1` or `diff1`: A bit is set if it's set in the first key but not in any of the other keys
   - `ANDOR` or `andor`: A bit is set if it's set in X and also in one or more of Y1, Y2, ...
   - `ONE` or `one`: A bit is set if it's set in exactly one source key
</ParamField>

<ParamField body="destkey" type="str" required>
    The key to store the result of the operation in.
</ParamField>

<ParamField body="keys" type="*List[str]" required >
    One or more keys to perform the operation on.
    </ParamField>

## Response

<ResponseField type="int" required>
  The size of the string stored in the destination key.
</ResponseField>

<RequestExample>
```py Standard Operations
# AND operation
redis.setbit("key1", 0, 1)
redis.setbit("key2", 0, 0)
redis.setbit("key2", 1, 1)

assert redis.bitop("AND", "dest", "key1", "key2") == 1

# OR operation
redis.bitop("OR", "dest", "key1", "key2")

# XOR operation
redis.bitop("XOR", "dest", "key1", "key2")

# NOT operation (only accepts one source key)
redis.bitop("NOT", "dest", "key1")
```

```py DIFF Operation (Redis 8.2+)
# Set bits in multiple bitmaps
redis.setbit("bitmap1", 0, 1)
redis.setbit("bitmap1", 1, 1)
redis.setbit("bitmap2", 1, 1)
redis.setbit("bitmap2", 2, 1)

# DIFF: bits set in all sources
result = redis.bitop("DIFF", "result", "bitmap1", "bitmap2")
# Result: bit 1 is set (only bit present in both)
```

```py DIFF1 Operation (Redis 8.2+)
# Set bits in bitmaps
redis.setbit("exclude", 0, 1)
redis.setbit("exclude", 1, 1)
redis.setbit("include1", 1, 1)
redis.setbit("include2", 2, 1)

# DIFF1: bits in first key but not in others
result = redis.bitop("DIFF1", "result", "exclude", "include1", "include2")
# Result: bit 0 is set (only in exclude, not in include1 or include2)
```

```py ANDOR Operation (Redis 8.2+)
# Set bits in bitmaps
redis.setbit("required", 0, 1)
redis.setbit("required", 1, 1)
redis.setbit("option1", 1, 1)
redis.setbit("option2", 2, 1)

# ANDOR: bits in required AND in at least one option
result = redis.bitop("ANDOR", "result", "required", "option1", "option2")
# Result: bit 1 is set (in required AND in option1)
```

```py ONE Operation (Redis 8.2+)
# Set bits in multiple sources
redis.setbit("source1", 0, 1)
redis.setbit("source1", 1, 1)
redis.setbit("source2", 1, 1)
redis.setbit("source2", 2, 1)
redis.setbit("source3", 2, 1)

# ONE: bits set in exactly one source
result = redis.bitop("ONE", "result", "source1", "source2", "source3")
# Result: bit 0 is set (only in source1)
```
</RequestExample>

## Advanced Operations Details (Redis 8.2+)

### DIFF
A bit in the destination is set if it is set in **all** source bitmaps. This is equivalent to the intersection of all source bitmaps.

**Use Cases:**
- Finding common features across multiple datasets
- Identifying users present in all segments
- Intersection of multiple filters

### DIFF1
A bit in the destination is set if it is set in the **first key** but **not in any of the other keys**. This finds bits unique to the first bitmap.

**Use Cases:**
- Finding exclusive features
- Identifying users in one segment but not in others
- Exclusion filtering

### ANDOR
A bit in the destination is set if it is set in **X and also in one or more of Y1, Y2, ...**. This implements "X AND (Y1 OR Y2 OR ...)" logic.

**Use Cases:**
- Required condition with optional alternatives
- Users with a required attribute and at least one optional attribute
- Complex filtering with mandatory and optional criteria

### ONE
A bit in the destination is set if it is set in **exactly one** of the source keys. This finds bits that are unique to a single source.

**Use Cases:**
- Finding unique occurrences
- Identifying exclusive memberships
- Detecting singular conditions across multiple sets

<Note>
The advanced operations (DIFF, DIFF1, ANDOR, ONE) are available in Redis 8.2.0 and later.
</Note>