Redis: The Complete Developer's Guide

Explore how Redis handles basic commands, using set and get to store and retrieve strings, and learn how data types like strings, lists, hashes, and sets differ.

Explore Redis string commands, learn to navigate official docs, and distinguish command variants like get, getdel, getex, set, and setnx, plus optional arguments and syntax.

Learn how the set command operates in Redis, storing simple string values. Analyze options for expiration, nx/xx conditions, and the get flag with practical color key examples.

Explore how Redis expiration options automatically delete data after a set time to support caching, memory management, and fast API responses with an example of headlines.

Learn how to use redis set, set with ex, set nx, and mset to assign and expire keys, including conditional updates and multi-key operations.

Learn Redis key retrieval with get for a single key and mget for multiple keys, retrieving color and model values like red and Toyota.

Explore del, get range, and set range commands in Redis, deleting keys, extracting substrings by index, and updating strings to demonstrate how these operations combine to power a data-driven system.

Discover how redis commands like get range and set range enable ultra-fast data access by encoding repetitive values into compact strings. Learn efficient fetch, update, and bulk insert patterns.

Learn how Redis stores numbers as strings and uses number commands like increment, decrease, and increase by, including float variants, while parsing results and avoiding misapplying to string keys.

Explains why the increment command exists by showing how Redis atomically reads, increments, and saves a value, and how concurrent requests can cause missed updates.

Learn to use the Arbor notebook to document commands, compare it with red ac alai, and manage completed notebooks via Object Cloud uploads and JSON exports.

Download the string exercises JSON, upload the file to the object cloud, complete three simple string exercises, then review the solutions together in the next video.

Practice using Redis commands to store values with set and get, conditionally set with NX, and implement key expiration with 3 seconds, through practical exercise solutions.

Learn to build a Redis-backed back end for an e-commerce app using TypeScript, covering setup, Node.js, Redis connection, and writing queries.

Explore Redis client libraries across languages, connect with Node Redis in a TypeScript project, and learn how get and set map to language-specific functions guided by official documentation.

Implement a Redis-based caching layer to speed up server-side rendering by storing and reusing rendered HTML for each page, reducing repeated HTML generation.

Apply Redis design methodology by caching rendered pages with set operations, starting from the queries we need to answer, and plan for page size, expiration, and key naming.

Define unique Redis keys by using a colon to separate data type and identifier, and use a pound symbol for unique ids to ease search, e.g., page: privacy, page: about.

Implement page caching with Redis by caching select routes such as about, privacy, sign in, and sign up, using get cache page and set cache page.

Create a small key-generation function to build page cache keys, replacing manual string concatenation to avoid typos and streamline access to routes like sign in, sign up, and privacy page.

Learn how hashes store nested key-value pairs under a single key, like a json object, perfect for storing record information such as users or posts; avoid deep nesting and arrays.

Learn how to store and retrieve hashes in Redis using hset, hget, and hgetall, managing key-value pairs and understanding raw client responses.

Discover quick Redis hash operations: check for key existence with h exists, delete an entire hash with del, and remove a specific field like age with h del.

Use h anchor by and h anchor by float to increment hash fields, with auto-creation and negative values; explore h string length, h keys, and h values.

Apply hset and hgetall to store and retrieve a car hash in Redis, with color and year fields, and observe surprising, unpredictable behavior to investigate further.

Analyze how Redis hset and hgetall convert objects with null or undefined fields to strings, and why toString on null triggers errors.

Explore how hgetall reads hashes in Redis and why a missing key returns an empty object instead of null, then check the object's length to return a 404.

Explore high-level design for an auction marketplace app and learn how to model data in Redis with hashes, including user auth, items, bids, views, and pagination.

Design for Redis starts with the required queries, not upfront data models, to build a fast, query‑driven data design that supports search, sorts, authentication, bids, views, and likes.

Learn when to use hash data structures in Redis for items, users, and sessions with multiple attributes and single-item pages, and when not to for likes, views, and time-series bids.

Create a new user by generating a unique id and storing a username and password in a Redis hash using a generated key. Return the new user id.

Discover how serialize and deserialize patterns prepare data for Redis by saving a company object as a hash, converting numbers and dates, and reconstructing values on read.

Create a serialize function in the users file that accepts a user and returns a plain object with the save-ready properties, then replace the set operation with this serialize function.

Learn to fetch a user by id from Redis using hgetall, and deserialize the resulting hash into an object with id, username, and password for authentication.

Explore how Redis sessions authenticate users by creating a session token, storing session data (user ID and username) under the token, and validating requests with the token.

Implement get session and save session methods using Redis hashes and hgetall, using the session id as the key, and serialize the result into a session object while checking for sign-in status.

Implement a serialize function to store a session in Redis by excluding the id and persisting the user id and username in a Redis hash.

Master storing and retrieving items in Redis by implementing create item and get items functions, and serialize date objects as Unix time milliseconds for precise auction timing.

Serialize an item into a Redis-friendly object by converting created at and ending at to millisecond values, generate a unique id with genID, and store it under items:${id}.

Fetch a single item from Redis using the items key, handle missing data by returning null, then serialize the item and convert millisecond timestamps and string values into proper types.

Learn to fetch multiple car records from Redis with pipelines, batching commands for many IDs in one batch, and handle the resulting list in JavaScript and TypeScript.

Learn to run multiple redis commands concurrently using a node pipeline pattern with Promise.all, building three hashes and batching hgetall and set operations in one request.

Execute a pipeline by mapping IDs to individual hgetall commands, run them with Promise.all, then serialize nonempty results aligned to their corresponding IDs.

Explore Redis sets, a unique collection of strings with no duplicates, and learn s add and s members commands through hands-on tests in a notebook, plus practical use cases.

Explore Redis set operations by forming unions of multiple sets to produce a unique new set, and learn s inter, s inter store, and s inter card via color examples.

Explore the intersection of sets by identifying elements that exist in all sets, using colors as examples and a quick code demonstration with the se inter command.

Explore set difference by identifying elements in the first set that do not appear in any other sets, illustrated with orange and a colors example.

Explore how Redis set operations union, difference, and intersection store results in a new key using store variant. Retrieve the intersection of colors one, two, and three with s members.

Use s is member to check single value in a set, returning 1 or 0. Use s m is member for multiple values, returning an array of 1s and 0s.

Discover how to measure a set's size with scard, remove elements with srem, and check membership with sismember, then scan large sets efficiently with sscan to walk data in pages.

Explore common use cases of sets in Redis, including enforcing unique usernames, modeling user likes with per-user sets, and computing intersections to find shared items.

Implement a unique username system in an e-commerce app by checking a set of usernames during sign up, enforcing uniqueness, and updating the set after account creation.

Add a per-user like system by storing liked item IDs in Redis sets keyed as users:likes:<userID>, enabling like and unlike actions and listing a user’s liked items.

Implement persistent like state by checking each user's like set to keep the button green on refresh, and cache per-item like counts on the item's hash for fast reads.

Learn to update like quantities in Redis by handling rapid duplicate like requests with the sadd return values, and adjust likes via hincrby for like and unlike.

Fetch all item IDs from the user's liked sets using s members, then retrieve item hashes with those IDs by reusing the get items function through a Redis pipeline.

Implement a common like items feature by intersecting two users' like sets to retrieve shared item IDs, then fetch and display those items.