# Redis sorted sets

Introduction to Redis sorted sets

A Redis sorted set is a collection of unique strings (members) ordered by an associated score. When more than one string has the same score, the strings are ordered lexicographically. Some use cases for sorted sets include:

• Leaderboards. For example, you can use sorted sets to easily maintain ordered lists of the highest scores in a massive online game.
• Rate limiters. In particular, you can use a sorted set to build a sliding-window rate limiter to prevent excessive API requests.

You can think of sorted sets as a mix between a Set and a Hash. Like sets, sorted sets are composed of unique, non-repeating string elements, so in some sense a sorted set is a set as well.

However while elements inside sets are not ordered, every element in a sorted set is associated with a floating point value, called the score (this is why the type is also similar to a hash, since every element is mapped to a value).

Moreover, elements in a sorted set are taken in order (so they are not ordered on request, order is a peculiarity of the data structure used to represent sorted sets). They are ordered according to the following rule:

• If B and A are two elements with a different score, then A > B if A.score is > B.score.
• If B and A have exactly the same score, then A > B if the A string is lexicographically greater than the B string. B and A strings can't be equal since sorted sets only have unique elements.

Let's start with a simple example, we'll add all our racers and the score they got in the first race:

As you can see `ZADD` is similar to `SADD`, but takes one additional argument (placed before the element to be added) which is the score. `ZADD` is also variadic, so you are free to specify multiple score-value pairs, even if this is not used in the example above.

With sorted sets it is trivial to return a list of hackers sorted by their birth year because actually they are already sorted.

Implementation note: Sorted sets are implemented via a dual-ported data structure containing both a skip list and a hash table, so every time we add an element Redis performs an O(log(N)) operation. That's good, so when we ask for sorted elements, Redis does not have to do any work at all, it's already sorted. Note that the `ZRANGE` order is low to high, while the `ZREVRANGE` order is high to low:

Note: 0 and -1 means from element index 0 to the last element (-1 works here just as it does in the case of the `LRANGE` command).

It is possible to return scores as well, using the `WITHSCORES` argument:

### Operating on ranges

Sorted sets are more powerful than this. They can operate on ranges. Let's get all the racers with 10 or fewer points. We use the `ZRANGEBYSCORE` command to do it:

We asked Redis to return all the elements with a score between negative infinity and 10 (both extremes are included).

To remove an element we'd simply call `ZREM` with the racer's name. It's also possible to remove ranges of elements. Let's remove racer Castilla along with all the racers with strictly fewer than 10 points: