我们再来学习如何从跳跃表中查询数据，跳跃表本质上是一个链表，但它允许我们像数组一样定位某个索引区间内的节点，并且与数组不同的是，跳跃表允许我们将头节点L0层的前驱节点（即跳跃表分值最小的节点）zsl->header.level[0].forward当成索引0的节点，尾节点zsl->tail（跳跃表分值最大的节点）当成索引zsl->length-1的节点，索引按分值从小到大递增查询；也允许我们将尾节点当成索引0的节点，头节点L0层的前驱节点当做索引zsl->length-1的节点，索引按分值从大到小递增查询。当我们调用下面的方法按照索引区间来查询时，会把我们的索引转换成跨度，然后查找落在跨度的第一个节点，之后根据reverse（逆向状态）决定是要正向查询还是逆向查询。

假设我们要进行正向查询（即：索引按分值从小到大递增查询），给定的索引区间是[0,2]，那么我们要找到跨度为1的节点，然后从跨度为1的节点L0层逐个递进，直到停留在跨度为3的节点，头节点L0层的前驱节点zsl->header.level[0].forward在跳跃表的索引为0，跨度为1，在跨度为1的节点从L0层逐个递进，一直递进到跨度为3的节点，这样便完成了索引区间[0,2]的查询。如果我们要进行逆向查询（即：索引按分值从大到小递增查询），索引区间依旧是[0,2]，那么我们要找到跨度为跨度为zsl->length-0=zsl->length的节点，那自然是尾节点，找到跨度区间的第一个节点后，我们通过backward指针逐个后退，一直后退到跨度为zsl->length-2的节点，如此便完成查询。

void zrangeGenericCommand(client *c, int reverse) {
    robj *key = c->argv[1];
    robj *zobj;
    int withscores = 0;
    long start;
    long end;
    long llen;
    long rangelen;
 
    //读取起始索引和终止索引，如果存在一个索引读取失败，则退出
    if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != C_OK) ||
        (getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != C_OK))
        return;
    //判断是否要返回分值
    if (c->argc == 5 && !strcasecmp(c->argv[4]->ptr, "withscores")) {
        withscores = 1;
    } else if (c->argc >= 5) {
        addReply(c, shared.syntaxerr);
        return;
    }
    //判断key是否存在，如果不存在则退出，如果存在但类型不为ZSET也退出。
    if ((zobj = lookupKeyReadOrReply(c, key, shared.emptyarray)) == NULL
        || checkType(c, zobj, OBJ_ZSET))
        return;
 
    /*
     * Sanitize indexes.
     * 审查索引，这里主要针对传入索引为负数的情况，大家都知道，如果一个
     * 跳跃表的节点个数为N，我们要从起始节点查询到末尾节点，可以用[0,N-1]
     * 或者[0,-1]，当传入的end<0时，这里会重新规正end的索引，llen为zset的长度，
     * 因此查询[0,-1]，这里会规正为[0,N-1]。同理，start也会被规正，如果我们查询
     * [-5,-3]，即代表查询有序集合倒数第5个节点至倒数第三个节点，前提是N>=5这个
     * 查询才有意义。如果我们的起始索引传入的是一个绝对值>N的负数，那么llen + start的
     * 结果也为负数，如果判断start<0，则start会被规正为0。
     * */
    llen = zsetLength(zobj);
    if (start < 0) start = llen + start;
    if (end < 0) end = llen + end;
    if (start < 0) start = 0;
 
    /*
     * Invariant: start >= 0, so this test will be true when end < 0.
     * The range is empty when start > end or start >= length.
     * 如果起始索引大于终止索引，或者起始索引大于等于有序集合节点数量，则直接
     * 返回空数组。
     * */
    if (start > end || start >= llen) {
        addReply(c, shared.emptyarray);
        return;
    }
    //如果判断终止索引大于等于节点数，则规整为llen-1
    if (end >= llen) end = llen - 1;
    //计算要返回的节点数
    rangelen = (end - start) + 1;
    //……
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        //压缩列表逻辑……
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        zset *zs = zobj->ptr;
        zskiplist *zsl = zs->zsl;
        zskiplistNode *ln;
        sds ele;
 
        /*
         * Check if starting point is trivial, before doing log(N) lookup.
         * 这里会根据给定的开始索引，查找该索引对应的节点，并将ln指向该节点。
         * 需要注意的一点是：平常我们都认为header.level[0].forward指向的节点，在跳跃表
         * 中的索引为0，但有时候跳跃表的末尾节点zsl->tail的索引值也有可能为0，这里就要提到
         * 逆向查询。
         * 当我们使用ZRANGE key min max [WITHSCORES]命令查询时，成员的位置是按照其分值
         * 从小到大来排序，这时候header.level[0].forward的索引值为0，
         * header.level[0].forward.level[0].forward的索引值为1。而zls->tail的索引值
         * 为zls->length-1。
         * 当我们使用ZREVRANGE key start stop [WITHSCORES]命令查询时，成员的位置是按照
         * 其分值从大到小来排序，这时候zls->tail的索引值为0，header.level[0].forward的
         * 索引值为zls->length-1，header.level[0].forward.level[0].forward的索引值为
         * zls->length-2。当reverse为1时，本次查询即为逆向查询。
         * 我们注意到不管是if还是else分值，只要start>0，最终都会执行zslGetElementByRank()
         * 将ln定位到起始节点。当start为0时，如果是逆向查询，则索引0的位置是尾节点zsl->tail，
         * 如果是正向查询，索引0的位置则是zsl->header->level[0].forward。
         * 那么(llen - start)和(start + 1)又代表什么含义呢？为什么zslGetElementByRank()
         * 可以根据这两个公式的计算结果，定位到索引对应的节点呢？其实这两个公式计算的是跨度，而
         * zslGetElementByRank()则是根据给定的跳跃表和跨度查找节点而已。
         * 如果是正常查询，假设起始索引为0，则跨度为start(0)+1=1，刚好为头节点L0层到达第一个节点的
         * 跨度为1；如果起始索引为1，则跨度为start(1)+1=2，刚好是头节点到达索引值为1的节点的跨度。
         * 如果是逆向查询，索引值为0代表尾节点，而llen-start(0)=llen为头节点到达尾节点的跨度；同理，
         * 倒数第二个节点的索引值为1，头节点到达倒数第二个节点的跨度为llen-start(1)=llen-1。
         * */
        if (reverse) {
            ln = zsl->tail;
            if (start > 0)
                ln = zslGetElementByRank(zsl, llen - start);
        } else {
            ln = zsl->header->level[0].forward;
            if (start > 0)
                ln = zslGetElementByRank(zsl, start + 1);
        }
        //定位到起始节点后，根据逆向状态，不为0时后退查询(ln-backward)，为0时递进查询(ln->level[0].forward)
        while (rangelen--) {
            serverAssertWithInfo(c, zobj, ln != NULL);
            ele = ln->ele;
            if (withscores && c->resp > 2) addReplyArrayLen(c, 2);
            addReplyBulkCBuffer(c, ele, sdslen(ele));
            if (withscores) addReplyDouble(c, ln->score);
            ln = reverse ? ln->backward : ln->level[0].forward;
        }
    } else {
        serverPanic("Unknown sorted set encoding");
    }
}

查找到跨度对应的节点，查找到跨度对应的节点，则在<1>处返回，如果我们传入的跨度大于头节点到尾节点的跨度，则返回NULL。

/*
 * Finds an element by its rank. The rank argument needs to be 1-based.
 * */
zskiplistNode *zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
    zskiplistNode *x;
    unsigned long traversed = 0;//累计跨度
    int i;
 
    x = zsl->header;
    /*
     * 从头节点的最高层出发，如果基于当前层能够递进到前一个节点，
     * 则把当前节点的跨度加到traversed。
     */
    for (i = zsl->level - 1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) <= rank) {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        /*
         * 如果累计跨度与调用方传入的跨度相等，则代表x已经前进到调用方
         * 所要求达到的跨度的节点，返回x。
         */
        if (traversed == rank) {
            return x;//<1>
        }
    }
    //如果传入的跨度大于头节点到尾节点的跨度，则返回NULL。
    return NULL;
}

跳跃表除了可以根据索引区间来查询，还可以根据分值区间来查询，这里我们又见到了结构体zrangespec。当我们需要判断一个节点是否落在我们指定的分值区间内，需要调用zslValueGteMin()和zslValueLteMax()，当传入一个指定的分值和区间，zslValueGteMin()和zslValueLteMax()的结果不为0，则表明节点落在分值区间内。此外，这两个方法还可以判断一个跳跃表是否和区间有交集，比如调用zslValueGteMin()时，传入尾节点（跳跃表分值最大的节点）及一个指定区间，如果尾节点没有落在指定区间，代表此区间都大于尾节点，此时我们不需要遍历跳跃表即可返回一个空数组，告诉客户端在指定区间内找不到任何节点；同理，调用zslValueLteMax()时传入头节点L0层的前驱节点（跳跃表分值最小节点）没有落在区间内，则表明区间小于跳跃表，同样不需要遍历跳跃表即可返回空数组给客户端，告诉客户端在指定区间内找不到任何节点。

/*
 * Struct to hold a inclusive/exclusive range spec by score comparison.
 * 此结构体用于表示一个指定区间，minex为0时表示在进行最小值比较时，要包含最小值本身
 * 同理maxex为0时表示进行最大值比较时，要包含最大值本身。
 * 比如：min=2,max=9
 * 当minex=0,maxex=0时，区间为:[2,9]
 * 当minex=1,maxex=0时，区间为:(2,9]
 * 当minex=0,maxex=1时，区间为:[2,9)
 * 当minex=1,maxex=1时，区间为:(2,9)
 * */
typedef struct {
    double min, max;
    int minex, maxex; /* are min or max exclusive? */
} zrangespec;
 
/*
 * 如果spec->minex不为0，返回分值是否大于区间最小值的比较结果，
 * 为0则返回分值是否大于等于区间最小值的比较结果。
 * 如果传入一个跳跃表尾节点的分值zsl->tail.score(即：跳跃表最大分值)和区间返回结果为0，
 * 则表示跳跃表和区间没有交集。
 * 这里分两种情况：
 * spec->minex不为0：区间要查询分值大于spec->min的元素，
 * zsl->tail.score<=spec->min代表跳跃表最大分值小于等于min，返回结果为0。
 * spec->minex为0：区间要查询分值大于等于spec->min的元素，
 * zsl->tail.score<spec->min代表跳跃表最大分值小于min，返回结果为0。
 */
int zslValueGteMin(double value, zrangespec *spec) {
    return spec->minex ? (value > spec->min) : (value >= spec->min);
}
 
/*
 * 如果spec->maxex不为0，返回分值是否小于区间最大值的比较结果，为0则返回分值
 * 是否小于等于区间最大值的比较结果。
 * 如果传入一个跳跃表头节点L0层指向节点的分值
 * zsl->header.level[0].forward.score(即：跳跃表最小分值)和
 * 区间返回结果为0，则表示跳跃表和区间没有交集。
 * 这里分两种情况：
 * spec->maxex不为0：区间要查询分值小于spec->max的元素，
 * zsl->header.level[0].forward.score>=spec->max代表跳跃表最小分值大于等于区间
 * 最大分值，返回结果为0。
 * spec->maxex为0：区间要查询分值小于等于spec->max的元素，
 * zsl->header.level[0].forward.score>spec->max代表跳跃表最小分值大于区间最大分值，
 * 返回结果为0。
 */
int zslValueLteMax(double value, zrangespec *spec) {
    return spec->maxex ? (value < spec->max) : (value <= spec->max);
}

在真正根据分值区间查询跳跃表前，会校验区间是否有效，如果我们输入一个区间[a,b]，但a>b，那么这个区间肯定是无效区间，无须遍历跳跃表；如果a=b，如果区间的开闭状态出现：(a,b)、(a,b]、[a,b)这三种情况，也是无效区间，只有[a,b]才会去查询节点，表示需要查找分值为a(或者b)的节点。当校验完区间是有效后，还会调用zslValueGteMin()和zslValueLteMax()判断跳跃表和区间是否存在交集，即区间是否整体大于跳跃表或整体小于跳跃表，如果出现这两种情况则表明区间和跳跃表无交集，也就不需要遍历。

/*
 * Returns if there is a part of the zset is in range.
 * 判断跳跃表和区间是否存在交集
 * */
int zslIsInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
 
    /*
     * Test for ranges that will always be empty.
     * 校验区间范围是否有效，无效则返回0表示查询结果为空：
     * 1.如果最小值大于最大值，则无效。
     * 2.如果最小值等于最大值，且区间为：(min,max)、(min,max]、[min,max)则无效。
     * */
    if (range->min > range->max ||
        (range->min == range->max && (range->minex || range->maxex)))
        return 0;
    /*
     * 如果尾节点不为NULL，则把跳跃表最大分值zsl->tail.score与区间比较，
     * 如果range->minex不为0，则查询分值大于range->min的元素，如果跳跃表
     * 最大分值zsl->tail.score小于等于range->min，则表示跳跃表和区间没有交集，
     * 无须遍历跳跃表查询；同理如果range->minex为0，则查询分值大于等于range->min
     * 的元素，如果zsl->tail.score小于range->min，则表示跳跃表和区间没有交集，
     * 也无须遍历跳跃表查询。
     */
    x = zsl->tail;
    if (x == NULL || !zslValueGteMin(x->score, range))
        return 0;
    /*
     * 如果头节点L0层的前驱节点不为NULL，则把跳跃表最小分值zsl->header->level[0].forward.score
     * 与区间比较，如果range->maxex不为0，则查询分值小于range->maxex的元素，如果跳跃表最小
     * 分值zsl->header->level[0].forward.score大于等于range->max，则表示跳跃表和区间没有交集，
     * 无须遍历跳跃表查询；同理如果range->maxex为0，则查询分值小于等于range->maxex的元素，如果跳跃表
     * 最小分值zsl->header->level[0].forward.score大于range->maxex，则表示跳跃表和区间没有交集，
     * 也无须遍历跳跃表查询。
     */
    x = zsl->header->level[0].forward;
    if (x == NULL || !zslValueLteMax(x->score, range))
        return 0;
    //跳跃表和区间存在交集，需要遍历跳跃表查询。
    return 1;
}

跳跃表允许我们根据分值区间进行正向查询（分值从小到大）或逆向查询（分值从大到小），如果是正向查询，则调用zslFirstInRange()方法，先判断跳跃表和指定区间是否存在交集，如果存在则查找指定区间内的分值最小的节点并返回。

/*
 * Find the first node that is contained in the specified range.
 * Returns NULL when no element is contained in the range.
 * 查找落在指定区间的第一个节点，如果没有元素落在这个区间则返回NULL。
 * */
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;
 
    /*
     * If everything is out of range, return early.
     * 如果跳跃表和区间没有交集则无须遍历，直接返回NULL。
     * */
    if (!zslIsInRange(zsl, range)) return NULL;
    //从头节点的最高层开始遍历
    x = zsl->header;
    for (i = zsl->level - 1; i >= 0; i--) {
        /*
         * Go forward while *OUT* of range.
         * 如果x->level[i].forward不为NULL，根据其分值x->level[i].forward->score和
         * range->minex判断前驱节点是否能前进。
         * 这里分两种情况：
         * range->minex不为0：判断前驱节点的分值是否大于range->min，如果小于等于的话
         * expression=zslValueGteMin(x->level[i].forward->score, range)为0，
         * 代表需要前进，找到大于min的节点，而!expression为1，while条件成立，x会
         * 前进到它的前驱节点。当x的前驱节点的分值大于min，就会停止循环，x会停留在区间内
         * 第一个节点的后继节点。
         * range->minex为0：判断前驱节点的分值是否大于等于range->min，如果小于的话，
         * expression=zslValueGteMin(x->level[i].forward->score, range)，expression为0，
         * 需要前进，找到大于等于min的节点，而!expression为1，while条件成立，x会
         * 前进到它的前驱节点。当x的前驱节点的分值大于等于min，就会停止循环，x会停留在区间内
         * 第一个节点的后继节点。
         * */
        while (x->level[i].forward &&
               !zslValueGteMin(x->level[i].forward->score, range))
            x = x->level[i].forward;
    }
 
    /*
     * This is an inner range, so the next node cannot be NULL.
     * 上面的循环会让x停留在区间内第一个节点的后继节点，为了达到区间内的
     * 第一个节点，x要在L0层前进到它的前驱节点。
     * */
    x = x->level[0].forward;
    serverAssert(x != NULL);
 
    /*
     * Check if score <= max.
     * range->maxex不为0：如果区间内第一个节点的分值大于等于spec->max，
     * expression=zslValueLteMax(x->score, range)，expression结果为0
     * !expression为1，表示查询异常，返回NULL。
     * range->maxex为0：如果区间内第一个节点的分值大于spec->max，
     * 则expression=zslValueLteMax(x->score, range)，expression结果为0
     * !expression为1，表示查询异常，返回NULL。
     * */
    if (!zslValueLteMax(x->score, range)) return NULL;
    return x;
}

如果要进行逆向查询，则调用zslLastInRange()，这里同样先判断跳跃表是否和区间存在交集，只有存在交集才会进行下一步的判断，查找指定区间内分值最大的节点并返回。

/*
 * Find the last node that is contained in the specified range.
 * Returns NULL when no element is contained in the range.
 * 查找落在指定区间的最后一个节点，如果没有元素落在这个区间则返回NULL。
 * */
zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;
 
    /*If everything is out of range, return early.*/
    if (!zslIsInRange(zsl, range)) return NULL;<br>
    //从头节点的最高层开始遍历
    x = zsl->header;
    for (i = zsl->level - 1; i >= 0; i--) {
        /*
         * Go forward while *IN* range.
         * 根据区间range和前驱节点的分值判断是否前进，如果x->level[i].forward
         * 不为NULL，根据range->maxex判断前驱节点是否能前进。
         * 这里分两种情况：
         * 如果range->maxex不为0，且前驱节点的分值小于range->max，则可以前进。
         * 如果range->maxex为0，且前驱节点的分值小于等于range->max，则可以前进。
         * */
        while (x->level[i].forward &&
               zslValueLteMax(x->level[i].forward->score, range))
            x = x->level[i].forward;
    }
 
    /* This is an inner range, so this node cannot be NULL. */
    serverAssert(x != NULL);
 
    /*
     * Check if score >= min.
     * 如果range->minex不为0，x的分值小于或等于range->min，代表查询出现异常，则返回NULL。
     * 如果range->minex为0，x的分值小于range->min，代表查询出现异常，则返回NULL。
     * */
    if (!zslValueGteMin(x->score, range)) return NULL;
    return x;
}

在了解完上面的内容后，下面我们要步入正题：如何根据分值区间进行正向或逆向查找节点。在下面代码<1>处，会根据逆向状态选择ln是指向区间分值最大的节点，或是分值最小的节点。在定位到起始节点后，会在<2>处的while循环对节点进行偏移，如果到达偏移位置后的ln不为NULL，则会进入<3>处的while循环，查找分值落在区间内的节点，这里会根据逆向状态是否不为0，决定是用backward指针后退，还是向L0层的前驱节点递进，一直到分值不落在区间内跳出while循环，或者ln为NULL，又或者limit为0结束while循环。如果我们没有指定偏移（offset）和返回数量（limit），则不会进行偏移，limit默认值为-1，limit--永远不为0，这里会返回落在区间内的所有节点，能结束while循环只有遇到分值不落在区间内的节点，或者是ln为NULL。

/* This command implements ZRANGEBYSCORE, ZREVRANGEBYSCORE. */
void genericZrangebyscoreCommand(client *c, int reverse) {
    zrangespec range;//指定区间
    robj *key = c->argv[1];
    robj *zobj;
    long offset = 0, limit = -1;//偏移和结果返回数量
    int withscores = 0;
    unsigned long rangelen = 0;
    void *replylen = NULL;
    int minidx, maxidx;
 
    /*
     * Parse the range arguments.
     * 解析范围参数
     * ZRANGEBYSCORE key min max和ZREVRANGEBYSCORE key max min两个命令
     * 都是此函数实现的，如果客户端输入的命令为ZRANGEBYSCORE，则reverse为0，按
     * 从小到大查找分值及元素，分值小的在前，分值大的在后。如果客户端输入的命令为
     * ZREVRANGEBYSCORE，则reverse不为0，按从大到小查找分值及元素，分值大的在前，
     * 分值小的在后。
     *
     * */
    if (reverse) {
        /* Range is given as [max,min] */
        maxidx = 2;
        minidx = 3;
    } else {
        /* Range is given as [min,max] */
        minidx = 2;
        maxidx = 3;
    }
 
    if (zslParseRange(c->argv[minidx], c->argv[maxidx], &range) != C_OK) {
        addReplyError(c, "min or max is not a float");
        return;
    }
 
    /*
     * Parse optional extra arguments. Note that ZCOUNT will exactly have
     * 4 arguments, so we'll never enter the following code path.
     * 遍历可选参数，这里会判断是否要返回分值(withscores)，是否要对查询结果进行偏移(offset)和数量(limit)的限制
     * */
    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")) {
                if ((getLongFromObjectOrReply(c, c->argv[pos + 1], &offset, NULL)
                     != C_OK) ||
                    (getLongFromObjectOrReply(c, c->argv[pos + 2], &limit, NULL)
                     != C_OK)) {
                    return;
                }
                pos += 3;
                remaining -= 3;
            } else {
                addReply(c, shared.syntaxerr);
                return;
            }
        }
    }
 
    /*
     * Ok, lookup the key and get the range
     * 如果key所对应的zobj不存在，或者zobj的类型不为zset，则退出。
     * */
    if ((zobj = lookupKeyReadOrReply(c, key, shared.emptyarray)) == NULL ||
        checkType(c, zobj, OBJ_ZSET))
        return;
 
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        //压缩列表流程...
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {//zobj类型为跳跃表
        zset *zs = zobj->ptr;
        zskiplist *zsl = zs->zsl;
        zskiplistNode *ln;
 
        /*
         * If reversed, get the last node in range as starting point.
         * 如果是逆向查询，ln会指向区间分值最大的节点，如果是正向查询，ln则指向区间分值最小的节点。
         * */
        if (reverse) {
            ln = zslLastInRange(zsl, &range);
        } else {
            ln = zslFirstInRange(zsl, &range);
        }
 
        /*
         * No "first" element in the specified interval.
         * 如果没有落在区间的开始节点则退出
         * */
        if (ln == NULL) {
            addReply(c, shared.emptyarray);
            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 */
        replylen = addReplyDeferredLen(c);
 
        /*
         * If there is an offset, just traverse the number of elements without
         * checking the score because that is done in the next loop.
         * <2>如果有偏移量，则根据reverse状态选择是后退还是递进，以达到偏移量。
         * 如果客户端有传入偏移，则offset不为0，这里会循环到offset为0或ln为NULL时跳出循环。
         * 否则offset默认值为0，不会进入此循环。
         * */
        while (ln && offset--) {
            if (reverse) {
                ln = ln->backward;
            } else {
                ln = ln->level[0].forward;
            }
        }
        /*
         * <3>如果客户端有传入偏移和数量，则limit不为0，此时会根据reverse状态后退或者前进至
         * ln为NULL或者limit为0，否则limit默认值为-1，limit--永远为true(注：只要limit
         * 不为0，则永远为true，即便是负数)，这里就会循环到ln为NULL时，获取所有分值符合区间
         * 节点的。
         * 除了limit为0，或者ln为NULL会跳出while循环，在<4>处还会根据reverse状态判断分值是否在区间，
         * 如果不在则跳出循环，如果分值符合区间，还会在<5>处根据reverse状态选择是后退到后一个节点(ln->backward)，
         * 还是前进到前一个节点(ln->level[0].forward)。
         */
        while (ln && limit--) {
            /*Abort when the node is no longer in range.*/
            if (reverse) {//<4>
                if (!zslValueGteMin(ln->score, &range)) break;
            } else {
                if (!zslValueLteMax(ln->score, &range)) break;
            }
 
            rangelen++;
            if (withscores && c->resp > 2) addReplyArrayLen(c, 2);
            addReplyBulkCBuffer(c, ln->ele, sdslen(ln->ele));
            if (withscores) addReplyDouble(c, ln->score);
 
            /* Move to next node */
            if (reverse) {//<5>
                ln = ln->backward;
            } else {
                ln = ln->level[0].forward;
            }
        }
    } else {
        serverPanic("Unknown sorted set encoding");
    }
 
    if (withscores && c->resp == 2) rangelen *= 2;
    setDeferredArrayLen(c, replylen, rangelen);
}

最后，我们要了解如何获取一个元素在跳跃表中的索引，其实这里面的逻辑也是非常的简单，我们先从字典上获取节点的分值，然后根据分值及元素获取其在跳跃表中的索引，这里依旧支持正向查询或逆向查询，如果是正向查询，分值越小，索引越小，如果分值相等，则元素越小，索引越小；如果是逆向查询，则分值越大，索引越小，如果分值相等，则元素越大，索引越小。

/* Given a sorted set object returns the 0-based rank of the object or
 * -1 if the object does not exist.
 * 返回元素在有序集合中的索引，如果返回-1则代表元素不在有序集合内。
 *
 * For rank we mean the position of the element in the sorted collection
 * of elements. So the first element has rank 0, the second rank 1, and so
 * forth up to length-1 elements.
 * 在跳跃表中第一个元素的索引为0，第二个元素索引为1，以此类推，最后一个元素索引为length-1。
 *
 * If 'reverse' is false, the rank is returned considering as first element
 * the one with the lowest score. Otherwise if 'reverse' is non-zero
 * the rank is computed considering as element with rank 0 the one with
 * the highest score.
 * 如果reverse为0，跳跃表索引从分值最小的节点开始，即zsl->header.level[0].forward索引为0、
 * zsl->header.level[0].forward.level[0].forward索引为1，zsl->tail索引为zsl-length-1；
 * 如果reverse不为0，跳跃表索引从分值最大的节点开始，即zsl->tail索引为0，zsl->tail.backward索引
 * 为1，zsl->header.level[0].forward索引为zsl->length-1
 * */
long zsetRank(robj *zobj, sds ele, int reverse) {
    unsigned long llen;
    unsigned long rank;
 
    llen = zsetLength(zobj);
 
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        //压缩列表逻辑……
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        zset *zs = zobj->ptr;
        zskiplist *zsl = zs->zsl;
        dictEntry *de;
        double score;
 
        de = dictFind(zs->dict, ele);
        if (de != NULL) {
            /*
             * 如果元素存在在跳跃表上，则获取元素的分支，并根据
             * 分支判断其在跳跃表中的跨度，根据跨度计算节点在跳跃表
             * 中的索引。
             * 如果是正向查询(reverse为0)，则索引为跨度(rank)-1。
             * 如果是逆向查询(reverse不为0)，则索引为跳跃表长度(zsl->length)-跨度(rank)。
             */
            score = *(double *) dictGetVal(de);
            rank = zslGetRank(zsl, score, ele);
            /* Existing elements always have a rank. */
            serverAssert(rank != 0);
            if (reverse)
                return llen - rank;
            else
                return rank - 1;
        } else {//如果元素不在跳跃表上，则返回-1
            return -1;
        }
    } else {
        serverPanic("Unknown sorted set encoding");
    }
}

获取完分值后，需要定位节点在跳跃表中的跨度，然后根据逆向状态及跨度，计算节点在跳跃表中的索引。

/* Find the rank for an element by both score and key.
 * Returns 0 when the element cannot be found, rank otherwise.
 * Note that the rank is 1-based due to the span of zsl->header to the
 * first element.
 * 根据给定的分支和元素查找其节点在跳跃表中的跨度，返回0代表节点不存在。
 * */
unsigned long zslGetRank(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *x;
    unsigned long rank = 0;
    int i;
    //从头节点最高层遍历，如果能前进到前一个节点，则把当前节点的跨度加到rank上
    x = zsl->header;
    for (i = zsl->level - 1; i >= 0; i--) {
        while (x->level[i].forward &&
               (x->level[i].forward->score < score ||
                (x->level[i].forward->score == score &&
                 sdscmp(x->level[i].forward->ele, ele) <= 0))) {
            rank += x->level[i].span;
            x = x->level[i].forward;
        }
 
        /*
         * x might be equal to zsl->header, so test if obj is non-NULL
         * x可能停留在头节点，此处判断是保证节点的元素不为NULL。
         * */
        if (x->ele && sdscmp(x->ele, ele) == 0) {
            return rank;
        }
    }
    return 0;
}

至此，笔者和大家一起学习了Redis跳跃表的是如何插入节点、删除节点、更新节点以及如何对跳跃表中的节点进行不同维度（索引、分值）的查询。跳跃表是一种应用相当广泛的数据结构，很多场景下人们都用跳跃表代替B-Tree，因为跳跃表和B-Tree有着一样的查询时间复杂度O(logN)，但跳跃表的实现却比B-Tree简单很多。而Redis正是借助了跳跃表的思路实现了有序集合，使得很多需要存储、排序海量数据的业务得以实现。

当然，由于笔者的时间精力有限，这里并没有完全介绍所有跳跃表命令的相关实现，但笔者相信能看到这里的人，基本已经掌握了跳跃表的整体脉络。