Redis with Node.js (ioredis) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this Redis command sequence using ioredis?

Consider the following Node.js code using ioredis:

const Redis = require('ioredis');
const redis = new Redis();

await redis.set('count', 5);
const result = await redis.incr('count');
console.log(result);

What will be printed to the console?

Redis

const Redis = require('ioredis');
const redis = new Redis();

await redis.set('count', 5);
const result = await redis.incr('count');
console.log(result);

A 6

B Error: value is not an integer

C 1

D 5

💡 Hint

The INCR command increases the integer value stored at key by one.

The key 'count' is set to 5, then INCR increases it by 1, so the result is 6.

📝 Syntax

intermediate

Which option correctly sets a hash field using ioredis?

You want to set the field 'name' to 'Alice' in the hash stored at key 'user:1'. Which of the following code snippets is correct?

A await redis.hset('user:1', ['name', 'Alice']);

B await redis.hset('user:1', {name: 'Alice'});

C await redis.hset('user:1', 'name', 'Alice');

D await redis.hset('user:1', 'name:Alice');

💡 Hint

hset takes key, field, and value as separate arguments.

Option C uses the correct syntax: key, field, value. Option C passes an object which is invalid for hset in ioredis. Option C passes an array which is invalid. Option C passes a single string combining field and value which is invalid.

❓ optimization

advanced

Which approach is best to retrieve multiple keys efficiently with ioredis?

You need to get the values of keys 'key1', 'key2', and 'key3'. Which option is the most efficient?

A await redis.pipeline().get('key1').get('key2').get('key3').exec();

B await redis.mget('key1', 'key2', 'key3');

C await Promise.all([redis.get('key1'), redis.get('key2'), redis.get('key3')]);

D await redis.get('key1'); await redis.get('key2'); await redis.get('key3');

💡 Hint

Pipelining batches commands to reduce round-trip time.

Option B uses mget which is the most efficient for retrieving multiple keys in one command. Option B uses pipelining which batches commands but mget is more efficient for multiple key retrieval. Option B sends commands sequentially, slowest. Option B sends commands in parallel but still multiple round-trips.

🔧 Debug

advanced

Why does this ioredis code throw an error?

Given this code:

const Redis = require('ioredis');
const redis = new Redis();

redis.set('foo', 'bar');
const value = await redis.get('foo');
console.log(value);

It throws: SyntaxError: await is only valid in async function. Why?

Redis

const Redis = require('ioredis');
const redis = new Redis();

redis.set('foo', 'bar');
const value = await redis.get('foo');
console.log(value);

A Because redis.set is missing await.

B Because redis.get returns undefined.

C Because Redis client is not connected.

D Because await is used outside an async function.

💡 Hint

await can only be used inside async functions.

The error is due to using await at the top level outside an async function. Wrapping code in async function or using .then() fixes it.

🧠 Conceptual

expert

What happens if you call redis.del('key') on a non-existing key?

Using ioredis, you run:

const result = await redis.del('nonexistent');
console.log(result);

What will be printed?

Redis

const result = await redis.del('nonexistent');
console.log(result);

A 0

B 1

C null

D Error: key does not exist

💡 Hint

DEL returns the number of keys removed.

If the key does not exist, DEL returns 0 indicating no keys were deleted.

Practice

1. What does the set method do in ioredis when used with Node.js?

easy

A. Stores a value with a specified key in Redis

B. Retrieves a value from Redis by key

C. Deletes a key-value pair from Redis

D. Connects to the Redis server

Solution

1. Step 1: Understand the purpose of set in Redis

   The set method is used to store data by assigning a value to a key in Redis.

2. Step 2: Differentiate from other methods

   get retrieves data, del deletes data, and connection is handled separately.

3. Final Answer:

   Stores a value with a specified key in Redis -> Option A

4. Quick Check:

   set stores data [OK]

Hint: Remember: set = save data, get = read data [OK]

Common Mistakes:

• Confusing set with get
• Thinking set deletes data
• Assuming set connects to Redis

2. Which of the following is the correct syntax to get a value for key 'name' using ioredis with async/await?

easy

A. const value = redis.get('name');

B. const value = redis.getSync('name');

C. const value = await redis.set('name');

D. const value = await redis.get('name');

Solution

1. Step 1: Recognize async nature of ioredis commands

   ioredis commands return promises, so await is needed to get the resolved value.

2. Step 2: Identify correct method and usage

   get retrieves the value; set stores data; getSync does not exist.

3. Final Answer:

   const value = await redis.get('name'); -> Option D

4. Quick Check:

   Use await with get [OK]

Hint: Always use await with async Redis calls [OK]

Common Mistakes:

• Omitting await causing unresolved promises
• Using non-existent getSync method
• Using set instead of get to read data

3. What will be the output of the following code snippet?

const Redis = require('ioredis');
const redis = new Redis();

async function test() {
  await redis.set('color', 'blue');
  const val = await redis.get('color');
  console.log(val);
}
test();

medium

A. null

B. undefined

C. blue

D. SyntaxError

Solution

1. Step 1: Analyze the set command

   The code stores the string 'blue' with key 'color' in Redis asynchronously.

2. Step 2: Analyze the get command and console output

   The code retrieves the value for 'color' and logs it, which should be 'blue'.

3. Final Answer:

   blue -> Option C

4. Quick Check:

   set then get returns stored value [OK]

Hint: set then get returns stored value [OK]

Common Mistakes:

• Forgetting await causing undefined output
• Assuming get returns null if key exists
• Syntax errors from missing async

4. Identify the error in the following code snippet using ioredis:

const Redis = require('ioredis');
const redis = new Redis();

function getValue() {
  const value = redis.get('key');
  console.log(value);
}
getValue();

medium

A. Missing await causing value to be a Promise

B. Incorrect Redis import statement

C. Redis client not connected

D. Using console.log inside function is invalid

Solution

1. Step 1: Understand async nature of redis.get

   The get method returns a Promise, so without await, value is a Promise object.

2. Step 2: Identify missing await and its effect

   Logging value prints a Promise, not the actual stored value.

3. Final Answer:

   Missing await causing value to be a Promise -> Option A

4. Quick Check:

   Always await async Redis calls [OK]

Hint: Always await redis.get to get actual value [OK]

Common Mistakes:

• Ignoring async/await causing Promise logs
• Thinking Redis import is wrong
• Assuming console.log inside function is invalid

5. You want to store a user's session data as a JSON object in Redis using ioredis. Which approach correctly stores and retrieves the session data?

hard

A. Store session as multiple keys like set('session:user', user) and set('session:data', data)

B. Use set('session', JSON.stringify(session)) to store and JSON.parse(await get('session')) to retrieve

C. Use hmset('session', session) without stringifying and hgetall('session') to retrieve

D. Use set('session', session) directly and await get('session') to retrieve

Solution

1. Step 1: Understand Redis stores strings

   Redis stores strings, so objects must be converted to strings before storing.

2. Step 2: Use JSON methods to store and retrieve objects

   Use JSON.stringify to convert object to string before storing, and JSON.parse to convert back after retrieving.

3. Final Answer:

   Use set('session', JSON.stringify(session)) to store and JSON.parse(await get('session')) to retrieve -> Option B

4. Quick Check:

   Stringify before set, parse after get [OK]

Hint: Stringify objects before set, parse after get [OK]

Common Mistakes:

• Trying to store objects directly without stringifying
• Using hash commands without proper structure
• Splitting session into multiple keys unnecessarily