八redis的sortset数据类型常见命令、内部编码、场景

你的名字 2023-03-13 05:51 9阅读 0赞

有序保存多个不重复的字符串的集合。

## 常见命令 ##

### zadd ###

*  解释
    
    有序集合插入元素以及元素的分数（分数支持双精度浮点数）。  
    如果本次插入的元素已经存在，则更新元素的分数，并且重排序。  
    如果键不存在，则创建Key。  
    如果其中元素的分数相同，则按照字典序排序。
 *  用法 zadd key \[NX|XX\] \[CH\]\[INCR\] socre member \[score member\]  
    NX: 仅仅更新元素的分数，元素必须存在才能操作成功  
    XX: 仅仅添加元素及其分数，当元素存在，则不操作
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 2 two
    (integer) 1
    127.0.0.1:6379> zrange key1 0 -1 withscores
    1)"one"
    2)"1"
    3)"two"
    4)"2"

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zadd",zaddCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}
    }

1.  赋值要设置元素的分数给变量scoreval
2.  在dict中查找键是否存在
3.  键不存在，创建数据类型为zset的键其内部编码为跳表，加入键到dict中
4.  键存在，如果数据类型不是zset返回错误信息
5.  如果命令为zadd,则incr=0;命令为zincrby,则incr=1,则进入下面代码块  
    5.1 如果元素存在,新的score等于老值加本次增加的score  
    5.2 如果score的值不是数字类型，返回错误信息
6.  如果元素不存在，新插入元素
7.  如果元素存在，删除元素重新插入元素及其分数

/** ** t_zset.c ** **/
    void zaddCommand(redisClient *c) { 
        double scoreval;
    	// 1.赋值要设置元素的分数给变量scoreval
        if (getDoubleFromObjectOrReply(c,c->argv[2],&scoreval,NULL) != REDIS_OK) return;
        c->argv[3] = tryObjectEncoding(c->argv[3]);
        zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,0);
    }
    
    
    void zaddGenericCommand(redisClient *c, robj *key, robj *ele, double score, int incr) { 
        robj *zsetobj;
        zset *zs;
        zskiplistNode *znode;
    	
    	//2. 在dict中查找键是否存在
        zsetobj = lookupKeyWrite(c->db,key);
        if (zsetobj == NULL) { 
    		//3. 键不存在，创建数据类型为zset的键其内部编码为跳表，加入键到dict中
            zsetobj = createZsetObject();
            dbAdd(c->db,key,zsetobj);
        } else { 
    		//4. 键存在，如果数据类型不是zset返回错误信息
            if (zsetobj->type != REDIS_ZSET) { 
                addReply(c,shared.wrongtypeerr);
                return;
            }
        }
        zs = zsetobj->ptr;
    
        // 5. 如果命令为zadd,则incr=0;命令为zincrby,则incr=1,则进入下面代码块
        if (incr) { 
    
            dictEntry *de = dictFind(zs->dict,ele);
    		// 5.1 如果元素存在,新的score等于老值加本次增加的score
            if (de != NULL)
                score += *(double*)dictGetEntryVal(de);
    		//5.2 如果score的值不是数字类型，返回错误信息
            if (isnan(score)) { 
                addReplyError(c,"resulting score is not a number (NaN)");    
                return;
            }
        }
    
       //6. 如果元素不存在，新插入元素
        if (dictAdd(zs->dict,ele,NULL) == DICT_OK) { 
            dictEntry *de;
    
           
            incrRefCount(ele); /* added to hash */
            znode = zslInsert(zs->zsl,score,ele);
            incrRefCount(ele); /* added to skiplist */
    
            /* Update the score in the dict entry */
            de = dictFind(zs->dict,ele);
            redisAssert(de != NULL);
            dictGetEntryVal(de) = &znode->score;
            touchWatchedKey(c->db,c->argv[1]);
            server.dirty++;
            if (incr)
                addReplyDouble(c,score);
            else
                addReply(c,shared.cone);
        } else { 
    	//7. 如果元素存在，删除元素重新插入元素及其分数
            dictEntry *de;
            robj *curobj;
            double *curscore;
            int deleted;
    
            /* Update score */
            de = dictFind(zs->dict,ele);
            redisAssert(de != NULL);
            curobj = dictGetEntryKey(de);
            curscore = dictGetEntryVal(de);
    
            /* When the score is updated, reuse the existing string object to * prevent extra alloc/dealloc of strings on ZINCRBY. */
            if (score != *curscore) { 
                deleted = zslDelete(zs->zsl,*curscore,curobj);
                redisAssert(deleted != 0);
                znode = zslInsert(zs->zsl,score,curobj);
                incrRefCount(curobj);
    
                /* Update the score in the current dict entry */
                dictGetEntryVal(de) = &znode->score;
                touchWatchedKey(c->db,c->argv[1]);
                server.dirty++;
            }
            if (incr)
                addReplyDouble(c,score);
            else
                addReply(c,shared.czero);
        }
    }

### zcard ###

*  解释
    
    返回有序集合元素的个数，如果键不存在，返回0
 *  用法 zcard key
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 2 two
    (integer) 1
    127.0.0.1:6379> zcard key1 
    (integer) 2

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
      { "zcard",zcardCommand,2,0,NULL,1,1,1}
    }

void zcardCommand(redisClient *c) { 
        robj *o;
        zset *zs;
    	//1.检查键是否存在以及是否数据类型是sort set，否则返回0
        if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
            checkType(c,o,REDIS_ZSET)) return;
    	//2. 获取到键中元素的指针，获取长度
        zs = o->ptr;
        addReplyLongLong(c,zs->zsl->length);
    }

### zcount ###

*  解释
    
    返回有序集合中元素分数在min和max中间的元素个数。  
    min max 表示在min,max之间包含min,max,  
    (min (max表示在min,max之间，不包含min,max  
    min最小值是-inf,max最大值是+inf
 *  用法 zcount key min max
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer)1
    127.0.0.1:6379> zadd key1 2 two
    (integer)1
    127.0.0.1:6379> zcount key1 1 2
    (integer)2
    127.0.0.1:6379> zcount key1 -inf +inf
    (integer)2

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
       { "zcount",zcountCommand,4,0,NULL,1,1,1}
    }

1.  解析min.max的值
2.  ZRANGEBYSCORE, ZREVRANGEBYSCORE命令可能是有超过四个参数的，需要解析出来
3.  检查键是否存在以及是否数据类型是sort set，否则返回0
4.  zset的对象
5.  获取跳表中等于min或者大于min的分数元素指针
6.  reverse=0 分数从低到高，reverse=1 分数从高到低
7.  没有范围内的元素，直接返回
8.  zcount命令 limit = -1,offset = 0 ln表示等于或大于start的元素的指针，根据正反序，以及是否包含stop进行判断
9.  元素在范围内计数

/** ** t_zset.c **/
    
    void zcountCommand(redisClient *c) { 
        genericZrangebyscoreCommand(c,0,1);
    }
    
    
    void genericZrangebyscoreCommand(redisClient *c, int reverse, int justcount) { 
        zrangespec range;
        robj *o, *emptyreply;
        zset *zsetobj;
        zskiplist *zsl;
        zskiplistNode *ln;
        int offset = 0, limit = -1;
        int withscores = 0;
        unsigned long rangelen = 0;
        void *replylen = NULL;
    
        // 1.解析min.max的值
        if (zslParseRange(c->argv[2],c->argv[3],&range) != REDIS_OK) { 
            addReplyError(c,"min or max is not a double");
            return;
        }
    
        //2. ZRANGEBYSCORE, ZREVRANGEBYSCORE命令可能是有超过四个参数的，需要解析出来
        if (c->argc > 4) { 
            int remaining = c->argc - 4;
            int pos = 4;
    
            while (remaining) { 
                if (remaining >= 1 && !strcasecmp(c->argv[pos]->ptr,"withscores")) { 
                    pos++; remaining--;
                    withscores = 1;
                } else if (remaining >= 3 && !strcasecmp(c->argv[pos]->ptr,"limit")) { 
                    offset = atoi(c->argv[pos+1]->ptr);
                    limit = atoi(c->argv[pos+2]->ptr);
                    pos += 3; remaining -= 3;
                } else { 
                    addReply(c,shared.syntaxerr);
                    return;
                }
            }
        }
    
        //3. 检查键是否存在以及是否数据类型是sort set，否则返回0
        emptyreply = justcount ? shared.czero : shared.emptymultibulk;
        if ((o = lookupKeyReadOrReply(c,c->argv[1],emptyreply)) == NULL ||
            checkType(c,o,REDIS_ZSET)) return;
    	//4. zset的对象
        zsetobj = o->ptr;
        zsl = zsetobj->zsl;
    
        //5. 获取跳表中等于min或者大于min的分数元素指针
        ln = zslFirstWithScore(zsl,range.min);
    	//6. reverse=0 分数从低到高，reverse=1 分数从高到低
        if (reverse) { 
            /* If range.min is out of range, ln will be NULL and we need to use * the tail of the skiplist as first node of the range. */
            if (ln == NULL) ln = zsl->tail;
    
            /* zslFirstWithScore returns the first element with where with * score >= range.min, so backtrack to make sure the element we use * here has score <= range.min. */
            while (ln && ln->score > range.min) ln = ln->backward;
    
            /* Move to the right element according to the range spec. */
            if (range.minex) { 
                /* Find last element with score < range.min */
                while (ln && ln->score == range.min) ln = ln->backward;
            } else { 
                /* Find last element with score <= range.min */
                while (ln && ln->level[0].forward &&
                             ln->level[0].forward->score == range.min)
                    ln = ln->level[0].forward;
            }
        } else { 
            if (range.minex) { 
                /* Find first element with score > range.min */
                while (ln && ln->score == range.min) ln = ln->level[0].forward;
            }
        }
    
       //7. 没有范围内的元素，直接返回
        if (ln == NULL) { 
            addReply(c,emptyreply);
            return;
        }
    
        /* We don't know in advance how many matching elements there * are in the list, so we push this object that will represent * the multi-bulk length in the output buffer, and will "fix" * it later */
        if (!justcount)
            replylen = addDeferredMultiBulkLength(c);
    
        /* If there is an offset, just traverse the number of elements without * checking the score because that is done in the next loop. */
        while(ln && offset--) { 
            if (reverse)
                ln = ln->backward;
            else
                ln = ln->level[0].forward;
        }
    
    	//8. zcount命令 limit = -1,offset = 0 ln表示等于或大于start的元素的指针
    	// 根据正反序，以及是否包含stop进行判断 
        while (ln && limit--) { 
            /* Check if this this element is in range. */
            if (reverse) { 
                if (range.maxex) { 
                    /* Element should have score > range.max */
                    if (ln->score <= range.max) break;
                } else { 
                    /* Element should have score >= range.max */
                    if (ln->score < range.max) break;
                }
            } else { 
                if (range.maxex) { 
                    /* Element should have score < range.max */
                    if (ln->score >= range.max) break;
                } else { 
                    /* Element should have score <= range.max */
                    if (ln->score > range.max) break;
                }
            }
    
            //9. 元素在范围内计数
            rangelen++;
            if (!justcount) { 
                addReplyBulk(c,ln->obj);
                if (withscores)
                    addReplyDouble(c,ln->score);
            }
    		
            if (reverse)
                ln = ln->backward;
            else
                ln = ln->level[0].forward;
        }
    
        if (justcount) { 
            addReplyLongLong(c,(long)rangelen);
        } else { 
            setDeferredMultiBulkLength(c,replylen,
                 withscores ? (rangelen*2) : rangelen);
        }
    }

### zincrby ###

*  解释
    
    有序集合指定元素增加指定的分数,结果返回元素最终的值;  
    如果元素不存在，则元素的分数为本次指定的值;  
    如果键不存在，创建键后，增加元素并且指定其值为本次指定的值;  
    如果键的类型不是有序集合(zset)，则返回错误。
 *  用法 zincrby key increment member
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer)1
    127.0.0.1:6379> zincrby key1 3 one
    (integer)4
    127.0.0.1:6379> zincrby key1 5 three
    (integer)5
    127.0.0.1:6379> zrange key1 0 -1 withscores
    1)"one"
    2)"4"
    3)"three"
    4)"5"

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zincrby",zincrbyCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}
    }
    
    
    
    /** ** t_zset.c 参考zadd **/
    void zincrbyCommand(redisClient *c) { 
        double scoreval;
        if (getDoubleFromObjectOrReply(c,c->argv[2],&scoreval,NULL) != REDIS_OK) return;
        c->argv[3] = tryObjectEncoding(c->argv[3]);
        zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,1);
    }

### zlexcount ###

*  解释
    
    当有序集合的所有元素的分数是相同的时候，会强制使用字典序对元素进行排序。  
    这个元素返回在start,stop之间的的元素个数。
 *  用法 zlexcount key min max  
    min,max的书写必须使用(,\[, ( 表示不包含， \[ 表示包含。  
    zlexcount - + 表示所有元素.
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer)
    127.0.0.1:6379> zadd key1 1 two
    (integer)1
    127.0.0.1:6379> zlexcount key1 - +
    (integer)2
    127.0.0.1:6379> zlexcount key1 [o  [w
    (integer)2

### zpopmax ###

*  解释
    
    返回有序集合中分数最大的count的元素，并且从有序集合中删除这些元素  
    如果count未指定，则操作分数最大的元素。  
    注意:这个命令redis5.0.0及之后的版本才支持
 *  用法 zpopmax key \[count\]
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer)1
    127.0.0.1:6379> zadd key1 2 two
    (integer)1
    127.0.0.1:6379> zpopmax key1
    1)"two"
    2)"2"

### zpopmin ###

*  解释
    
    返回有序集合中分数最小的count的元素，并且从有序集合中删除这些元素  
    如果count未指定，则操作分数最小的元素。  
    注意:这个命令redis5.0.0及之后的版本才支持
 *  用法
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer)1
    127.0.0.1:6379> zadd key1 2 two
    (integer)1
    127.0.0.1:6379> zpopmix key1
    1)"one"
    2)"1"

*  源码

### zrange ###

*  解释
    
    返回有序集合的元素，按照分数从低到高返回。  
    如果元素的分数相同，按照元素的字典序排序；  
    如果想返回元素的分数，使用withscores;  
    start,stop从0开始（表示第一个元素），start,stop包含start,stop，  
    如zrange key 0 1 返回索引为0，1之间的元素包含0，1;
 *  用法 zrange key start stop \[witscores\]
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 2 two
    (integer) 1
    127.0.0.1:6379> zrange key1 0 -1
    1)one
    2)two
    127.0.0.1:6379> zrange key1 0 -1 withscores
    1)"one"
    2)"1"
    3)"two"
    4)"2"

*  源码

1.  解析出statr,stop的值
2.  解析传入的命令参数是否包含withscores需要返回元素对应的分数
3.  如果命令的参数大于5，返回语法错误
4.  查询键是否存在以及是否是sortset数据类型
5.  转换存储的负的索引值
6.  如果startd大于end或start超出了元素的个数返回错误信息
7.  如果stop最大为元素个数的长度
8.  获取到开始遍历的元素对象
9.  返回元素，如果要返回分数也返回分数

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zrange",zrangeCommand,-4,0,NULL,1,1,1}
    }

/** ** t_zset.c **/
    
    void zrangeCommand(redisClient *c) { 
        zrangeGenericCommand(c,0);
    }
    
    void zrangeGenericCommand(redisClient *c, int reverse) { 
        robj *o;
        long start;
        long end;
        int withscores = 0;
        int llen;
        int rangelen, j;
        zset *zsetobj;
        zskiplist *zsl;
        zskiplistNode *ln;
        robj *ele;
    
    	//1. 解析出statr,stop的值
        if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != REDIS_OK) ||
            (getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != REDIS_OK)) return;
    
    	//2. 解析传入的命令参数是否包含withscores需要返回元素对应的分数
        if (c->argc == 5 && !strcasecmp(c->argv[4]->ptr,"withscores")) { 
            withscores = 1;
        } else if (c->argc >= 5) { 
    	//3. 如果命令的参数大于5，返回语法错误
            addReply(c,shared.syntaxerr);
            return;
        }
    	//4. 查询键是否存在以及是否是sortset数据类型
        if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk)) == NULL
             || checkType(c,o,REDIS_ZSET)) return;
        zsetobj = o->ptr;
        zsl = zsetobj->zsl;
        llen = zsl->length;
    
        //5. 转换存储的负的索引值
        if (start < 0) start = llen+start;
        if (end < 0) end = llen+end;
        if (start < 0) start = 0;
    
        //6. 如果startd大于end或start超出了元素的个数返回错误信息
        if (start > end || start >= llen) { 
            addReply(c,shared.emptymultibulk);
            return;
        }
    	//7. 如果stop最大为元素个数的长度
        if (end >= llen) end = llen-1;
        rangelen = (end-start)+1;
    
        //8. 获取到开始遍历的元素对象
        if (reverse) { 
            ln = start == 0 ? zsl->tail : zslGetElementByRank(zsl, llen-start);
        } else { 
            ln = start == 0 ?
                zsl->header->level[0].forward : zslGetElementByRank(zsl, start+1);
        }
    
        //9. 返回元素，如果要返回分数也返回分数
        addReplyMultiBulkLen(c,withscores ? (rangelen*2) : rangelen);
        for (j = 0; j < rangelen; j++) { 
            ele = ln->obj;
            addReplyBulk(c,ele);
            if (withscores)
                addReplyDouble(c,ln->score);
            ln = reverse ? ln->backward : ln->level[0].forward;
        }
    }

### zrevrange ###

*  解释
    
    返回有序集合的元素，按照分数从高到低返回。  
    如果元素的分数相同，按照元素的字典序排序；  
    如果想返回元素的分数，使用withscores;  
    start,stop从0开始（表示第一个元素），start,stop包含start,stop，  
    zrevrange key 0 1 返回索引为0，1之间的元素包含0，1;
 *  用法 zrevrange key start stop \[withscores\]
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 2 two
    (integer) 1
    127.0.0.1:6379> zrange key1 0 -1
    1)one
    2)two
    127.0.0.1:6379> zrevrange key1 0 -1 withscores
    1)"two"
    2)"2"
    3)"one"
    4)"1"

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zrevrange",zrevrangeCommand,-4,0,NULL,1,1,1}
    }
    
    /** ** 参见zrange ** t_zset.c **/
    void zrevrangeCommand(redisClient *c) { 
        zrangeGenericCommand(c,1);
    }

### zrangebyscore ###

*  解释

返回有序集合中的元素分数在start,stop(包含start,stop)之间按照分数从低到高排序，  
如果分数相同，按照字典序排序，

*  用法 zrangebyscore key min max \[withscores\] \[limit offset count\]
    
    withscores: 返回包含元素的分数  
    min:最小是-inf  
    max:最大是+inf  
    min, max = -inf, +inf 表示返回所有的元素
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 2 two
    (integer) 1
    127.0.0.1:6379> zrange key1 0 -1
    1)one
    2)two
    127.0.0.1:6379> zrangebyscore key1 -inf +inf
    1)"one"
    2)"two"

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zrangebyscore",zrangebyscoreCommand,-4,0,NULL,1,1,1}
    }
    
    /** ** 参见zcount ** t_zset.c **/
    void zrangebyscoreCommand(redisClient *c) { 
        genericZrangebyscoreCommand(c,0,0);
    }

### zrank ###

*  解释

返回有序集合中指定元素的索引，  
索引从0开始，元素排序按照分数从低到高。  
zrevrank按照分数从高到低排序。

*  用法 zrank key member
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 3 two
    (integer) 1
    127.0.0.1:6379> zrank key1 two
    1)1

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zrangebyscore",zrangebyscoreCommand,-4,0,NULL,1,1,1}
    }
    
    
    1.查找键是否存在并且是否是sortset数据类型
    2.查找对应的元素
    3.元素不存在返回空
    4.查询元素的分数，以及其分数的索引
    
    
    /** ** ** t_zset.c **/
    
    void zrankCommand(redisClient *c) { 
        zrankGenericCommand(c, 0);
    }
    
    
    void zrankGenericCommand(redisClient *c, int reverse) { 
        robj *o;
        zset *zs;
        zskiplist *zsl;
        dictEntry *de;
        unsigned long rank;
        double *score;
    	//1.查找键是否存在并且是否是sortset数据类型
        if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
            checkType(c,o,REDIS_ZSET)) return;
    
        zs = o->ptr;
        zsl = zs->zsl;
    	//2. 查找对应的元素
        c->argv[2] = tryObjectEncoding(c->argv[2]);
        de = dictFind(zs->dict,c->argv[2]);
    	//3. 元素不存在返回空
        if (!de) { 
            addReply(c,shared.nullbulk);
            return;
        }
    	//4. 查询元素的分数，以及其分数的索引
        score = dictGetEntryVal(de);
        rank = zslGetRank(zsl, *score, c->argv[2]);
        if (rank) { 
            if (reverse) { 
                addReplyLongLong(c, zsl->length - rank);
            } else { 
                addReplyLongLong(c, rank-1);
            }
        } else { 
            addReply(c,shared.nullbulk);
        }
    }

### zrem ###

*  解释

从有序集合中删除指定元素，如果元素不存在，则忽略。  
返回值：返回成功删除元素的给个数，如果元素不存在，返回0

*  用法 zrem key member \[member\]
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 3 two
    (integer) 1
    127.0.0.1:6379> zrank key1 two
    1)1
    127.0.0.1:6379> zrem key1 one
    (integer)1

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zrem",zremCommand,3,0,NULL,1,1,1}
    }
    
    1.查找键是否存在并且是否是sortset数据类型	
    2. 查找元素的对象，如果为null,返回0
    3. 从skiplist中删除
    
    void zremCommand(redisClient *c) { 
        robj *zsetobj;
        zset *zs;
        dictEntry *de;
        double curscore;
        int deleted;
    	//1.查找键是否存在并且是否是sortset数据类型 
        if ((zsetobj = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
            checkType(c,zsetobj,REDIS_ZSET)) return;
    
        zs = zsetobj->ptr;
        c->argv[2] = tryObjectEncoding(c->argv[2]);
    	//2. 查找元素的对象，如果为null,返回0
        de = dictFind(zs->dict,c->argv[2]);
        if (de == NULL) { 
            addReply(c,shared.czero);
            return;
        }
        //3. 从skiplist中删除
        curscore = *(double*)dictGetEntryVal(de);
        deleted = zslDelete(zs->zsl,curscore,c->argv[2]);
        redisAssert(deleted != 0);
    
        /* Delete from the hash table */
        dictDelete(zs->dict,c->argv[2]);
        if (htNeedsResize(zs->dict)) dictResize(zs->dict);
        if (dictSize(zs->dict) == 0) dbDelete(c->db,c->argv[1]);
        touchWatchedKey(c->db,c->argv[1]);
        server.dirty++;
        addReply(c,shared.cone);
    }

### zscore ###

*  解释
    
    返回元素的分数，如果键或者元素不存在，返回nil
 *  用法 zscore key member
 *  示例

127.0.0.1:6379> zadd key1 1 one
    (integer) 1
    127.0.0.1:6379> zadd key1 3 two
    (integer) 1
    127.0.0.1:6379> zscore key1 two
    "3"

*  源码

/** ** redis.c **/ 
    struct redisCommand readonlyCommandTable[] = { 
     { "zscore",zscoreCommand,3,0,NULL,1,1,1}
    }
    
    1.查找键是否存在并且是否是sortset数据类型	
    2. 查询元素对应的对象
    3. 如果元素不存在返回null
    4.元素存在，返回其分数
    
    void zscoreCommand(redisClient *c) { 
        robj *o;
        zset *zs;
        dictEntry *de;
    	//1.查找键是否存在并且是否是sortset数据类型 
        if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
            checkType(c,o,REDIS_ZSET)) return;
    
        zs = o->ptr;
        c->argv[2] = tryObjectEncoding(c->argv[2]);
    	//2. 查询元素对应的对象
        de = dictFind(zs->dict,c->argv[2]);
        if (!de) { 
    	//3. 如果元素不存在返回null
            addReply(c,shared.nullbulk);
        } else { 
    	//4.元素存在，返回其分数
            double *score = dictGetEntryVal(de);
    
            addReplyDouble(c,*score);
        }
    }

## 内部编码 ##

skiplist 跳表

## 使用场景 ##

### 场景一: 排行榜 ###

用户为爱豆打榜，member存爱豆的id,用户每次打榜操作，增加爱豆id对应的score

### 场景二: 热搜话题热度 ###

每个话题用户搜索，发布话题内容，对应的话题id的分数增加一定值。
    每次返回前十个分数最高的话题