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

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

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

## Response

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

<RequestExample>
```ts Standard Operations
// AND operation
await redis.bitop("and", "destKey", "sourceKey1", "sourceKey2");

// OR operation
await redis.bitop("or", "destKey", "sourceKey1", "sourceKey2");

// XOR operation
await redis.bitop("xor", "destKey", "sourceKey1", "sourceKey2");

// NOT operation (only accepts one source key)
await redis.bitop("not", "destKey", "sourceKey");
```

```ts DIFF Operation (Redis 8.2+)
// Set bits in multiple bitmaps
await redis.setbit("bitmap1", 0, 1);
await redis.setbit("bitmap1", 1, 1);
await redis.setbit("bitmap2", 1, 1);
await redis.setbit("bitmap2", 2, 1);

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

```ts DIFF1 Operation (Redis 8.2+)
// Set bits in bitmaps
await redis.setbit("exclude", 0, 1);
await redis.setbit("exclude", 1, 1);
await redis.setbit("include1", 1, 1);
await redis.setbit("include2", 2, 1);

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

```ts ANDOR Operation (Redis 8.2+)
// Set bits in bitmaps
await redis.setbit("required", 0, 1);
await redis.setbit("required", 1, 1);
await redis.setbit("option1", 1, 1);
await redis.setbit("option2", 2, 1);

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

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

// ONE: bits set in exactly one source
await 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>