ZRANGE 

ZRANGE key start stop [BYSCORE | BYLEX] [REV] [LIMIT offset count]
  [WITHSCORES]
Available since:
Redis Open Source 1.2.0
Time complexity:
O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
ACL categories:
@read, @sortedset, @slow,
Compatibility:
Redis Software and Redis Cloud compatibility

Returns the specified range of elements in the sorted set stored at <key>.

ZRANGE can perform different types of range queries: by index (rank), by the score, or by lexicographical order.

Starting with Redis 6.2.0, this command can replace the following commands: ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANGEBYLEX and ZREVRANGEBYLEX.

Required arguments

key

The name of the key that holds the sorted set.

start

The start of the range. By default a zero-based index (negatives count from the end); a score bound with BYSCORE; or a lexicographical bound with BYLEX.

stop

The end of the range, inclusive. Interpreted the same way as start.

Optional arguments

BYSCORE | BYLEX

Interpret the range as a score range (BYSCORE) or a lexicographical range (BYLEX) instead of an index range.

REV

Reverse the ordering so results are returned from high to low.

LIMIT offset count

Skip offset matching members and return up to count of them. Requires BYSCORE or BYLEX. A negative count returns all remaining members.

WITHSCORES

Also return the score of each member.

Examples

Foundational: Retrieve a range of members from a sorted set by index using ZRANGE (supports negative indexes, inclusive range)
ZADD myzset 1 "one" 2 "two" 3 "three" ZRANGE myzset 0 -1 ZRANGE myzset 2 3 ZRANGE myzset -2 -1
Redis CLI guide
Also, check out our other client tools Redis Insight and Redis for VS Code. 
res = r.zadd("myzset", {"one": 1, "two":2, "three":3})
print(res)
# >>> 3

res = r.zrange("myzset", 0, -1)
print(res)
# >>> ['one', 'two', 'three']

res = r.zrange("myzset", 2, 3)
print(res)
# >>> ['three']

res = r.zrange("myzset", -2, -1)
print(res)
# >>> ['two', 'three']
Python Quick-Start 
const val5 = await client.zAdd("myzset", [
  { value: 'one', score: 1 },
  { value: 'two', score: 2 },
  { value: 'three', score: 3 }
]);
console.log(val5);
// returns 3

const val6 = await client.zRange('myzset', 0, -1);
console.log(val6);
// returns ['one', 'two', 'three']

const val7 = await client.zRange('myzset', 2, 3);
console.log(val7);
// returns ['three']

const val8 = await client.zRange('myzset', -2, -1);
console.log(val8);
// returns ['two', 'three']
Node.js Quick-Start 
const res5 = await redis.zadd('myzset', 1, 'one', 2, 'two', 3, 'three');
console.log(res5); // >>> 3

const res6 = await redis.zrange('myzset', 0, -1);
console.log(res6); // >>> ['one', 'two', 'three']

const res7 = await redis.zrange('myzset', 2, 3);
console.log(res7); // >>> ['three']

const res8 = await redis.zrange('myzset', -2, -1);
console.log(res8); // >>> ['two', 'three']
ioredis Quick-Start 
        Map<String, Double> zRangeExampleParams1 = new HashMap<>();
        zRangeExampleParams1.put("one", 1.0);
        zRangeExampleParams1.put("two", 2.0);
        zRangeExampleParams1.put("three", 3.0);
        long zRangeResult1 = jedis.zadd("myzset", zRangeExampleParams1);
        System.out.println(zRangeResult1);  // >>> 3

        List<String> zRangeResult2 = jedis.zrange("myzset", new ZRangeParams(0, -1));
        System.out.println(String.join(", ", zRangeResult2));   // >>> one, two, three

        List<String> zRangeResult3 = jedis.zrange("myzset", new ZRangeParams(2, 3));
        System.out.println(String.join(", ", zRangeResult3));   // >> three

        List<String> zRangeResult4 = jedis.zrange("myzset", new ZRangeParams(-2, -1));
        System.out.println(String.join(", ", zRangeResult4));   // >> two, three
Java-Sync Quick-Start 
            CompletableFuture<Void> zRange1Example = asyncCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .thenCompose(res5 -> {
                        System.out.println(res5); // >>> 3
                        return asyncCommands.zrange("myzset", 0, -1);
                    }).thenCompose(res6 -> {
                        System.out.println(res6); // >>> [one, two, three]
                        return asyncCommands.zrange("myzset", 2, 3);
                    }).thenCompose(res7 -> {
                        System.out.println(res7); // >>> [three]
                        return asyncCommands.zrange("myzset", -2, -1);
                    }).thenAccept(res8 -> {
                        System.out.println(res8); // >>> [two, three]
                    }).toCompletableFuture();
Java-Async Quick-Start 
            Mono<Void> zRange1Example = reactiveCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .doOnNext(res5 -> {
                        System.out.println(res5); // >>> 3
                    })
                    .then(reactiveCommands.zrange("myzset", 0, -1).collectList())
                    .doOnNext(res6 -> {
                        System.out.println(res6); // >>> [one, two, three]
                    })
                    .then(reactiveCommands.zrange("myzset", 2, 3).collectList())
                    .doOnNext(res7 -> {
                        System.out.println(res7); // >>> [three]
                    })
                    .then(reactiveCommands.zrange("myzset", -2, -1).collectList())
                    .doOnNext(res8 -> {
                        System.out.println(res8); // >>> [two, three]
                    })
                    .then();
Java-Reactive Quick-Start 
	zrangeResult1, err := rdb.ZAdd(ctx, "myzset",
		redis.Z{Member: "one", Score: 1},
		redis.Z{Member: "two", Score: 2},
		redis.Z{Member: "three", Score: 3},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zrangeResult1) // >>> 3

	zrangeResult2, err := rdb.ZRange(ctx, "myzset", 0, -1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zrangeResult2) // >>> [one two three]

	zrangeResult3, err := rdb.ZRange(ctx, "myzset", 2, 3).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zrangeResult3) // >>> [three]

	zrangeResult4, err := rdb.ZRange(ctx, "myzset", -2, -1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zrangeResult4) // >>> [two three]
Go Quick-Start 
        long zRangeResult1 = db.SortedSetAdd(
            "myzset",
            [
                new("one", 1),
                new("two", 2),
                new("three", 3)
            ]
        );
        Console.WriteLine(zRangeResult1);   // >>> 3

        RedisValue[] zRangeResult2 = db.SortedSetRangeByRank("myzset", 0, -1);
        Console.WriteLine(string.Join(", ", zRangeResult2));
        // >>> one, two, three

        RedisValue[] zRangeResult3 = db.SortedSetRangeByRank("myzset", 2, 3);
        Console.WriteLine(string.Join(", ", zRangeResult3));
        // >>> three

        RedisValue[] zRangeResult4 = db.SortedSetRangeByRank("myzset", -2, -1);
        Console.WriteLine(string.Join(", ", zRangeResult4));
        // >>> two, three
C#-Sync (SE.Redis) Quick-Start 
        $res5 = $r->zadd('myzset', ['one' => 1, 'two' => 2, 'three' => 3]);
        echo $res5 . PHP_EOL; // >>> 3

        $res6 = $r->zrange('myzset', 0, -1);
        echo json_encode($res6) . PHP_EOL; // >>> ["one","two","three"]

        $res7 = $r->zrange('myzset', 2, 3);
        echo json_encode($res7) . PHP_EOL; // >>> ["three"]

        $res8 = $r->zrange('myzset', -2, -1);
        echo json_encode($res8) . PHP_EOL; // >>> ["two","three"]
PHP Quick-Start 
res5 = r.zadd('myzset', [[1, 'one'], [2, 'two'], [3, 'three']])
puts res5 # >>> 3

res6 = r.zrange('myzset', 0, -1)
puts res6.inspect # >>> ["one", "two", "three"]

res7 = r.zrange('myzset', 2, 3)
puts res7.inspect # >>> ["three"]

res8 = r.zrange('myzset', -2, -1)
puts res8.inspect # >>> ["two", "three"]
Ruby Quick-Start 
        if let Ok(res5) = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]) {
            let res5: i32 = res5;
            println!("{res5}"); // >>> 3
        }

        if let Ok(res6) = r.zrange("myzset", 0, -1) {
            let res6: Vec<String> = res6;
            println!("{res6:?}"); // >>> ["one", "two", "three"]
        }

        if let Ok(res7) = r.zrange("myzset", 2, 3) {
            let res7: Vec<String> = res7;
            println!("{res7:?}"); // >>> ["three"]
        }

        if let Ok(res8) = r.zrange("myzset", -2, -1) {
            let res8: Vec<String> = res8;
            println!("{res8:?}"); // >>> ["two", "three"]
        }
Rust-Sync Quick-Start 
        if let Ok(res5) = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]).await {
            let res5: i32 = res5;
            println!("{res5}"); // >>> 3
        }

        if let Ok(res6) = r.zrange("myzset", 0, -1).await {
            let res6: Vec<String> = res6;
            println!("{res6:?}"); // >>> ["one", "two", "three"]
        }

        if let Ok(res7) = r.zrange("myzset", 2, 3).await {
            let res7: Vec<String> = res7;
            println!("{res7:?}"); // >>> ["three"]
        }

        if let Ok(res8) = r.zrange("myzset", -2, -1).await {
            let res8: Vec<String> = res8;
            println!("{res8:?}"); // >>> ["two", "three"]
        }
Rust-Async Quick-Start

The following example using WITHSCORES shows how the command returns always an array, but this time, populated with element_1, score_1, element_2, score_2, ..., element_N, score_N.

Return scores with members: Retrieve members with their scores from a sorted set using ZRANGE with WITHSCORES option
DEL myzset ZADD myzset 1 "one" 2 "two" 3 "three" ZRANGE myzset 0 1 WITHSCORES
Redis CLI guide
Also, check out our other client tools Redis Insight and Redis for VS Code. 
res = r.zadd("myzset", {"one": 1, "two":2, "three":3})
res = r.zrange("myzset", 0, 1, withscores=True)
print(res)
# >>> [('one', 1.0), ('two', 2.0)]
Python Quick-Start 
const val9 = await client.zAdd("myzset", [
  { value: 'one', score: 1 },
  { value: 'two', score: 2 },
  { value: 'three', score: 3 }
]);
console.log(val9);
// returns 3

const val10 = await client.zRangeWithScores('myzset', 0, 1);
console.log(val10);
// returns [{value: 'one', score: 1}, {value: 'two', score: 2}]
Node.js Quick-Start 
await redis.zadd('myzset', 1, 'one', 2, 'two', 3, 'three');

const res9 = await redis.zrange('myzset', 0, 1, 'WITHSCORES');
console.log(res9); // >>> ['one', '1', 'two', '2']
ioredis Quick-Start 
        Map<String, Double> zRangeExampleParams2 = new HashMap<>();
        zRangeExampleParams2.put("one", 1.0);
        zRangeExampleParams2.put("two", 2.0);
        zRangeExampleParams2.put("three", 3.0);
        long zRangeResult5 = jedis.zadd("myzset", zRangeExampleParams2);
        System.out.println(zRangeResult5);  // >>> 3

        List<Tuple> zRangeResult6 = jedis.zrangeWithScores("myzset", new ZRangeParams(0, 1));

        for (Tuple item: zRangeResult6) {
            System.out.println("Element: " + item.getElement() + ", Score: " + item.getScore());
        }
        // >>> Element: one, Score: 1.0
        // >>> Element: two, Score: 2.0
Java-Sync Quick-Start 
            CompletableFuture<Void> zRange2Example = asyncCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .thenCompose(res9 -> {
                        return asyncCommands.zrangeWithScores("myzset", 0, 1);
                    }).thenAccept(res10 -> {
                        System.out.println(res10);
                        // >>> [ScoredValue[1.000000, one], ScoredValue[2.000000, two]]
                    }).toCompletableFuture();
Java-Async Quick-Start 
            Mono<Void> zRange2Example = reactiveCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .then(reactiveCommands.zrangeWithScores("myzset", 0, 1).collectList())
                    .doOnNext(res9 -> {
                        System.out.println(res9);
                        // >>> [ScoredValue[1.000000, one], ScoredValue[2.000000, two]]
                    })
                    .then();
Java-Reactive Quick-Start 
	zRangeResult5, err := rdb.ZAdd(ctx, "myzset",
		redis.Z{Member: "one", Score: 1},
		redis.Z{Member: "two", Score: 2},
		redis.Z{Member: "three", Score: 3},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zRangeResult5) // >>> 3

	zRangeResult6, err := rdb.ZRangeWithScores(ctx, "myzset", 0, 1).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zRangeResult6) // >>> [{1 one} {2 two}]
Go Quick-Start 
        long zRangeResult5 = db.SortedSetAdd(
            "myzset",
            [
                new("one", 1),
                new("two", 2),
                new("three", 3)
            ]
        );

        SortedSetEntry[] zRangeResult6 = db.SortedSetRangeByRankWithScores("myzset", 0, 1);
        Console.WriteLine($"{string.Join(", ", zRangeResult6.Select(b => $"{b.Element}: {b.Score}"))}");
        // >>> one: 1, two: 2
C#-Sync (SE.Redis) Quick-Start 
        $r->zadd('myzset', ['one' => 1, 'two' => 2, 'three' => 3]);

        $res9 = $r->zrange('myzset', 0, 1, ['withscores' => true]);
        echo json_encode($res9) . PHP_EOL; // >>> {"one":"1","two":"2"}
PHP Quick-Start 
r.zadd('myzset', [[1, 'one'], [2, 'two'], [3, 'three']])

res9 = r.zrange('myzset', 0, 1, with_scores: true)
puts res9.inspect # >>> [["one", 1.0], ["two", 2.0]]
Ruby Quick-Start 
        let _: Result<i32, _> = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]);

        if let Ok(res9) = r.zrange_withscores("myzset", 0, 1) {
            let res9: Vec<(String, f64)> = res9;
            println!("{res9:?}"); // >>> [("one", 1.0), ("two", 2.0)]
        }
Rust-Sync Quick-Start 
        let _: Result<i32, _> = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]).await;

        if let Ok(res9) = r.zrange_withscores("myzset", 0, 1).await {
            let res9: Vec<(String, f64)> = res9;
            println!("{res9:?}"); // >>> [("one", 1.0), ("two", 2.0)]
        }
Rust-Async Quick-Start

This example shows how to query the sorted set by score, excluding the value 1 and up to infinity, returning only the second element of the result:

Query by score: Query a sorted set by score range using ZRANGE with BYSCORE and LIMIT options (supports exclusive ranges and pagination)
DEL myzset ZADD myzset 1 "one" 2 "two" 3 "three" ZRANGE myzset (1 +inf BYSCORE LIMIT 1 1
Redis CLI guide
Also, check out our other client tools Redis Insight and Redis for VS Code. 
res = r.zadd("myzset", {"one": 1, "two":2, "three":3})
res = r.zrange("myzset", 2, 3, byscore=True, offset=1, num=1)
print(res)
# >>> ['three']
Python Quick-Start 
const val11 = await client.zAdd("myzset", [
  { value: 'one', score: 1 },
  { value: 'two', score: 2 },
  { value: 'three', score: 3 }
]);
console.log(val11);
// returns 3

const val12 = await client.zRange('myzset', 2, 3, { BY: 'SCORE', LIMIT: { offset: 1, count: 1 } });
console.log(val12);
// >>> ['three']
Node.js Quick-Start 
await redis.zadd('myzset', 1, 'one', 2, 'two', 3, 'three');

const res10 = await redis.zrange('myzset', '(1', '+inf', 'BYSCORE', 'LIMIT', 1, 1);
console.log(res10); // >>> ['three']
ioredis Quick-Start 
        Map<String, Double> zRangeExampleParams3 = new HashMap<>();
        zRangeExampleParams3.put("one", 1.0);
        zRangeExampleParams3.put("two", 2.0);
        zRangeExampleParams3.put("three", 3.0);
        long zRangeResult7 = jedis.zadd("myzset", zRangeExampleParams3);
        System.out.println(zRangeResult7);  // >>> 3

        List<String> zRangeResult8 = jedis.zrangeByScore("myzset", "(1", "+inf", 1, 1);
        System.out.println(String.join(", ", zRangeResult8));   // >>> three
Java-Sync Quick-Start 
            CompletableFuture<Void> zRange3Example = asyncCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .thenCompose(res11 -> {
                        return asyncCommands.zrangebyscore("myzset",
                                Range.from(Range.Boundary.excluding(1d), Range.Boundary.unbounded()),
                                Limit.create(1, 1));
                    }).thenAccept(res12 -> {
                        System.out.println(res12); // >>> [three]
                    }).toCompletableFuture();
Java-Async Quick-Start 
            Mono<Void> zRange3Example = reactiveCommands.zadd("myzset",
                    ScoredValue.just(1d, "one"), ScoredValue.just(2d, "two"), ScoredValue.just(3d, "three"))
                    .then(reactiveCommands.zrangebyscore("myzset",
                            Range.from(Range.Boundary.excluding(1d), Range.Boundary.unbounded()),
                            Limit.create(1, 1)).collectList())
                    .doOnNext(res10 -> {
                        System.out.println(res10); // >>> [three]
                    })
                    .then();
Java-Reactive Quick-Start 
	zRangeResult7, err := rdb.ZAdd(ctx, "myzset",
		redis.Z{Member: "one", Score: 1},
		redis.Z{Member: "two", Score: 2},
		redis.Z{Member: "three", Score: 3},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zRangeResult7) // >>> 3

	zRangeResult8, err := rdb.ZRangeArgs(ctx,
		redis.ZRangeArgs{
			Key:     "myzset",
			ByScore: true,
			Start:   "(1",
			Stop:    "+inf",
			Offset:  1,
			Count:   1,
		},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(zRangeResult8) // >>> [three]
Go Quick-Start 
        long zRangeResult7 = db.SortedSetAdd(
            "myzset",
            [
                new("one", 1),
                new("two", 2),
                new("three", 3)
            ]
        );

        RedisValue[] zRangeResult8 = db.SortedSetRangeByScore(
            "myzset",
            1,
            double.PositiveInfinity,
            Exclude.Start,
            skip: 1, take: 1
        );
        Console.WriteLine(string.Join(", ", zRangeResult8));
        // >>> three
C#-Sync (SE.Redis) Quick-Start 
        $r->zadd('myzset', ['one' => 1, 'two' => 2, 'three' => 3]);

        $res10 = $r->zrange('myzset', '(1', '+inf', ['byscore' => true, 'limit' => [1, 1]]);
        echo json_encode($res10) . PHP_EOL; // >>> ["three"]
PHP Quick-Start 
r.zadd('myzset', [[1, 'one'], [2, 'two'], [3, 'three']])

res10 = r.zrange('myzset', '(1', '+inf', by_score: true, limit: [1, 1])
puts res10.inspect # >>> ["three"]
Ruby Quick-Start 
        let _: Result<i32, _> = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]);

        if let Ok(res10) = r.zrangebyscore_limit("myzset", "(1", "+inf", 1, 1) {
            let res10: Vec<String> = res10;
            println!("{res10:?}"); // >>> ["three"]
        }
Rust-Sync Quick-Start 
        let _: Result<i32, _> = r.zadd_multiple("myzset", &[(1, "one"), (2, "two"), (3, "three")]).await;

        if let Ok(res10) = r.zrangebyscore_limit("myzset", "(1", "+inf", 1, 1).await {
            let res10: Vec<String> = res10;
            println!("{res10:?}"); // >>> ["three"]
        }
Rust-Async Quick-Start

Details

Common behavior and options

The order of elements is from the lowest to the highest score. Elements with the same score are ordered lexicographically.

The optional REV argument reverses the ordering, so elements are ordered from highest to lowest score, and score ties are resolved by reverse lexicographical ordering.

The optional LIMIT argument can be used to obtain a sub-range from the matching elements (similar to SELECT LIMIT offset, count in SQL). A negative <count> returns all elements from the <offset>. Keep in mind that if <offset> is large, the sorted set needs to be traversed for <offset> elements before getting to the elements to return, which can add up to O(N) time complexity.

The optional WITHSCORES argument supplements the command's reply with the scores of elements returned. The returned list contains value1,score1,...,valueN,scoreN instead of value1,...,valueN. Client libraries are free to return a more appropriate data type (suggestion: an array with (value, score) arrays/tuples).

Index ranges

By default, the command performs an index range query. The <start> and <stop> arguments represent zero-based indexes, where 0 is the first element, 1 is the next element, and so on. These arguments specify an inclusive range, so for example, ZRANGE myzset 0 1 will return both the first and the second element of the sorted set.

The indexes can also be negative numbers indicating offsets from the end of the sorted set, with -1 being the last element of the sorted set, -2 the penultimate element, and so on.

Out of range indexes do not produce an error.

If <start> is greater than either the end index of the sorted set or <stop>, an empty list is returned.

If <stop> is greater than the end index of the sorted set, Redis will use the last element of the sorted set.

Score ranges

When the BYSCORE option is provided, the command behaves like ZRANGEBYSCORE and returns the range of elements from the sorted set having scores equal or between <start> and <stop>.

<start> and <stop> can be -inf and +inf, denoting the negative and positive infinities, respectively. This means that you are not required to know the highest or lowest score in the sorted set to get all elements from or up to a certain score.

By default, the score intervals specified by <start> and <stop> are closed (inclusive). It is possible to specify an open interval (exclusive) by prefixing the score with the character (.

For example:

ZRANGE zset (1 5 BYSCORE

Will return all elements with 1 < score <= 5 while:

ZRANGE zset (5 (10 BYSCORE

Will return all the elements with 5 < score < 10 (5 and 10 excluded).

Reverse ranges

Using the REV option reverses the sorted set, with index 0 as the element with the highest score.

By default, <start> must be less than or equal to <stop> to return anything. However, if the BYSCORE, or BYLEX options are selected, the <start> is the highest score to consider, and <stop> is the lowest score to consider, therefore <start> must be greater than or equal to <stop> in order to return anything.

For example:

ZRANGE zset 5 10 REV

Will return the elements between index 5 and 10 in the reversed index.

ZRANGE zset 10 5 REV BYSCORE

Will return all elements with scores less than 10 and greater than 5.

Lexicographical ranges

When the BYLEX option is used, the command behaves like ZRANGEBYLEX and returns the range of elements from the sorted set between the <start> and <stop> lexicographical closed range intervals.

Note that lexicographical ordering relies on all elements having the same score. The reply is unspecified when the elements have different scores.

Valid <start> and <stop> must start with ( or [, in order to specify whether the range interval is exclusive or inclusive, respectively.

The special values of + or - for <start> and <stop> mean positive and negative infinite strings, respectively, so for instance the command ZRANGE myzset - + BYLEX is guaranteed to return all the elements in the sorted set, providing that all the elements have the same score.

The REV options reverses the order of the <start> and <stop> elements, where <start> must be lexicographically greater than <stop> to produce a non-empty result.

Lexicographical comparison of strings

Strings are compared as a binary array of bytes. Because of how the ASCII character set is specified, this means that usually this also have the effect of comparing normal ASCII characters in an obvious dictionary way. However, this is not true if non-plain ASCII strings are used (for example, utf8 strings).

However, the user can apply a transformation to the encoded string so that the first part of the element inserted in the sorted set will compare as the user requires for the specific application. For example, if I want to add strings that will be compared in a case-insensitive way, but I still want to retrieve the real case when querying, I can add strings in the following way:

ZADD autocomplete 0 foo:Foo 0 bar:BAR 0 zap:zap

Because of the first normalized part in every element (before the colon character), we are forcing a given comparison. However, after the range is queried using ZRANGE ... BYLEX, the application can display to the user the second part of the string, after the colon.

The binary nature of the comparison allows to use sorted sets as a general purpose index, for example, the first part of the element can be a 64-bit big-endian number. Since big-endian numbers have the most significant bytes in the initial positions, the binary comparison will match the numerical comparison of the numbers. This can be used in order to implement range queries on 64-bit values. As in the example below, after the first 8 bytes, we can store the value of the element we are indexing.

Redis Software and Redis Cloud compatibility

Redis
Software		 Redis
Cloud		 Notes
✅ Standard
✅ Active-Active		 ✅ Standard
✅ Active-Active

Return information

Array reply: a list of members in the specified range with, optionally, their scores when the WITHSCORES option is given.

History

  • Starting with Redis version 6.2.0: Added the REV, BYSCORE, BYLEX and LIMIT options.
RATE THIS PAGE
Back to top ↑