Redis 中集合操作的实现方法

Redis 是一种高性能的 NoSQL 数据库，它提供了多种数据结构来满足不同的业务需求。其中集合是一种常用的数据结构，它可以用来存储一组不重复的元素。在本文中，我们将介绍 Redis 中集合操作的实现方法，并提供示例代码和指导意义。

集合操作的基本命令

Redis 中集合操作的基本命令包括以下几个：

• SADD：添加一个或多个元素到集合中
• SREM：从集合中移除一个或多个元素
• SMEMBERS：返回集合中所有元素
• SISMEMBER：判断一个元素是否存在于集合中
• SCARD：返回集合中元素的数量
• SUNION：返回多个集合的并集
• SINTER：返回多个集合的交集
• SDIFF：返回两个集合的差集

这些命令可以通过 Redis 的客户端或者 API 来使用。以下是一个使用 Node.js Redis 客户端的示例代码：

// www.javascriptcn.com code example
const redis = require('redis');
const client = redis.createClient();

client.sadd('myset', 'foo', 'bar', 'baz', (err, res) => {
  console.log(res); // 3
});

client.smembers('myset', (err, res) => {
  console.log(res); // ['foo', 'bar', 'baz']
});

client.sismember('myset', 'foo', (err, res) => {
  console.log(res); // 1
});

client.scard('myset', (err, res) => {
  console.log(res); // 3
});

client.srem('myset', 'foo', (err, res) => {
  console.log(res); // 1
});

client.sadd('myset2', 'bar', 'baz', 'qux', (err, res) => {
  console.log(res); // 3
});

client.sunion('myset', 'myset2', (err, res) => {
  console.log(res); // ['bar', 'baz', 'qux']
});

client.sinter('myset', 'myset2', (err, res) => {
  console.log(res); // ['bar', 'baz']
});

client.sdiff('myset', 'myset2', (err, res) => {
  console.log(res); // ['foo']
});

集合操作的实现方法

Redis 中的集合是通过哈希表实现的，每个元素都是哈希表中的一个键值对，其中键是元素的值，值是固定的空值（称为“哨兵”）。这种实现方法可以保证集合中的元素不重复，而且添加、删除、查找等操作的时间复杂度都是 O(1)。

下面是 Redis 中集合操作的实现方法的详细说明：

SADD

SADD 命令的实现方法很简单，就是在哈希表中添加一个键值对。如果该键已经存在，那么不做任何操作。

// www.javascriptcn.com code example
int saddCommand(client *c) {
    robj *set;
    int j, added = 0;

    // 获取或创建集合对象
    if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,set,OBJ_SET)) return C_ERR;

    // 添加元素
    for (j = 2; j < c->argc; j++) {
        if (setTypeAdd(set,c->argv[j])) added++;
    }

    // 发送回复
    if (added) {
        signalModifiedKey(c,c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_SET,"sadd",c->argv[1],c->db->id);
    }
    server.dirty += added;
    addReplyLongLong(c,added);
    return C_OK;
}

SREM

SREM 命令的实现方法也很简单，就是在哈希表中删除一个键值对。如果该键不存在，那么不做任何操作。

// www.javascriptcn.com code example
int sremCommand(client *c) {
    robj *set;
    int j, deleted = 0;

    // 获取集合对象
    if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,set,OBJ_SET)) return C_ERR;

    // 删除元素
    for (j = 2; j < c->argc; j++) {
        if (setTypeRemove(set,c->argv[j])) {
            deleted++;
            if (setTypeSize(set) == 0) {
                dbDelete(c->db,c->argv[1]);
                break;
            }
        }
    }

    // 发送回复
    if (deleted) {
        signalModifiedKey(c,c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_SET,"srem",c->argv[1],c->db->id);
        if (setTypeSize(set) == 0) notifyKeyspaceEvent(NOTIFY_GENERIC,"del",c->argv[1],c->db->id);
    }
    server.dirty += deleted;
    addReplyLongLong(c,deleted);
    return C_OK;
}

SMEMBERS

SMEMBERS 命令的实现方法也很简单，就是遍历哈希表中的所有键，并将它们的值作为元素返回。

// www.javascriptcn.com code example
int smembersCommand(client *c) {
    robj *set;

    // 获取集合对象
    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.emptyarray)) == NULL ||
        checkType(c,set,OBJ_SET)) return C_ERR;

    // 遍历哈希表
    addReplyArrayLen(c,setTypeSize(set));
    setTypeIterator *si = setTypeInitIterator(set);
    while (setTypeNext(si) != NULL) {
        addReplyBulk(c,si->entry);
    }
    setTypeReleaseIterator(si);
    return C_OK;
}

SISMEMBER

SISMEMBER 命令的实现方法也很简单，就是在哈希表中查找指定键是否存在。

// www.javascriptcn.com code example
int sismemberCommand(client *c) {
    robj *set;

    // 获取集合对象
    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,set,OBJ_SET)) return C_ERR;

    // 查找元素
    if (setTypeIsMember(set,c->argv[2])) {
        addReply(c,shared.cone);
    } else {
        addReply(c,shared.czero);
    }
    return C_OK;
}

SCARD

SCARD 命令的实现方法也很简单，就是返回哈希表中键值对的数量。

// www.javascriptcn.com code example
int scardCommand(client *c) {
    robj *o;

    // 获取集合对象
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_SET)) return C_ERR;

    // 发送回复
    addReplyLongLong(c,setTypeSize(o));
    return C_OK;
}

SUNION

SUNION 命令的实现方法比较复杂，需要遍历多个哈希表，并将它们的键值对合并到一个新的哈希表中。

// www.javascriptcn.com code example
int sunionCommand(client *c) {
    robj *o, *set, *dstset = createSetObject();
    int i, j;

    // 合并多个集合
    for (i = 1; i < c->argc; i++) {
        o = lookupKeyRead(c->db,c->argv[i]);
        if (o && o->type != OBJ_SET) {
            decrRefCount(dstset);
            addReply(c,shared.wrongtypeerr);
            return C_ERR;
        }
        set = o ? o : &shared.emptyset[c->argv[i]->encoding];
        setTypeUnion(dstset, set);
    }

    // 发送回复
    addReplyArrayLen(c,setTypeSize(dstset));
    setTypeIterator *si = setTypeInitIterator(dstset);
    while (setTypeNext(si) != NULL) {
        addReplyBulk(c,si->entry);
    }
    setTypeReleaseIterator(si);
    decrRefCount(dstset);
    return C_OK;
}

SINTER

SINTER 命令的实现方法与 SUNION 类似，也需要遍历多个哈希表，并将它们的交集合并到一个新的哈希表中。

// www.javascriptcn.com code example
int sinterCommand(client *c) {
    robj *o, *set, *dstset = createSetObject();
    int i, j;

    // 计算多个集合的交集
    for (i = 1; i < c->argc; i++) {
        o = lookupKeyRead(c->db,c->argv[i]);
        if (o && o->type != OBJ_SET) {
            decrRefCount(dstset);
            addReply(c,shared.wrongtypeerr);
            return C_ERR;
        }
        set = o ? o : &shared.emptyset[c->argv[i]->encoding];
        if (i == 1) {
            setTypeInter(dstset, set);
        } else {
            setTypeInter(dstset, set);
            if (setTypeSize(dstset) == 0) break;
        }
    }

    // 发送回复
    addReplyArrayLen(c,setTypeSize(dstset));
    setTypeIterator *si = setTypeInitIterator(dstset);
    while (setTypeNext(si) != NULL) {
        addReplyBulk(c,si->entry);
    }
    setTypeReleaseIterator(si);
    decrRefCount(dstset);
    return C_OK;
}

SDIFF

SDIFF 命令的实现方法与 SINTER 类似，也需要遍历两个哈希表，并将它们的差集合并到一个新的哈希表中。

// www.javascriptcn.com code example
int sdiffCommand(client *c) {
    robj *o, *set, *dstset = createSetObject();
    int i, j;

    // 计算两个集合的差集
    o = lookupKeyRead(c->db,c->argv[1]);
    if (o && o->type != OBJ_SET) {
        decrRefCount(dstset);
        addReply(c,shared.wrongtypeerr);
        return C_ERR;
    }
    set = o ? o : &shared.emptyset[c->argv[1]->encoding];
    setTypeUnion(dstset, set);
    for (i = 2; i < c->argc; i++) {
        o = lookupKeyRead(c->db,c->argv[i]);
        if (o && o->type != OBJ_SET) {
            decrRefCount(dstset);
            addReply(c,shared.wrongtypeerr);
            return C_ERR;
        }
        set = o ? o : &shared.emptyset[c->argv[i]->encoding];
        setTypeDiff(dstset, set);
    }

    // 发送回复
    addReplyArrayLen(c,setTypeSize(dstset));
    setTypeIterator *si = setTypeInitIterator(dstset);
    while (setTypeNext(si) != NULL) {
        addReplyBulk(c,si->entry);
    }
    setTypeReleaseIterator(si);
    decrRefCount(dstset);
    return C_OK;
}

指导意义

Redis 中集合操作的实现方法非常简单，但是它们具有很强的实用性和性能优势。在实际开发中，我们可以将集合作为缓存或者索引来使用，以提高数据访问速度和查询效率。

除了集合，Redis 还提供了多种其他数据结构，如字符串、哈希表、列表和有序集合等，它们都具有不同的特点和用途。在选择数据结构时，我们应该根据实际业务需求来进行选择，并充分发挥 Redis 的性能优势，以提高系统的可用性和稳定性。

来源：JavaScript中文网 ，转载请注明来源 https://www.javascriptcn.com/post/67d0dcdba941bf71341c9dd3