0
# Redis Commands
1

2
ioredis provides complete Redis command support through the RedisCommander interface. All Redis commands are available as methods with proper TypeScript typing, promise-based returns, and optional callback support.
3

4
## Capabilities
5

6
### Command Execution
7

8
All Redis commands are available as methods on Redis and Cluster instances with consistent patterns.
9

10
```typescript { .api }
11
// Generic command execution
12
call(command: string, ...args: any[]): Promise<unknown>;
13

14
// Example command signatures
15
get(key: RedisKey): Promise<string | null>;
16
set(key: RedisKey, value: RedisValue): Promise<"OK">;
17
set(key: RedisKey, value: RedisValue, expiryMode: "EX", time: number): Promise<"OK">;
18
set(key: RedisKey, value: RedisValue, expiryMode: "PX", time: number): Promise<"OK">;
19
set(key: RedisKey, value: RedisValue, mode: "NX"): Promise<"OK" | null>;
20
set(key: RedisKey, value: RedisValue, mode: "XX"): Promise<"OK" | null>;
21

22
// All commands also support callback pattern
23
get(key: RedisKey, callback: Callback<string | null>): void;
24
set(key: RedisKey, value: RedisValue, callback: Callback<"OK">): void;
25
```
26

27
**Usage Examples:**
28

29
```typescript
30
import Redis from "ioredis";
31

32
const redis = new Redis();
33

34
// Promise-based usage
35
const value = await redis.get("key");
36
await redis.set("key", "value");
37

38
// Callback usage
39
redis.get("key", (err, result) => {
40
  if (err) console.error(err);
41
  else console.log(result);
42
});
43

44
// Complex command with options
45
await redis.set("session:123", "data", "EX", 3600, "NX");
46

47
// Generic command execution
48
const result = await redis.call("CUSTOM_COMMAND", "arg1", "arg2");
49
```
50

51
### Buffer Command Variants
52

53
All Redis commands have corresponding buffer variants that work with binary data and return Buffer objects instead of strings.
54

55
```typescript { .api }
56
// Every command has a Buffer variant
57
getBuffer(key: RedisKey): Promise<Buffer | null>;
58
setBuffer(key: RedisKey, value: RedisValue): Promise<Buffer>;
59
hgetBuffer(key: RedisKey, field: string): Promise<Buffer | null>;
60
lrangeBuffer(key: RedisKey, start: number, stop: number): Promise<Buffer[]>;
61

62
// Generic buffer command execution
63
callBuffer(command: string, ...args: any[]): Promise<Buffer>;
64
```
65

66
**Usage Examples:**
67

68
```typescript
69
// Working with binary data
70
const binaryData = Buffer.from("hello world", "utf8");
71
await redis.setBuffer("binary:key", binaryData);
72

73
const result = await redis.getBuffer("binary:key"); // Returns Buffer
74
console.log(result.toString()); // "hello world"
75

76
// Hash operations with buffers
77
await redis.hsetBuffer("hash:key", "field", Buffer.from("value"));
78
const hashValue = await redis.hgetBuffer("hash:key", "field"); // Returns Buffer
79

80
// List operations with buffers
81
await redis.lpushBuffer("list:key", Buffer.from("item1"), Buffer.from("item2"));
82
const items = await redis.lrangeBuffer("list:key", 0, -1); // Returns Buffer[]
83
```
84

85
## String Commands
86

87
Operations on Redis string data type (binary-safe).
88

89
```typescript { .api }
90
// Basic string operations
91
get(key: RedisKey): Promise<string | null>;
92
set(key: RedisKey, value: RedisValue): Promise<"OK">;
93
getset(key: RedisKey, value: RedisValue): Promise<string | null>;
94
append(key: RedisKey, value: RedisValue): Promise<number>;
95
strlen(key: RedisKey): Promise<number>;
96

97
// Multi-key operations
98
mget(...keys: RedisKey[]): Promise<Array<string | null>>;
99
mset(...args: Array<RedisKey | RedisValue>): Promise<"OK">;
100
msetnx(...args: Array<RedisKey | RedisValue>): Promise<number>;
101

102
// Numeric operations
103
incr(key: RedisKey): Promise<number>;
104
incrby(key: RedisKey, increment: number): Promise<number>;
105
incrbyfloat(key: RedisKey, increment: number): Promise<string>;
106
decr(key: RedisKey): Promise<number>;
107
decrby(key: RedisKey, decrement: number): Promise<number>;
108

109
// Substring operations
110
getrange(key: RedisKey, start: number, end: number): Promise<string>;
111
setrange(key: RedisKey, offset: number, value: RedisValue): Promise<number>;
112

113
// Bit operations
114
getbit(key: RedisKey, offset: number): Promise<number>;
115
setbit(key: RedisKey, offset: number, value: number): Promise<number>;
116
bitcount(key: RedisKey): Promise<number>;
117
bitcount(key: RedisKey, start: number, end: number): Promise<number>;
118
```
119

120
**Usage Examples:**
121

122
```typescript
123
// Basic string operations
124
await redis.set("user:name", "Alice");
125
const name = await redis.get("user:name");
126

127
// Expiration
128
await redis.set("session", "abc123", "EX", 3600); // Expire in 1 hour
129

130
// Multi-key operations
131
await redis.mset("key1", "value1", "key2", "value2");
132
const values = await redis.mget("key1", "key2");
133

134
// Numeric operations
135
await redis.set("counter", "0");
136
const count = await redis.incr("counter");
137
await redis.incrby("counter", 10);
138

139
// Conditional operations
140
const wasSet = await redis.set("lock", "value", "NX", "EX", 30);
141
if (wasSet) console.log("Lock acquired");
142
```
143

144
## Hash Commands
145

146
Operations on Redis hash data type (field-value maps).
147

148
```typescript { .api }
149
// Basic hash operations
150
hget(key: RedisKey, field: string): Promise<string | null>;
151
hset(key: RedisKey, field: string, value: RedisValue): Promise<number>;
152
hset(key: RedisKey, object: Record<string, RedisValue>): Promise<number>;
153
hdel(key: RedisKey, ...fields: string[]): Promise<number>;
154
hexists(key: RedisKey, field: string): Promise<number>;
155
hlen(key: RedisKey): Promise<number>;
156

157
// Multi-field operations
158
hmget(key: RedisKey, ...fields: string[]): Promise<Array<string | null>>;
159
hmset(key: RedisKey, ...args: Array<string | RedisValue>): Promise<"OK">;
160
hgetall(key: RedisKey): Promise<Record<string, string>>;
161
hkeys(key: RedisKey): Promise<string[]>;
162
hvals(key: RedisKey): Promise<string[]>;
163

164
// Numeric operations
165
hincrby(key: RedisKey, field: string, increment: number): Promise<number>;
166
hincrbyfloat(key: RedisKey, field: string, increment: number): Promise<string>;
167

168
// Conditional operations
169
hsetnx(key: RedisKey, field: string, value: RedisValue): Promise<number>;
170
```
171

172
**Usage Examples:**
173

174
```typescript
175
// Basic hash operations
176
await redis.hset("user:123", "name", "Alice");
177
await redis.hset("user:123", "email", "alice@example.com");
178
const name = await redis.hget("user:123", "name");
179

180
// Object-style setting
181
await redis.hset("user:456", {
182
  name: "Bob",
183
  email: "bob@example.com",
184
  age: "25"
185
});
186

187
// Get all hash data
188
const user = await redis.hgetall("user:123");
189
console.log(user); // { name: "Alice", email: "alice@example.com" }
190

191
// Multi-field operations  
192
const [name2, email] = await redis.hmget("user:123", "name", "email");
193

194
// Numeric operations
195
await redis.hincrby("stats:views", "page1", 1);
196
```
197

198
## List Commands
199

200
Operations on Redis list data type (linked lists).
201

202
```typescript { .api }
203
// Push operations
204
lpush(key: RedisKey, ...values: RedisValue[]): Promise<number>;
205
rpush(key: RedisKey, ...values: RedisValue[]): Promise<number>;
206
lpushx(key: RedisKey, ...values: RedisValue[]): Promise<number>;
207
rpushx(key: RedisKey, ...values: RedisValue[]): Promise<number>;
208

209
// Pop operations
210
lpop(key: RedisKey): Promise<string | null>;
211
rpop(key: RedisKey): Promise<string | null>;
212
blpop(...args: [...keys: RedisKey[], timeout: number]): Promise<[string, string] | null>;
213
brpop(...args: [...keys: RedisKey[], timeout: number]): Promise<[string, string] | null>;
214

215
// Range operations
216
lrange(key: RedisKey, start: number, stop: number): Promise<string[]>;
217
ltrim(key: RedisKey, start: number, stop: number): Promise<"OK">;
218

219
// Index operations
220
lindex(key: RedisKey, index: number): Promise<string | null>;
221
lset(key: RedisKey, index: number, value: RedisValue): Promise<"OK">;
222
linsert(key: RedisKey, direction: "BEFORE" | "AFTER", pivot: RedisValue, value: RedisValue): Promise<number>;
223

224
// List information
225
llen(key: RedisKey): Promise<number>;
226
lrem(key: RedisKey, count: number, value: RedisValue): Promise<number>;
227

228
// Blocking operations
229
brpoplpush(source: RedisKey, destination: RedisKey, timeout: number): Promise<string | null>;
230
```
231

232
**Usage Examples:**
233

234
```typescript
235
// Queue operations (FIFO)
236
await redis.lpush("queue", "job1", "job2", "job3");
237
const job = await redis.rpop("queue");
238

239
// Stack operations (LIFO)
240
await redis.lpush("stack", "item1", "item2");
241
const item = await redis.lpop("stack");
242

243
// Blocking operations
244
const result = await redis.blpop("queue", 10); // Wait 10 seconds
245
if (result) {
246
  const [queueName, value] = result;
247
  console.log(`Got ${value} from ${queueName}`);
248
}
249

250
// Range operations
251
await redis.rpush("messages", "msg1", "msg2", "msg3");
252
const messages = await redis.lrange("messages", 0, -1); // Get all
253
const recent = await redis.lrange("messages", -5, -1);  // Last 5
254
```
255

256
## Set Commands
257

258
Operations on Redis set data type (unordered collections).
259

260
```typescript { .api }
261
// Basic set operations
262
sadd(key: RedisKey, ...members: RedisValue[]): Promise<number>;
263
srem(key: RedisKey, ...members: RedisValue[]): Promise<number>;
264
smembers(key: RedisKey): Promise<string[]>;
265
scard(key: RedisKey): Promise<number>;
266
sismember(key: RedisKey, member: RedisValue): Promise<number>;
267

268
// Random operations
269
spop(key: RedisKey): Promise<string | null>;
270
spop(key: RedisKey, count: number): Promise<string[]>;
271
srandmember(key: RedisKey): Promise<string | null>;
272
srandmember(key: RedisKey, count: number): Promise<string[]>;
273

274
// Set operations
275
sinter(...keys: RedisKey[]): Promise<string[]>;
276
sunion(...keys: RedisKey[]): Promise<string[]>;
277
sdiff(...keys: RedisKey[]): Promise<string[]>;
278
sinterstore(destination: RedisKey, ...keys: RedisKey[]): Promise<number>;
279
sunionstore(destination: RedisKey, ...keys: RedisKey[]): Promise<number>;
280
sdiffstore(destination: RedisKey, ...keys: RedisKey[]): Promise<number>;
281

282
// Move operations
283
smove(source: RedisKey, destination: RedisKey, member: RedisValue): Promise<number>;
284
```
285

286
**Usage Examples:**
287

288
```typescript
289
// Basic set operations
290
await redis.sadd("tags", "redis", "database", "cache");
291
const tags = await redis.smembers("tags");
292
const hasRedis = await redis.sismember("tags", "redis");
293

294
// Set operations
295
await redis.sadd("user:123:tags", "redis", "javascript");
296
await redis.sadd("user:456:tags", "redis", "python");
297

298
// Find common tags
299
const commonTags = await redis.sinter("user:123:tags", "user:456:tags");
300
console.log(commonTags); // ["redis"]
301

302
// Random selection
303
const randomTag = await redis.srandmember("tags");
304
const randomTags = await redis.srandmember("tags", 2);
305
```
306

307
## Sorted Set Commands
308

309
Operations on Redis sorted set data type (scored collections).
310

311
```typescript { .api }
312
// Basic sorted set operations
313
zadd(key: RedisKey, ...args: Array<number | string>): Promise<number>;
314
zrem(key: RedisKey, ...members: RedisValue[]): Promise<number>;
315
zcard(key: RedisKey): Promise<number>;
316
zcount(key: RedisKey, min: string, max: string): Promise<number>;
317

318
// Range operations
319
zrange(key: RedisKey, start: number, stop: number): Promise<string[]>;
320
zrange(key: RedisKey, start: number, stop: number, withScores: "WITHSCORES"): Promise<string[]>;
321
zrevrange(key: RedisKey, start: number, stop: number): Promise<string[]>;
322
zrangebyscore(key: RedisKey, min: string, max: string): Promise<string[]>;
323
zrevrangebyscore(key: RedisKey, max: string, min: string): Promise<string[]>;
324

325
// Score operations
326
zscore(key: RedisKey, member: RedisValue): Promise<string | null>;
327
zincrby(key: RedisKey, increment: number, member: RedisValue): Promise<string>;
328
zrank(key: RedisKey, member: RedisValue): Promise<number | null>;
329
zrevrank(key: RedisKey, member: RedisValue): Promise<number | null>;
330

331
// Lexicographical operations
332
zrangebylex(key: RedisKey, min: string, max: string): Promise<string[]>;
333
zrevrangebylex(key: RedisKey, max: string, min: string): Promise<string[]>;
334
zlexcount(key: RedisKey, min: string, max: string): Promise<number>;
335
```
336

337
**Usage Examples:**
338

339
```typescript
340
// Leaderboard example
341
await redis.zadd("leaderboard", 100, "alice", 85, "bob", 120, "charlie");
342

343
// Get top players
344
const topPlayers = await redis.zrevrange("leaderboard", 0, 2, "WITHSCORES");
345
console.log(topPlayers); // ["charlie", "120", "alice", "100", "bob", "85"]
346

347
// Get player rank (0-based)
348
const aliceRank = await redis.zrevrank("leaderboard", "alice");
349
console.log(`Alice is rank ${aliceRank + 1}`);
350

351
// Update score
352
await redis.zincrby("leaderboard", 10, "bob");
353

354
// Range by score
355
const highScorers = await redis.zrangebyscore("leaderboard", "90", "+inf");
356
```
357

358
## Key Commands
359

360
Operations on Redis keys (metadata and lifecycle).
361

362
```typescript { .api }
363
// Key existence and information
364
exists(...keys: RedisKey[]): Promise<number>;
365
type(key: RedisKey): Promise<string>;
366
ttl(key: RedisKey): Promise<number>;
367
pttl(key: RedisKey): Promise<number>;
368

369
// Key expiration
370
expire(key: RedisKey, seconds: number): Promise<number>;
371
pexpire(key: RedisKey, milliseconds: number): Promise<number>;
372
expireat(key: RedisKey, timestamp: number): Promise<number>;
373
pexpireat(key: RedisKey, millisecondsTimestamp: number): Promise<number>;
374
persist(key: RedisKey): Promise<number>;
375

376
// Key operations
377
del(...keys: RedisKey[]): Promise<number>;
378
unlink(...keys: RedisKey[]): Promise<number>;
379
rename(key: RedisKey, newkey: RedisKey): Promise<"OK">;
380
renamenx(key: RedisKey, newkey: RedisKey): Promise<number>;
381
move(key: RedisKey, db: number): Promise<number>;
382

383
// Key scanning
384
keys(pattern: string): Promise<string[]>;
385
scan(cursor: string): Promise<[string, string[]]>;
386
scan(cursor: string, matchPattern: string): Promise<[string, string[]]>;
387
scan(cursor: string, countOption: "COUNT", count: number): Promise<[string, string[]]>;
388
```
389

390
**Usage Examples:**
391

392
```typescript
393
// Check key existence
394
const exists = await redis.exists("user:123");
395
if (exists) {
396
  const type = await redis.type("user:123");
397
  console.log(`Key exists and is of type: ${type}`);
398
}
399

400
// Set expiration
401
await redis.set("session:abc", "data");
402
await redis.expire("session:abc", 3600); // Expire in 1 hour
403

404
// Check TTL
405
const ttl = await redis.ttl("session:abc");
406
console.log(`Key expires in ${ttl} seconds`);
407

408
// Delete keys
409
await redis.del("old_key1", "old_key2");
410

411
// Pattern matching (use with caution on large datasets)
412
const userKeys = await redis.keys("user:*");
413

414
// Safer scanning for large datasets
415
let cursor = "0";
416
do {
417
  const [nextCursor, keys] = await redis.scan(cursor, "MATCH", "user:*", "COUNT", 100);
418
  cursor = nextCursor;
419
  console.log("Found keys:", keys);
420
} while (cursor !== "0");
421
```
422

423
## Types
424

425
```typescript { .api }
426
type RedisKey = string | Buffer;
427
type RedisValue = string | Buffer | number;
428
type Callback<T> = (err?: Error | null, result?: T) => void;
429
```