Wat zijn gesorteerde verzamelingen en hoe worden ze gebruikt?

Question

Accepted Answer

**Gesorteerde verzamelingen** (ZSETs) zijn een van de meest krachtige structuren van Redis — verzamelingen van **unieke leden elk met een numerieke score**, automatisch **gesorteerd op score**. Ze zijn de standaardstructuur voor ranglijsten, rankings, prioriteitswachtrijen en op tijd geordende gegevens.

## Gesorteerde verzamelingen operaties

```bash
# add members with scores; the set stays ordered by score automatically
ZADD leaderboard 100 "Ann" 90 "Bob" 110 "Carol"
ZRANGE leaderboard 0 -1 WITHSCORES        # ascending by score: Bob(90), Ann(100), Carol(110)
ZREVRANGE leaderboard 0 2 WITHSCORES      # DESCENDING top 3 (highest scores first)
ZRANK leaderboard "Ann"                    # Ann's rank (position) ascending
ZREVRANK leaderboard "Ann"                 # rank descending (e.g. "2nd place")
ZSCORE leaderboard "Ann"                   # => 100 (Ann's score)
ZINCRBY leaderboard 5 "Ann"               # add 5 to Ann's score (atomic)
```

Leden zijn uniek (zoals een verzameling) maar elk heeft een score, en de verzameling is altijd gesorteerd op score — dus u kunt efficiënt bereiken, rangen en gesorteerde resultaten verkrijgen.

## Use case: ranglijst / ranking

```bash
# a game leaderboard — update scores, get top players and ranks instantly
ZINCRBY game:scores 10 "player1"          # player scores 10 points
ZREVRANGE game:scores 0 9 WITHSCORES      # top 10 players
ZREVRANK game:scores "player1"             # this player's rank
# → all efficient; the sorted set keeps everything ranked automatically
```

**Ranglijsten** zijn het klassieke gebruik: scores worden bijgewerkt en u krijgt onmiddellijk de top N en de rang van elke speler — efficiënt, zonder handmatig te sorteren.

## Bereik-query's op score

```bash
ZRANGEBYSCORE leaderboard 90 100          # members with scores 90-100
ZREMRANGEBYSCORE events 0 1609459200      # remove old items by score (e.g. timestamp)
# → using a TIMESTAMP as the score makes a time-ordered set (priority queue, time-series)
```

Door een **timestamp als de score** te gebruiken, ontstaat op tijd geordende gegevens — een veel voorkomend patroon voor prioriteitswachtrijen, geplande taken en op tijd begrensd gegevens.

## Waarom het belangrijk is

Gesorteerde verzamelingen zijn een van de meest krachtige en onderscheidende gegevensstructuren van Redis, dus het begrijpen ervan is waardevolle kennis die belangrijke use cases ontsluit.

De combinatie — **unieke leden, elk met een score, automatisch gesorteerd** — lost efficiënt problemen op die elders omslachtig zouden zijn.

De klassieke toepassing is **ranglijsten/rankings**: scores worden bijgewerkt (`ZINCRBY`) en u krijgt onmiddellijk de **top N** (`ZREVRANGE`) en de **rang** (`ZREVRANK`) van elk lid zonder handmatig te sorteren — wat realtime-ranglijsten (veel voorkomend in spellen, competities, trending content) triviaal en efficiënt maakt, wat een kenmerkend Redis use case is.

Buiten ranglijsten drijven gesorteerde verzamelingen **prioriteitswachtrijen** (score = prioriteit), **op tijd geordende gegevens en geplande taken** (met behulp van een **timestamp als de score** om op tijd geordende verzamelingen te creëren, bereik-query's op tijd in te schakelen en oude items te verwijderen — een veel voorkomend patroon voor time-series, vertraagde taken en op tijd begrensd gegevens) en **bereik-query's op score** (`ZRANGEBYSCORE`).

Het begrijpen van gesorteerde verzamelingen en deze patronen stelt u in staat om ranking-, prioriteits- en tijd-ordening problemen elegant met Redis op te lossen.

Aangezien rankings, ranglijsten, prioriteitswachtrijen en op tijd geordende gegevens veel voorkomende behoeften zijn, en aangezien gesorteerde verzamelingen een efficiënte, elegante structuur voor allemaal bieden (automatisch de volgorde op score behoudend), is het begrijpen van gesorteerde verzamelingen — de operaties, het ranglijst use case en het timestamp-as-score patroon voor op tijd geordende gegevens — waardevolle, onderscheidende Redis kennis die krachtige mogelijkheden ontsluit, een van de structuren die het best aantoont waarom de rijke gegevenstypen van Redis het veel meer maken dan een eenvoudige cache.