[Redis#13] cpp-redis接口 | set | hash |zset

目录

Set

[1. Sadd 和 Smembers](#1. Sadd 和 Smembers)

[2. Sismember](#2. Sismember)

[3. Scard](#3. Scard)

[4. Spop](#4. Spop)

[5. Sinter](#5. Sinter)

[6. Sinter store](#6. Sinter store)

Hash

[1. Hset 和 Hget](#1. Hset 和 Hget)

[2. Hexists](#2. Hexists)

[3. Hdel](#3. Hdel)

[4. Hkeys 和 Hvals](#4. Hkeys 和 Hvals)

[5. Hmget 和 Hmset](#5. Hmget 和 Hmset)

Zset

[1. Zadd 和 Zrange](#1. Zadd 和 Zrange)

[2. Zcard](#2. Zcard)

[3. Zrem](#3. Zrem)

[4. Zscore](#4. Zscore)

---

cpp-redis 的学习 主要关注于 传入和传出，中间就是对于 redis 对象的接口调用了

1. 接口的相似性：

• sw/redis++ 的接口设计与 Redis 原生命令非常相似，这使得熟悉 Redis 命令的开发者可以快速上手。

2. 参数传递方式：

• 当需要传入多个参数时，有两种方法：

• • 使用容器（如 std::vector 或 std::set）保存参数，并传递容器的迭代器。
  • 直接使用初始化列表 {} 传递参数。

3. 键值对传递：

• 如果需要传递键值对，可以使用 std::pair 来表示，例如 std::pair<std::string, std::string>。

4. 常用 C++ 类型：

• OptionalString：用于接收可能为 nil 的返回值，可以判断是否为空。
• StringView：用于传递只读字符串，但通常直接使用 std::string 即可。
• long long：用于接收整数类型的返回值。
• double：用于 ZSET 中的分数（score）类型。

5. 输出多个变量 ：

• 如果函数需要输出多个变量，应该 传递一个插入迭代器（如 std::inserter 或 std::back_inserter），这样可以将结果直接插入到容器中。

示例

这里给出一个简单的示例来说明如何使用 sw/redis++ 和上述提到的数据类型：

#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <sw/redis++/redis++.h>

using namespace std;
using sw::redis::Redis;

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    // 使用初始化列表添加元素
    redis.sadd("myset", {"apple", "banana", "cherry"});

    // 使用容器添加元素
    set<string> fruits = {"date", "elderberry"};
    redis.sadd("myset", fruits.begin(), fruits.end());

    //输出
    // 获取集合中的所有成员
    vector<string> result;
    auto inserter = back_inserter(result);
    redis.smembers("myset", inserter);//通过插入迭代器

    // 打印
    for (const auto& item : result) {
        cout << item << endl;
    }
    return 0;
}

---

Set

1. Sadd 和 Smembers

此示例展示了如何向集合中添加元素以及如何获取集合中的所有成员。注意，保存 smembers 结果时，使用 std::set 可能更合适，因为集合中的元素是无序且唯一的。

void TestSaddAndSmembers(Redis& redis) {
    // 清空数据库
    redis.flushall();

    // 一次添加一个元素
    redis.sadd("key", "111");

    // 使用初始化列表一次性添加多个元素
    redis.sadd("key", {"222", "333", "444"});

    // 使用迭代器从集合容器中添加多个元素
    std::set<std::string> elems = {"555", "666", "777"};
    redis.sadd("key", elems.begin(), elems.end());

    // 获取并打印集合中的所有元素
    std::set<std::string> result;
    auto it = std::inserter(result, result.end());
    redis.smembers("key", it);

    PrintContainer(result);
}

2. Sismember

这个例子检查给定的元素是否存在于指定的集合中，并输出结果。

void TestSismember(Redis& redis) {
    // 清空数据库
    redis.flushall();

    // 添加一些元素到集合
    redis.sadd("key", {"111", "222", "333", "444"});

    // 检查元素 '555' 是否存在
    bool result = redis.sismember("key", "555");
    std::cout << "result: " << result << std::endl;
}

3. Scard

该示例计算集合中元素的数量，并输出结果。

void TestScard(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 向集合中添加元素
    redis.sadd("key", {"111", "222", "333"});

    // 计算集合大小
    long long result = redis.scard("key");
    std::cout << "result: " << result << std::endl;
}

4. Spop

这里演示了如何随机移除集合中的一个元素，并打印被移除的元素或相应的错误信息。

void TestSpop(Redis& redis) {
    // 清空数据库
    redis.flushall();

    // 向集合中添加元素
    redis.sadd("key", {"111", "222", "333", "444"});

    // 随机移除一个元素
    auto result = redis.spop("key");
    if (result) {
        std::cout << "result: " << result.value() << std::endl;
    } else {
        std::cout << "result 无效!" << std::endl;
    }
}

5. Sinter

此示例说明了如何找到两个集合的交集

void TestSinter(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 向两个不同的集合中添加元素
    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    // 计算两个集合的交集
    std::set<std::string> result;
    auto it = std::inserter(result, result.end());
    redis.sinter({"key1", "key2"}, it);

    // 打印交集结果
    PrintContainer(result);
}

6. Sinter store

本示例展示如何计算两个集合的交集并将结果存储在一个新的集合中，同时打印新集合的大小和内容。

void TestSinterstore(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 向两个不同的集合中添加元素
    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    // 计算两个集合的交集并存储在新的集合 key3 中
    long long len = redis.sinterstore("key3", {"key1", "key2"});
    std::cout << "len: " << len << std::endl;

    // 获取到上述元素
    // 此处用来保存 smembers 的结果, 使用 set 可能更合适. 
    vector<string> result;
    // auto it = std::back_inserter(result);
    // 由于此处 set 里的元素顺序是固定的. 指定一个 result.end() 或者 result.begin() 或者其他位置的迭代器, 都无所谓~~
    auto it = std::inserter(result, result.end());
    redis.smembers("key3", it);

    PrintContainer(result);
}

---

vscode 查找替换 快捷键：

Hash

1. Hset 和 Hget

这个示例演示了如何向哈希中添加字段-值对，并从中获取特定字段的值。

void TestHsetAndHget(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 设置单个字段-值对
    redis.hset("key", "f1", "111");
    // 使用 std::pair 设置另一个字段-值对
    redis.hset("key", std::make_pair("f2", "222"));

    // 批量设置多个字段-值对
    redis.hset("key", {std::make_pair("f3", "333"), std::make_pair("f4", "444")});

    // 使用容器批量设置
    std::vector<std::pair<std::string, std::string>> fields = {
        std::make_pair("f5", "555"),
        std::make_pair("f6", "666")
    };
    redis.hset("key", fields.begin(), fields.end());

    // 获取并打印字段 f3 的值
    auto result = redis.hget("key", "f3");
    if (result) {
        std::cout << "result: " << result.value() << std::endl;
    } else {
        std::cout << "result 无效!" << std::endl;
    }
}

2. Hexists

此示例检查指定字段是否存在于给定的哈希中，并输出结果。

void TestHexists(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 设置一些字段-值对
    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    // 检查字段 f4 是否存在
    bool result = redis.hexists("key", "f4");
    std::cout << "result: " << result << std::endl;
}

3. Hdel

这个例子展示如何删除哈希中的一个或多个字段，并输出受影响的字段数量。

void TestHdel(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 设置一些字段-值对
    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    // 删除字段 f1 并输出受影响的数量
    long long result = redis.hdel("key", "f1");
    std::cout << "result: " << result << std::endl;

    // 删除字段 f2 和 f3 并输出受影响的数量
    result = redis.hdel("key", {"f2", "f3"});
    std::cout << "result: " << result << std::endl;

    // 输出当前哈希中的字段数量
    long long len = redis.hlen("key");
    std::cout << "len: " << len << std::endl;
}

4. Hkeys 和 Hvals

该示例获取哈希中的所有 field 和对应的 value，并分别打印出来。

void TestHkeysAndHvals(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 设置一些字段-值对
    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    // 获取并打印所有键名
    std::vector<std::string> fields;
    auto itFields = std::back_inserter(fields);
    redis.hkeys("key", itFields);
    PrintContainer(fields);

    // 获取并打印所有值
    std::vector<std::string> values;
    auto itValues = std::back_inserter(values);
    redis.hvals("key", itValues);
    PrintContainer(values);
}

5. Hmget 和 Hmset

此示例说明了如何一次性设置多个字段-值对 (vector<pair>)，并从哈希中获取多个字段的值。

void TestHmgetAndHmset(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 批量设置多个字段-值对
    redis.hmset("key", {std::make_pair("f1", "111"),
                        std::make_pair("f2", "222"),
                        std::make_pair("f3", "333")});

    // 再次批量设置更多字段-值对
    std::vector<std::pair<std::string, std::string>> pairs = {
        std::make_pair("f4", "444"),
        std::make_pair("f5", "555"),
        std::make_pair("f6", "666")
    };
    redis.hmset("key", pairs.begin(), pairs.end());

    // 获取并打印指定字段的值
    std::vector<std::string> values;
    auto it = std::back_inserter(values);
    redis.hmget("key", {"f1", "f2", "f3"}, it);
    PrintContainer(values);
}

---

Zset

1. Zadd 和 Zrange

这个示例演示了如何向有序集合中添加成员，并通过 zrange 命令以两种不同的方式获取成员：只查询成员或同时查询成员和分数。

void TestZaddAndZrange(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 添加单个成员及其分数
    redis.zadd("key", "吕布", 99);

    // 批量添加多个成员及其分数
    redis.zadd("key", {std::make_pair("赵云", 98), std::make_pair("典韦", 97)});

    // 使用容器批量添加成员及其分数
    std::vector<std::pair<std::string, double>> members = {
        std::make_pair("关羽", 95),
        std::make_pair("张飞", 93)
    };
    redis.zadd("key", members.begin(), members.end());

    // 获取并打印所有成员（不带分数）
    std::vector<std::string> memberResults;
    auto it = std::back_inserter(memberResults);
    redis.zrange("key", 0, -1, it);
    PrintContainer(memberResults);

    // 获取并打印所有成员及其分数
    std::vector<std::pair<std::string, double>> membersWithScore;
    auto it2 = std::back_inserter(membersWithScore);
    redis.zrange("key", 0, -1, it2);
    PrintContainerPair(membersWithScore);
}

• zrange支持两种主要的风格：

• • 只查询member, 不带score
  • 查询member同时带score

• 关键就是看插入迭代器指向的容器的类型 ：

• • 指向的容器只是包含一个string, 就是只查询member
  • 指向的容器包含的是一个pair, 里面有string和 double, 就是查询member同时带有score

2. Zcard

此示例计算有序集合中的成员数量，并输出结果。

void TestZcard(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 添加一些成员及其分数
    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    // 计算集合大小
    long long result = redis.zcard("key");
    std::cout << "result: " << result << std::endl;
}

3. Zrem

这个例子展示如何从有序集合中删除一个成员，并输出删除后的集合大小。

void TestZrem(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 添加一些成员及其分数
    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    // 删除成员 zhangsan
    redis.zrem("key", "zhangsan");

    // 计算删除后的集合大小
    long long result = redis.zcard("key");
    std::cout << "result: " << result << std::endl;
}

4. Zscore

该示例获取指定成员的分数，并输出结果。

void TestZscore(Redis &redis) {
    // 清空数据库
    redis.flushall();

    // 添加一些成员及其分数
    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    // 获取并打印成员 zhangsan 的分数
    auto score = redis.zscore("key", "zhangsan");
    if (score) {
        std::cout << "score: " << score.value() << std::endl;
    } else {
        std::cout << "score 无效" << std::endl;
    }
}