Ultimate Redis Cheatsheet
Tags: redis, database
Published: 2023-07-27 11:44:02

---
title: Ultimate Redis Cheatsheet
published: true
description: This post is a collection of the most common commands used to manage Redis instances.
tags: redis, databases
canonical_url: https://idiomaticprogrammers.com/post/ultimate-redis-cheatsheet/
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/icni0cmjw6z9dfv6w4mr.png
---


## What is Redis?

Redis, which stands for Remote Dictionary Server, is an open-source, in-memory data structure store that serves as a highly efficient and versatile database solution. Developed by Salvatore Sanfilippo, Redis is designed to offer lightning-fast data access and retrieval by keeping all the data in memory rather than on disk, ensuring remarkable performance and responsiveness.

One of the key features that sets Redis apart is its support for various data structures, including strings, lists, sets, sorted sets, and hashes. This versatility enables Redis to serve multiple purposes, such as acting as a key-value store, a message broker, or a caching layer.

Redis utilizes an in-memory approach, making it exceptionally fast for read and write operations. With its optimized data structures and efficient algorithms, Redis can process data in sub-millisecond response times, making it an ideal choice for real-time applications and use cases that require high-performance data manipulation.

Furthermore, Redis offers persistence options, allowing users to store their data on disk periodically or whenever specific conditions are met. This feature ensures data durability and makes Redis suitable for applications that require both speed and data persistence.

In addition to its exceptional performance, Redis provides advanced features like pub/sub messaging, transactions, and Lua scripting, which empower developers to build complex applications and systems with ease.

Redis has become immensely popular due to its simplicity, versatility, and extensive support for multiple programming languages. It offers client libraries for various languages, making it accessible and easy to integrate into different software stacks.

Whether you need to cache frequently accessed data, build real-time applications, implement a messaging system, or store and process complex data structures, Redis provides a robust and efficient solution that continues to be widely adopted across industries.

In conclusion, Redis is a powerful and flexible database solution that excels in performance, versatility, and ease of use. Its in-memory nature, support for various data structures, and extensive feature set make it a go-to choice for developers looking to build high-performance applications and systems.

## How Redis is different from other Databases?

Redis differs from other databases in several key aspects:

1. **In-Memory Data Storage**: Redis primarily stores data in memory, allowing for extremely fast read and write operations. This design choice sets Redis apart from traditional disk-based databases that incur disk I/O overhead. By keeping data in memory, Redis can achieve high throughput and low latency, making it well-suited for applications that require real-time data processing and high-performance caching.
2. **Data Structures**: Redis supports a wide range of data structures, including strings, lists, sets, hashes, and sorted sets. This flexibility allows developers to model complex data scenarios efficiently. Unlike many other databases that offer a fixed schema, Redis provides dynamic and versatile data structures that can be manipulated and combined to suit specific application needs.
3. **Built-in Caching Mechanisms**: Redis has native support for caching, making it an excellent choice for scenarios that require frequent access to frequently accessed data. With features like key expiration and eviction policies, Redis can efficiently manage cache storage and ensure that the most relevant data remains readily available.
4. **Pub/Sub Messaging**: Redis includes built-in publish/subscribe messaging capabilities. This feature allows applications to implement real-time messaging and event-driven architectures. Publishers can send messages to specific channels, and subscribers receive messages from those channels in real-time. This makes Redis a suitable choice for building chat systems, real-time analytics, and other applications that require event-based communication.
5. **Lua Scripting**: Redis supports Lua scripting, which enables developers to execute server-side scripts directly within the database. This allows for complex operations and transactional logic to be performed within Redis, reducing the need for round-trips between the application and the database. Lua scripting enhances Redis's flexibility and extensibility by enabling custom behaviour and complex data manipulations.
6. **Replication and Persistence**: Redis provides built-in replication mechanisms for creating multiple copies of the database. This replication ensures high availability and fault tolerance by propagating changes from a master node to one or more slave nodes. Redis also offers persistence options through snapshotting and append-only file (AOF) logging, allowing data to be saved to disk for recovery in the event of a system failure.
7. **Simplicity and Performance**: Redis is known for its simplicity and performance. It offers a straightforward set of commands that are easy to understand and use. The focus on in-memory storage and the absence of complex query languages or indexing mechanisms simplify the database's design and contribute to its exceptional performance.

Overall, Redis stands out among other databases due to its in-memory storage, versatile data structures, caching capabilities, pub/sub messaging, Lua scripting, replication, and performance-oriented design. These features make Redis a popular choice for applications that require speed, flexibility, and real-time data processing.

## Installing Redis and Redis CLI

Here are the steps to install Redis on Linux, macOS, and Windows:

**Linux:**

1. Open a terminal window.
2. Update the package manager:
    
    ```bash
    sudo apt update
    ```
    
3. Install Redis:
    
    ```bash
    sudo apt install redis-server
    ```
    
4. Start the Redis service:
    
    ```bash
    sudo systemctl start redis-server
    ```
    
5. To access the Redis command-line interface (redis-cli):
    
    ```bash
    redis-cli
    ```
    

**macOS:**

1. Open a terminal window.
2. Install Homebrew (if not already installed):
    
    ```bash
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    ```
    
3. Install Redis using Homebrew:
    
    ```bash
    brew install redis
    ```
    
4. Start the Redis service:
    
    ```bash
    brew services start redis
    ```
    
5. To access the Redis command-line interface (redis-cli):
    
    ```bash
    redis-cli
    ```
    

**Windows:**

1. Download the latest Redis for Windows from the Microsoft Open Tech GitHub repository: **[https://github.com/microsoftarchive/redis/releases](https://github.com/microsoftarchive/redis/releases)**
2. Extract the downloaded archive to a directory of your choice, e.g., **`C:\Redis`**.
3. Open a Command Prompt window.
4. Navigate to the Redis installation directory:
    
    ```bash
    cd C:\Redis
    ```
    
5. Start the Redis server:
    
    ```bash
    redis-server.exe
    ```
    
6. Open another Command Prompt window to access the Redis command-line interface (redis-cli):
    
    ```bash
    cd C:\Redis
    redis-cli.exe
    ```
    

Please note that for Linux and macOS, the installation steps assume the usage of package managers like **`apt`** and Homebrew, respectively. If you are using a different package manager or distribution, you may need to adjust the installation commands accordingly.

## Commands

### SET manipulation

1. **SET**
    - Command: **`SET`**
    - Syntax: **`SET key value`**
    - Usage: **`SET myset "Hello Redis"`**
    - Description: Sets the value of a key with the provided string value. If the key already exists, it overwrites the existing value. This command is also used to create a new key-value pair if the key doesn't exist.

2. **GET**
    - Command: **`GET`**
    - Syntax: **`GET key`**
    - Usage: **`GET myset`**
    - Description: Retrieves the value associated with the specified key. If the key exists, the command returns the value; otherwise, it returns **`nil`**.

3. **SADD**
    - Command: **`SADD`**
    - Syntax: **`SADD key member [member ...]`**
    - Usage: **`SADD myset "value1" "value2"`**
    - Description: Adds one or more members to a set. If the members already exist, they are ignored. If the key doesn't exist, a new set is created with the specified members.

4. **SMEMBERS**
    - Command: **`SMEMBERS`**
    - Syntax: **`SMEMBERS key`**
    - Usage: **`SMEMBERS myset`**
    - Description: Returns all the members of a set. If the key doesn't exist, an empty set is returned.

5. **SISMEMBER**
    - Command: **`SISMEMBER`**
    - Syntax: **`SISMEMBER key member`**
    - Usage: **`SISMEMBER myset "value1"`**
    - Description: Checks if a member exists in a set. Returns **`1`** if the member is present; otherwise, returns **`0`**.

6. **SREM**
    - Command: **`SREM`**
    - Syntax: **`SREM key member [member ...]`**
    - Usage: **`SREM myset "value1" "value2"`**
    - Description: Removes one or more members from a set. If the members don't exist, they are ignored. If the key becomes empty after removing members, the key is also removed.

7. **SCARD**
    - Command: **`SCARD`**
    - Syntax: **`SCARD key`**
    - Usage: **`SCARD myset`**
    - Description: Returns the cardinality (number of members) of a set. If the key doesn't exist, **`0`** is returned.

8. **SINTER**
    - Command: **`SINTER`**
    - Syntax: **`SINTER key [key ...]`**
    - Usage: **`SINTER myset1 myset2`**
    - Description: Returns the intersection of multiple sets. Only the members that exist in all the specified sets are included in the result set.

9. **SUNION**
    - Command: **`SUNION`**
    - Syntax: **`SUNION key [key ...]`**
    - Usage: **`SUNION myset1 myset2`**
    - Description: Returns the union of multiple sets. All the members from the specified sets are included in the result set.

10. **SDIFF**
    - Command: **`SDIFF`**
    - Syntax: **`SDIFF key [key ...]`**
    - Usage: **`SDIFF myset1 myset2`**
    - Description: Returns the difference between two sets. The members that exist in the first set but not in any other specified sets are included in the result set.

### **Sorted Sets manipulation**

1. **ZADD**
    - Command: **`ZADD`**
    - Syntax: **`ZADD key [NX|XX] [CH] [INCR] score member [score member ...]`**
    - Usage: **`ZADD mysortedset 1 "value1" 2 "value2"`**
    - Description: Adds one or more members with scores to a sorted set. If a member already exists, its score is updated. Additional options like **`NX`** (only add new elements), **`XX`** (only update existing elements), **`CH`** (return the number of changed elements), and **`INCR`** (increment the score of existing member) can be specified.

2. **ZSCORE**
    - Command: **`ZSCORE`**
    - Syntax: **`ZSCORE key member`**
    - Usage: **`ZSCORE mysortedset "value1"`**
    - Description: Returns the score of a member in a sorted set. If the member doesn't exist, **`nil`** is returned.

3. **ZRANGE**
    - Command: **`ZRANGE`**
    - Syntax: **`ZRANGE key start stop [WITHSCORES]`**
    - Usage: **`ZRANGE mysortedset 0 -1`**
    - Description: Returns a range of members from a sorted set based on their position. The **`start`** and **`stop`** arguments specify the inclusive range of positions. The optional **`WITHSCORES`** flag includes the scores in the result.

4. **ZREVRANGE**
    - Command: **`ZREVRANGE`**
    - Syntax: **`ZREVRANGE key start stop [WITHSCORES]`**
    - Usage: **`ZREVRANGE mysortedset 0 -1 WITHSCORES`**
    - Description: Returns a range of members from a sorted set in reverse order based on their position. The **`start`** and **`stop`** arguments specify the inclusive range of positions. The optional **`WITHSCORES`** flag includes the scores in the result.

5. **ZREM**
    - Command: **`ZREM`**
    - Syntax: **`ZREM key member [member ...]`**
    - Usage: **`ZREM mysortedset "value1" "value2"`**
    - Description: Removes one or more members from a sorted set. If a member doesn't exist, it is ignored. If the key becomes empty after removing members, the key is also removed.

6. **ZCARD**
    - Command: **`ZCARD`**
    - Syntax: **`ZCARD key`**
    - Usage: **`ZCARD mysortedset`**
    - Description: Returns the cardinality (number of members) of a sorted set. If the key doesn't exist, **`0`** is returned.

7. **ZCOUNT**
    - Command: **`ZCOUNT`**
    - Syntax: **`ZCOUNT key min max`**
    - Usage: **`ZCOUNT mysortedset 1 10`**
    - Description: Returns the count of members in a sorted set within the specified score range (**`min`** and **`max`** inclusive).

8. **ZRANK**
    - Command: **`ZRANK`**
    - Syntax: **`ZRANK key member`**
    - Usage: **`ZRANK mysortedset "value1"`**
    - Description: Returns the position (rank) of a member in a sorted set when sorted in ascending order. The lowest rank is **`0`**. If the member doesn't exist, **`nil`** is returned.

9. **ZREVRANK**
    - Command: **`ZREVRANK`**
    - Syntax: **`ZREVRANK key member`**
    - Usage: **`ZREVRANK mysortedset "value1"`**
    - Description: Returns the position (rank) of a member in a sorted set when sorted in descending order. The highest rank is **`0`**. If the member doesn't exist, **`nil`** is returned.
    
10. **ZINCRBY**
    - Command: **`ZINCRBY`**
    - Syntax: **`ZINCRBY key increment member`**
    - Usage: **`ZINCRBY mysortedset 5 "value1"`**
    - Description: Increments the score of a member in a sorted set by the specified increment. If the member doesn't exist, it is added with the initial score as the increment value.

### String, Number and Bit Manipulation

1. **APPEND**
    - Command: **`APPEND`**
    - Syntax: **`APPEND key value`**
    - Usage: **`APPEND mykey "world"`**
    - Description: Appends the specified value to the string value already stored at the key. If the key doesn't exist, a new key is created with the specified value.

2. **BITCOUNT**
    - Command: **`BITCOUNT`**
    - Syntax: **`BITCOUNT key [start end]`**
    - Usage: **`BITCOUNT mykey`**
    - Description: Counts the number of set bits (1s) in a string value. Optionally, a range can be specified to count the bits within that range.

3. **BITOP**
    - Command: **`BITOP`**
    - Syntax: **`BITOP operation destkey key [key ...]`**
    - Usage: **`BITOP AND destkey key1 key2`**
    - Description: Performs a bitwise operation (AND, OR, XOR, NOT) between multiple keys and stores the result in the destination key.
4. **BITPOS**
    - Command: **`BITPOS`**
    - Syntax: **`BITPOS key bit [start] [end]`**
    - Usage: **`BITPOS mykey 1 0 10`**
    - Description: Finds the position of the first set bit (1) or clear bit (0) in a string value. Optionally, a range can be specified to search for the bit within that range.

5. **DECR**
    - Command: **`DECR`**
    - Syntax: **`DECR key`**
    - Usage: **`DECR mykey`**
    - Description: Decrements the value of the key by 1. If the key doesn't exist, it is initialized with the value of 0 before decrementing.

6. **DECRBY**
    - Command: **`DECRBY`**
    - Syntax: **`DECRBY key decrement`**
    - Usage: **`DECRBY mykey 5`**
    - Description: Decrements the value of the key by the specified decrement. If the key doesn't exist, it is initialized with the value of 0 before decrementing.

7. **GET**
    - Command: **`GET`**
    - Syntax: **`GET key`**
    - Usage: **`GET mykey`**
    - Description: Retrieves the value associated with the specified key. If the key exists, the command returns the value; otherwise, it returns **`nil`**.

8. **GETBIT**
    - Command: **`GETBIT`**
    - Syntax: **`GETBIT key offset`**
    - Usage: **`GETBIT mykey 5`**
    - Description: Returns the bit value at the specified offset in a string value. The offset is zero-based.

9. **GETRANGE**
    - Command: **`GETRANGE`**
    - Syntax: **`GETRANGE key start end`**
    - Usage: **`GETRANGE mykey 0 3`**
    - Description: Retrieves a substring of the string value stored at the key, starting from the specified start index to the end index (inclusive).

10. **GETSET**
    - Command: **`GETSET`**
    - Syntax: **`GETSET key value`**
    - Usage: **`GETSET mykey "newvalue"`**
    - Description: Sets the value of the key with the provided string value and returns the old value. If the key doesn't exist, it is initialized with the specified value.

11. **INCR**
    - Command: **`INCR`**
    - Syntax: **`INCR key`**
    - Usage: **`INCR mykey`**
    - Description: Increments the value of the key by 1. If the key doesn't exist, it is initialized with the value of 0 before incrementing.

12. **INCRBY**
    - Command: **`INCRBY`**
    - Syntax: **`INCRBY key increment`**
    - Usage: **`INCRBY mykey 5`**
    - Description: Increments the value of the key by the specified increment. If the key doesn't exist, it is initialized with the value of 0 before incrementing.
    
13. **INCRBYFLOAT**
    - Command: **`INCRBYFLOAT`**
    - Syntax: **`INCRBYFLOAT key increment`**
    - Usage: **`INCRBYFLOAT mykey 2.5`**
    - Description: Increments the value of the key by the specified float increment. If the key doesn't exist, it is initialized with the value of 0 before incrementing.

14. **MGET**
    - Command: **`MGET`**
    - Syntax: **`MGET key [key ...]`**
    - Usage: **`MGET key1 key2 key3`**
    - Description: Retrieves the values associated with multiple keys. It returns an array of values corresponding to the provided keys.

15. **MSET**
    - Command: **`MSET`**
    - Syntax: **`MSET key value [key value ...]`**
    - Usage: **`MSET key1 "value1" key2 "value2"`**
    - Description: Sets multiple keys to their respective values. It allows setting multiple key-value pairs in a single command.

16. **MSETNX**
    - Command: **`MSETNX`**
    - Syntax: **`MSETNX key value [key value ...]`**
    - Usage: **`MSETNX key1 "value1" key2 "value2"`**
    - Description: Sets multiple keys to their respective values, only if none of the keys already exist. It allows atomic setting of multiple keys.

17. **PSETEX**
    - Command: **`PSETEX`**
    - Syntax: **`PSETEX key milliseconds value`**
    - Usage: **`PSETEX mykey 1000 "Hello"`**
    - Description: Sets the value of the key with the provided string value and a specified expiration time in milliseconds.

18. **SET**
    - Command: **`SET`**
    - Syntax: **`SET key value [EX seconds|PX milliseconds] [NX|XX]`**
    - Usage: **`SET mykey "Hello" EX 60 NX`**
    - Description: Sets the value of a key with the provided string value. Additional options like expiration time, conditional set (**`NX`** - only if the key doesn't exist, **`XX`** - only if the key exists) can be specified.

19. **SETBIT**
    - Command: **`SETBIT`**
    - Syntax: **`SETBIT key offset value`**
    - Usage: **`SETBIT mykey 5 1`**
    - Description: Sets the bit at the specified offset in a string value to either 0 or 1.

20. **SETEX**
    - Command: **`SETEX`**
    - Syntax: **`SETEX key seconds value`**
    - Usage: **`SETEX mykey 60 "Hello"`**
    - Description: Sets the value of the key with the provided string value and a specified expiration time in seconds.

21. **SETNX**
    - Command: **`SETNX`**
    - Syntax: **`SETNX key value`**
    - Usage: **`SETNX mykey "Hello"`**
    - Description: Sets the value of a key with the provided string value, only if the key doesn't exist.

22. **SETRANGE**
    - Command: **`SETRANGE`**
    - Syntax: **`SETRANGE key offset value`**
    - Usage: **`SETRANGE mykey 5 "Redis"`**
    - Description: Overwrites a substring of the string value stored at the key, starting from the specified offset with the provided value.
    
23. **STRLEN**
    - Command: **`STRLEN`**
    - Syntax: **`STRLEN key`**
    - Usage: **`STRLEN mykey`**
    - Description: Returns length

## Conclusion

In conclusion, we have discussed Redis, a popular in-memory data structure store, and explored its unique characteristics that set it apart from other databases. Redis offers exceptional performance and versatility, making it suitable for various use cases, such as caching, real-time analytics, messaging systems, and more.

We have also covered the installation process of Redis on Linux, macOS, and Windows, including how to access the Redis command-line interface (redis-cli) for interacting with the database.

Furthermore, we have delved into the major commands related to set manipulation, providing syntax, usage examples, and descriptions for each command. These commands enable users to perform various operations like adding, retrieving, modifying, and removing elements from sets in Redis.

Additionally, we have explored the major commands related to sorted set manipulation, including operations such as adding members with scores, retrieving ranges, finding positions, incrementing scores, and more. Sorted sets in Redis provide an ordered collection of unique elements, allowing efficient operations based on both element values and scores.

Redis commands like APPEND, GET, SET, INCR, and many others offer powerful functionality for string manipulation, bit operations, and key-value management.

Redis, with its versatility, performance, and rich set of commands, continues to be a preferred choice for developers and architects when it comes to handling data-intensive applications and solving various data storage and retrieval challenges.