Supercharge Your Workflow with Redis: 12 Handy Commands Every Developer Needs to Know

Redis Developers Beware! 12 Game-Changing Commands You Can't Afford to Miss! Boost Your Performance and Revolutionize Your Data Management Today!

Table of Contents

Are you a developer looking to supercharge your workflow? Redis is a powerful open-source, in-memory data structure store that can help take your productivity and efficiency to the next level. In this blog post, I will cover everything from the setup and installation process to basic and advanced commands and syntax. I’ll also offer tips and tricks for optimizing your workflow with Redis so that you can make the most of this powerful tool. By the end of this article, you’ll have all the knowledge needed to use Redis effectively and supercharge your development workflow.


Redis is an incredibly powerful tool for developers, providing the ability to supercharge their workflow with fast and reliable performance. As an in-memory data structure store, developers use Redis for caching, analytics, real-time data synchronization, messaging queues, and more. With its open source nature and wide range of applications, Redis is quickly becoming a go-to solution for developers looking to optimize their workflow.

Regarding taking full advantage of Redis’ capabilities, there are 12 handy commands every developer should know. Basic commands like GET and SET have more advanced commands like SETNX and FLUSHDB. Knowing the syntax of these commands allows developers to do complex operations quickly and efficiently. Knowing these commands will not only help developers maximize their productivity but also make troubleshooting easier when something doesn’t go quite right.

Using Redis provides numerous benefits that can help any developer improve their workflow. It has a low latency rate, which makes it ideal for applications that need real-time responses. It also offers scalability solutions that allow developers to build large databases without compromising on performance or reliability. Plus, its fault tolerance provides high availability even if a node fails or goes offline temporarily.

Now let's get down to business.

What is Redis?

Redis is an open-source, in-memory data structure store used as a database. It is written in C and optimized for performance and scalability. Redis has become increasingly popular among developers due to its speed, ease of use, and ability to handle complex operations quickly and efficiently.

Redis supports many different data types such as strings, hashes, lists, sets, and more. It also uses the key/value format for its commands which makes it very easy to use and understand. By using this format, developers can store cached data such as web page content or session information with minimal effort. Additionally, Redis is designed with fault tolerance in mind so that if one server fails, it can be recovered from another without any major issues or downtime.

In addition to its speed and scalability benefits, Redis also provides various other advantages including transactions (which allow you to execute multiple commands at once), subscription (which allows you to subscribe to certain keys for updates), Lua scripting (which allows you to write scripts that run inside the Redis server), replication (for improving availability of data), disk persistence (to protect all stored information remains intact when the system shuts down), and more.

Setup and Installation

If you are using a package manager, such as apt-get or yum, you can install Redis from their respective repositories. Building from source is also an option for more experienced users. Additionally, if you plan on using Redis in the cloud, most popular providers offer out-of-the-box solutions that make installation quick and easy.


$ curl -fsSL | sudo gpg -dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
$ echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
$ sudo apt-get update
$ sudo apt-get install redis-stack-server


$ brew update
$ brew install redis
$ brew services start redis

By following the above steps outlined, developers will be able to set up and install Redis correctly so they can begin reaping the benefits of having an open source in-memory data structure store at their fingertips ready to supercharge their workflow! If you are on a different platform/OS than you can refer to the Redis official documentation for installation.

Basic Redis Commands and Syntax

Redis is an incredibly powerful database, but to get the most out of it you need to understand its basic syntax and commands. With this knowledge, developers can work faster and more productively. The fundamental building block of Redis is the key/value format. Keys are strings that can be used to store any type of data, such as strings, hashes, lists, sets, and sorted sets.


Before starting you need to login to the redis cli so that you can run various commands. You can do this by entering the following command:

# localhost
$ redis-cli

# for remote server
# syntax
$ redis-cli -h host -p port -a password
# example
$ redis-cli -h -p 6379 -a "mysecurepassword"


The SET command is used to set the value of a key, whereas the GET command is used to retrieve the value of a key. For example, the following commands can be used to set and get a key's value:

# syntax
redis> SET key value [NX | XX] [GET] [EX seconds | PX milliseconds |
EXAT unix-time-seconds | PXAT unix-time-milliseconds | KEEPTTL]

# example
redis> SET user_1 Jhon

# creating a record only if it does not already exist.
redis> SET user_5 "Jhon here" NX

# creating a record which will expire after 10min
redis> SET user_5 "Jhon here" EX 600

# syntax
redis> GET key

# example
redis> GET user_1


The KEYS command is used to list all the keys matching a pattern. For example, the following command can be used to list all the keys that start with "user":

# syntax
redis> KEYS pattern

# example
redis> KEYS user*
1) "user_1"

# to get all the keys
redis> KEYS *
1) "user_1"
2) "mykey"

# to get all keys which contains user
redis> KEYS *user*
1) "user_1"


The EXPIRE command is used to set a time-to-live (TTL) for a key. Once the TTL expires, the key and its associated value will be deleted. This will guarantee that stale data does not remain in memory and allows for better resource management. The following command can be used to set a TTL of 2 minutes for a key:

# syntax
redis> EXPIRE key seconds

# example
redis> EXPIRE user_1 120
(integer) 1


The EXISTS command is used to check if a key exists or not. For example:

# syntax
redis> EXISTS key [key …]

# example
redis> EXISTS user_1
(integer) 1


The DEL command is used to delete a key and its associated value. For example:

# syntax
redis> DEL key [key …]

# example
redis> DEL mykey
(integer) 1


The Redis TYPE command tells you the data type of the value in the key.

# syntax
redis> TYPE key

# example
redis> TYPE user_1

# key which do not exists
redis> TYPE user_2

Advanced Redis Commands and Syntax


The FLUSHDB command is used to delete all the keys and their associated values in the current database. For example:

# syntax

# example


The TTL command is used to check the remaining time-to-live of a key. For example:

# syntax
redis> TTL key

# example
redis> TTL user_1
(integer) 83


Redis RENAME command changes the name of a key. If the new key and old key names are the same, or the old key does not, then it returns an error. If the new key exists then it is overwritten.

# syntax
redis> RENAME key newkey

# example
redis> RENAME user_1 user_2

Tips and Tricks

When working with Redis, there are a few tips and tricks developers can use to optimize their workflow. Pipelining is one such method, which involves sending multiple commands at once instead of waiting for each command to complete before sending the next. This method is especially useful when performing large operations.

To explain this in more detail, let's consider an example where you want to get the value of several keys from Redis. Without pipelining, you would need to send a separate command for each key, like this:

redis> GET user_3
redis> GET user_4
redis> GET user_5
"Jhon here"

With pipelining, you can send all three commands in one package, like this

redis> MULTI
redis> GET user_3
redis> GET user_4
redis> GET user_5
redis> EXEC
1) "hello"
2) "world"
3) "Jhon here"

In this example, the MULTI command tells Redis that you're about to send a series of commands, and the EXEC command tells Redis to execute them all at once. By using pipelining, you can reduce the overhead of sending multiple commands individually and improve the performance of your Redis operations.

Another tip to keep in mind is to avoid using keys with a common prefix. Redis stores all data in RAM, and accessing keys with a common prefix will take up more memory than necessary. To remedy this issue, developers should consider using an external library that implements sharding or replication when storing data sets that exceed the available RAM.

Last, but not the least, it is sometimes required to delete specific keys having a specified pattern. There is a way to do that as well, without having to delete them manually one by one. Here is an example:

# delete all the key where name start with mykey_
$ redis-cli -h -p 6379 -scan -pattern mykey_* | xargs redis-cli -h -p 6379 del

Putting It All Together

Redis is an incredibly effective tool for optimizing workflow performance. As the go-to solution for caching, queuing, and distributed storage, its fast data retrieval, scalability, and robustness make it an ideal choice. Developers can leverage Redis' versatility in a variety of scenarios to supercharge their workflows.

For instance, storing frequently accessed data in Redis allows for reduced latency and improved performance since it supports multiple types of structured information such as JSON objects or lists of objects that need to be manipulated quickly.

Using tips and tricks when leveraging Redis' abilities can further increase their effectiveness. For example, pipelining commands lets you send multiple requests at once, and keeping keys with a common prefix organized while using less memory. All together, these techniques make sure you get the most out of this powerful tool.

I hope you found this article informative and helpful. If you did, please share it with your colleagues, like it, and leave a comment below. I would love to hear your thoughts and insights on Redis and these essential commands. I encourage you to keep exploring and experimenting with Redis to see what other amazing things you can do with it.

Raunak Gupta

Raunak Gupta

I'm Raunak Gupta, a seasoned software developer with over 9 years of experience in a wide range of programming languages, frameworks, and tools. I started my journey as a WordPress & CakePHP developer in 2014, diving deep into the world of OOPs, Request handling, and SEO. Along the way, I crafted numerous dazzling WooCommerce stores, tamed payment gateways, optimized for full filament functionality, and achieved ultra-low latency for lightning-fast load times. My expertise extends to BI tools, website builders, DevOps, and team leadership. I like to help upcoming developers, so I share my experience through this blog and by assisting fellow developers on Stack Overflow, where I've earned a stellar reputation with over 10k+ points of recognition.

Articles: 29

One comment

Leave a Reply

Your email address will not be published. Required fields are marked *