Quels types de données Redis supporte-t-il ?

Question

Accepted Answer

Redis supporte plusieurs **structures de données** comme valeurs — chaînes, listes, hashes, ensembles, ensembles triés, plus des types spécialisés (streams, bitmaps, HyperLogLog, géospatial). Choisir le bon type pour chaque cas d'usage est clé pour utiliser Redis efficacement.

## Types de données principaux

```bash
# STRING — the simplest (text, numbers, even binary up to 512MB)
SET key "value"
INCR counter            # atomic increment (strings can be counters)

# LIST — ordered list of strings (a linked list — fast push/pop at ends)
LPUSH mylist "a"        # push left
RPUSH mylist "b"        # push right
LRANGE mylist 0 -1      # get all → useful for queues, recent-items

# HASH — a map of field→value (like an object/record)
HSET user:1 name "Ann" age 30
HGET user:1 name        # => "Ann"  → great for storing objects

# SET — unordered unique strings
SADD tags "redis" "cache"
SISMEMBER tags "redis"  # membership test; SINTER/SUNION for set operations

# SORTED SET (ZSET) — unique members each with a SCORE, kept ordered by score
ZADD leaderboard 100 "Ann" 90 "Bob"
ZRANGE leaderboard 0 -1 WITHSCORES   # ranked → leaderboards, priority queues
```

## Types spécialisés

```text
STREAM      → an append-only log (like a message queue/event log with consumer groups)
BITMAP      → bit operations on strings (compact flags, e.g. daily active users)
HYPERLOGLOG → approximate unique counts using tiny memory (cardinality estimation)
GEOSPATIAL  → store/query locations (geo radius queries)
```

## Choisir le bon type

```text
String      → simple values, counters, cached serialized data
List        → queues, stacks, recent-items, activity feeds
Hash        → objects/records (store fields of an entity together)
Set         → unique collections, membership tests, tags, relationships
Sorted Set  → leaderboards, rankings, priority queues, time-ordered data
→ Picking the right structure makes operations efficient and natural.
```

## Pourquoi c'est important

Comprendre les types de données de Redis est fondamental pour utiliser Redis efficacement, car la puissance de Redis vient précisément de ses **structures de données riches** (et non seulement d'un simple stockage clé-valeur), donc les connaître et savoir quand utiliser chacun est une connaissance pratique essentielle.

Les **types principaux** conviennent chacun à des besoins différents : **chaînes** (valeurs simples et compteurs atomiques), **listes** (collections ordonnées pour les files d'attente, piles et feeds d'articles récents), **hashes** (stockage d'objets/enregistrements avec plusieurs champs ensemble — efficace pour les entités), **ensembles** (collections uniques pour les tests d'appartenance, les tags et les relations, avec des opérations sur ensembles comme l'intersection), et **ensembles triés** (membres classés par score — le choix naturel pour les classements, les palmares et les files de priorité).

Comprendre les **types spécialisés** — streams (logs append-only avec groupes de consommateurs, pour les files de messages et le sourcing d'événements), bitmaps (drapeaux compacts), HyperLogLog (comptes uniques approximatifs en minuscule mémoire), et géospatial (requêtes de localisation) — élargit ce que Redis peut faire efficacement.

Plus important encore, **choisir le bon type** pour chaque cas d'usage (un ensemble trié pour un classement, un hash pour un objet, une liste pour une file d'attente) est ce qui rend les opérations Redis efficaces et naturelles — utiliser la mauvaise structure conduit à des solutions maladroites et lentes.

Comme la valeur de Redis provient de ses structures de données et que les utiliser correctement est la compétence centrale du travail avec Redis, et comme le choix de la structure détermine directement si les opérations sont efficaces et le code est propre, comprendre les types de données Redis — les types principaux et spécialisés et quand utiliser chacun — est une connaissance essentielle, fréquemment appliquée pour quiconque utilise Redis, la base pour exploiter Redis efficacement au-delà du stockage trivial de clé-valeur.