Redis-CPP 5大类型操作

这篇文章不会讲解所有关于5大基础类型的所有命令，只讲解几个常用的命令操作。如果想看全部的命令操作，可以看其它的文章。

string

set

先来看一看set操作在服务器端的函数原型：
SET key value [expiration EX seconds|PX milliseconds] [NX|XX]
其中有[NX | XX]选项，而且还能设置过期时间，在通用接口中我们已经见过了函数原型。只是还有2个参数没有讲解，接下来就讲解另外2个参数。

bool set(const sw::redis::StringView &key, const sw::redis::StringView &val, const std::chrono::milliseconds &ttl = std::chrono::milliseconds(0), sw::redis::UpdateType type = sw::redis::UpdateType::ALWAYS)

第三个参数用于设置超时时间，第四个参数可以选择设置[NX | XX]。有三种选项可以选择：

• ALWAYS：默认值是这个。表示的是总是插入新的数据。
• NOT_EXIST：key不存在时才会插入，key存在时则不设置(返回nil)。与NX一样。
• EXIST：key存在时则更新（相当于更新key的value），不存在时不会设置。与XX一样。

代码示例：

using sw::redis::Redis;
using namespace std;void test1(Redis &redis)
{cout << "get 和 set" << std::endl;redis.flushall();redis.set("key1", "111");auto value = redis.get("key1");if (value)cout << "value:" << value.value() << endl;redis.set("key2", "222");value = redis.get("key2");if (value)cout << "value:" << value.value() << endl;cout << "带上超时时间" << endl;redis.set("key3", "333", 10s);   // 设置10秒后过期this_thread::sleep_for(3s);   // 休眠3秒long long time = redis.ttl("key3");cout << "time: " << time << endl;
}

---

void test2(Redis &redis)
{cout << "set NX 和 XX" << endl;redis.flushall();redis.set("key1", "111");// set的重载版本中，没有单独提供NX和XX的版本，必须搭配过期时间版本来使用。redis.set("key1", "222", 5s, sw::redis::UpdateType::EXIST); // 如果不想设置过期时间的话，写0s就行，不能省略第三个参数auto value = redis.get("key1");if (value)cout << "value: " << value.value() << endl;elsecout << "key不存在" << endl;
}

mset

用于同时设置多个key。函数原型如下：

 template <typename Input>void mset(Input first, Input last);template <typename T>void mset(std::initializer_list<T> il) {mset(il.begin(), il.end());}

第一个版本是可以使用容器迭代器，类型是std::pair<std::string, std::string>。例如，可以使用vector，然后存入pair；也可以使用map或者unordered_map来进行存储。
第二个版本是使用初始化列表，列表中的每个元素都是std::pair<std::string, std::string>。

• 代码示例：

void test3(Redis &redis)
{cout << "mset" << endl;redis.flushall();// 使用初始化列表redis.mset({make_pair("key1", "111"), make_pair("key2", "222")});// 使用迭代器方法vector<pair<string, string>> v = {{"key3", "333"},{"key4", "444"},};redis.mset(v.begin(), v.end());auto value = redis.get("key1");if (value)std::cout << "value: " << value.value() << std::endl;value = redis.get("key2");if (value)std::cout << "value: " << value.value() << std::endl;value = redis.get("key3");if (value)std::cout << "value: " << value.value() << std::endl;
}

mget

用于同时获取多个key。函数原型如下：

template <typename Input, typename Output>void mget(Input first, Input last, Output output);template <typename T, typename Output>void mget(std::initializer_list<T> il, Output output) {mget(il.begin(), il.end(), output);}

也有两个版本，一种是使用迭代器类型，把要查询的key放入到input容器中，然后输入容器的头尾迭代器。第三个参数是一个output迭代器，用于接收输出的value。另一种是使用初始化列表，把要查询的key放入到列表当中。

• 代码示例：

void test4(Redis &redis)
{std::cout << "mget" << std::endl;redis.flushall();vector<std::pair<string, string>> keys = {{"key1", "111"},{"key2", "222"},{"key3", "333"}};redis.mset(keys.begin(), keys.end());vector<sw::redis::OptionalString> result;auto it = std::back_inserter(result);redis.mget({"key1", "key2", "key3", "key4"}, it);for (auto &elem : result){// 此处预期elem是一个optional类型的元素，打印之前，先判定一下，看是否有效。if (elem)cout << elem.value() << endl;elsecout << "元素无效" << endl;}
}

getrange

获取指定范围内的字符串。函数原型如下：
std::string getrange(const StringView &key, long long start, long long end);
第一个参数是需要查看的key，第二个和第三个参数都是查询的范围，下标可以是负数。

setrange

从指定下标覆盖字符串。函数原型如下：
long long setrange(const StringView &key, long long offset, const StringView &val);
第一个参数是指定的key；第二个参数是起始的下标，从起始下标往后的字符将被覆盖；第三个参数是用val进行覆盖。
返回值是此操作后字符串的长度。

• 代码示例：

void test5(Redis &redis)
{cout << "getrange" << endl;redis.flushall();redis.set("key", "abcdefg");string result = redis.getrange("key", 2, 5);cout << "result: " << result << endl;redis.setrange("key", 2, "ooo");auto value = redis.get("key");cout << "value: " << value.value() << endl;
}

incrby

将 key 中储存的数字加上指定的增量值。函数原型如下：
long long incrby(const StringView &key, long long increment);

decrby

将 key 对应的 string 表⽰的数字减去对应的值。函数原型如下：
long long decrby(const StringView &key, long long decrement);

• 代码示例：

void test6(Redis &redis)
{cout << "incrby和decrby" << endl;redis.flushall();redis.set("key1", "111");redis.set("key2", "222");long long result1 = redis.incrby("key1", 10);long long result2 = redis.decrby("key2", 10);cout << "result1: " << result1 << endl;cout << "result2: " << result2 << endl;
}

list

lpush

把元素头插到列表头部。函数原型如下：

long long lpush(const StringView &key, const StringView &val);template <typename Input>long long lpush(const StringView &key, Input first, Input last);template <typename T>long long lpush(const StringView &key, std::initializer_list<T> il) {return lpush(key, il.begin(), il.end());}

第一个版本很简单，每次只能插入一个元素。
第二个版本是迭代器类型，第三个版本是使用初始化列表。

• 代码示例

void test1(Redis &redis)
{cout << "lpush 和 lrange用法" << endl;redis.flushall();// 插入单个元素redis.lpush("key1", "111");// 插入多个元素，使用初始化列表redis.lpush("key1", {"222", "333", "444"});// 使用迭代器vector<string> val = {"555", "666"};redis.lpush("key1", val.begin(), val.end());// 获取元素vector<string> ans;auto it = back_inserter(ans);redis.lrange("key1", 0, -1, it);for (auto &elem : ans){cout << elem << endl;}
}

rpush

把元素尾插到列表尾部。函数原型如下：

long long rpush(const StringView &key, const StringView &val);template <typename Input>
long long rpush(const StringView &key, Input first, Input last);template <typename T>
long long rpush(const StringView &key, std::initializer_list<T> il) {return rpush(key, il.begin(), il.end());
}

使用方法和lpush一样。

lpop

从头部删除元素。函数原型如下：

OptionalString lpop(const StringView &key);

此处需要注意返回的是OptionalString类型，需要进行检查，避免为空。

rpop

从尾部删除元素。函数原型如下：

OptionalString rpop(const StringView &key);

• 代码示例：

void test2(Redis &redis)
{cout << "lpop 和 rpop 用法" << endl;redis.flushall();redis.rpush("key1", {"111", "222", "333", "444", "555"});auto ans = redis.lpop("key1");if (ans)cout << "lpop: " << ans.value() << endl;ans = redis.rpop("key1");if (ans)cout << "rpop: " << ans.value() << endl;ans = redis.lpop("key2");if (ans)cout << "lpop: " << ans.value() << endl;elsecout << "该key不存在" << endl;
}

lrange

获取指定范围内的元素。函数原型如下：

template <typename Output>
void lrange(const StringView &key, long long start, long long stop, Output output);

指定区间[start, top]，然后把结果通过output迭代器输出到容器中。

llen

获取列表的长度。函数原型如下：

long long llen(const StringView &key);

blpop

阻塞等待，获取头部元素。函数原型如下：

// 单个key
OptionalStringPair blpop(const StringView &key, long long timeout);OptionalStringPair blpop(const StringView &key,const std::chrono::seconds &timeout = std::chrono::seconds{0});// 迭代器版本
template <typename Input>OptionalStringPair blpop(Input first, Input last, long long timeout);template <typename Input>OptionalStringPair blpop(Input first,Input last,const std::chrono::seconds &timeout = std::chrono::seconds{0});// 初始化列表版本
template <typename T>OptionalStringPair blpop(std::initializer_list<T> il, long long timeout) {return blpop(il.begin(), il.end(), timeout);}template <typename T>OptionalStringPair blpop(std::initializer_list<T> il,const std::chrono::seconds &timeout = std::chrono::seconds{0}) {return blpop(il.begin(), il.end(), timeout);}

blpop有6个重载但其实是同样的功能的不同传参形式而已。对于redis的等待，其可以传入一个或者多个key。前两个函数重载就是对单个key的特化、超时时间可以分为lonng long类型和std::chrono类型，所以有两个重载。
blpop的返回值一个是OptionalStringPair，第一个成员是key，表示该数据从哪一个list得到的，第二个成员OptionalStringPair.value().second才是获得到的值。
有两种方式可以访问成员，第一种是通过value()方法获取pair：

OptionalStringPair.value().first;
OptionalStringPair.value().fsecond;

还有一种是通过->访问：

OptionalStringPair -> first;
OptionalStringPair -> second;

该函数可能返回一个空值，所以使用之前要检测是否为空。

• 代码示例

void test3(Redis &redis)
{using namespace std::chrono_literals;cout << "blpop 和 brpop 用法" << endl;redis.flushall();auto result = redis.blpop({"key", "key2", "key3"}, 10s);   // 如果不设置超时时间，那么会一直阻塞住if (result){std::cout << "key:" << result.value().first << std::endl;std::cout << "elem:" << result->second << std::endl;}else{std::cout << "result 无效!" << std::endl;}
}

brpop

函数原型：

// 单key版本
OptionalStringPair brpop(const StringView &key, long long timeout);OptionalStringPair brpop(const StringView &key,const std::chrono::seconds &timeout = std::chrono::seconds{0});// 多key，容器迭代器版本
template <typename Input>
OptionalStringPair brpop(Input first, Input last, long long timeout);template <typename Input>
OptionalStringPair brpop(Input first,Input last,const std::chrono::seconds &timeout = std::chrono::seconds{0});// 多key，初始化列表版本
template <typename T>
OptionalStringPair brpop(std::initializer_list<T> il, long long timeout);template <typename T>
OptionalStringPair brpop(std::initializer_list<T> il,const std::chrono::seconds &timeout = std::chrono::seconds{0});

和blpop一样

set

sadd

往集合中插入元素，或者创建一个集合。函数原型如下：

long long sadd(const StringView &key, const StringView &member);template <typename Input>long long sadd(const StringView &key, Input first, Input last);template <typename T>long long sadd(const StringView &key, std::initializer_list<T> il) {return sadd(key, il.begin(), il.end());}

第一个版本是一次添加一个元素。第二个版本是迭代器版本。第三个版本是使用初始化列表。

smembers

返回集合中的所有的成员。 不存在的集合 key 被视为空集合。函数原型如下：

template <typename Output>void smembers(const StringView &key, Output output);

• 代码示例：

void test1(Redis &redis)
{cout << "sadd 和 smembers" << endl;redis.flushall();// 一次添加一个redis.sadd("key1", "111");// 使用初始化列表redis.sadd("key1", {"222", "333", "444"});// 使用迭代器set<string> elems = {"555", "666", "777"};redis.sadd("key1", elems.begin(), elems.end());vector<string> result;// auto it = back_inserter(result);// 由于此处set里的元素顺序是固定的，指定一个result.end()或者result.begin()或者其它位置的迭代器，都无所谓auto it = inserter(result, result.end());redis.smembers("key1", it);for (auto &elem : result){cout << "value: " << elem << endl;}
}

sismember

判断成员元素是否是集合的成员。函数原型：

bool sismember(const StringView &key, const StringView &member);

scard

返回集合中元素的数量。函数原型如下：

long long scard(const StringView &key);

• 代码示例：

void test2(Redis &redis)
{cout << "scard使用" << endl;redis.flushall();redis.sadd("key1", {"111", "222", "333", "444"});auto ans = redis.scard("key1");cout << ans << endl;
}

spop

从 set 中删除并返回⼀个或者多个元素。函数原型：

OptionalString spop(const StringView &key);template <typename Output>void spop(const StringView &key, long long count, Output output);

• 代码示例：

void test3(Redis &redis)
{std::cout << "spop" << std::endl;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;}
}

sinter

返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。函数原型：

template <typename Input, typename Output>void sinter(Input first, Input last, Output output);template <typename T, typename Output>void sinter(std::initializer_list<T> il, Output output) {sinter(il.begin(), il.end(), output);}

第一个版本是使用迭代器。第二个是使用初始化列表。最后把结果输出到output迭代器当中。

• 代码示例：

void test4(Redis &redis)
{cout << "sinter" << endl;redis.flushall();redis.sadd("key1", {"111", "222", "333"});redis.sadd("key2", {"111", "222", "444"});set<string> result;auto it = inserter(result, result.end());redis.sinter({"key1", "key2"}, it);for (auto &elem : result){cout << "value: " << elem << endl;}
}

sinterstore

将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在，则将其覆盖。函数原型：

long long sinterstore(const StringView &destination, const StringView &key);template <typename Input>long long sinterstore(const StringView &destination,Input first,Input last);template <typename T>long long sinterstore(const StringView &destination,std::initializer_list<T> il) {return sinterstore(destination, il.begin(), il.end());}

重载的第一个参数都是destination，求出的交集会被存放到这个set中。第一个重载是对单个set的特化，后续两个重载分别输入一个迭代器或者初始化列表，内部放要求交集的多个set。

• 代码示例：

void test5(Redis &redis)
{cout << "sinterstore" << endl;redis.flushall();redis.sadd("key1", {"111", "222", "333"});redis.sadd("key2", {"111", "222", "444"});long long len = redis.sinterstore("key3", {"key1", "key2"});cout << "len: " << len << endl;set<string> result;auto it = inserter(result, result.end());redis.smembers("key3", it);for (auto &elem : result){cout << "value: " << elem << endl;}
}

hash

hset

用于为哈希表中的字段赋值 。如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，旧值将被覆盖。函数原型：

long long hset(const StringView &key, const StringView &field, const StringView &val);long long hset(const StringView &key, const std::pair<StringView, StringView> &item);template <typename Input>
auto hset(const StringView &key, Input first, Input last)-> typename std::enable_if<!std::is_convertible<Input, StringView>::value,         long long>::type;template <typename T>
long long hset(const StringView &key, std::initializer_list<T> il);

前2个版本是单个键值对。后两个版本是插入多个键值对。

hget

用于返回哈希表中指定字段的值。函数原型：

OptionalString hget(const StringView &key, const StringView &field);

• 代码示例：

void test1(Redis &redis)
{cout << "hget 和 hset" << endl;redis.flushall();redis.hset("key1", "f1", "111");redis.hset("key1", make_pair("f2", "222"));// 一次性插入多个键值对redis.hset("key1", {make_pair("f3", "333"), make_pair("f4", "444")});vector<pair<string, string>> fields = {make_pair("f5", "555"), make_pair("f6", "666")};redis.hset("key1", fields.begin(), fields.end());auto ans = redis.hget("key1", "f3");if (ans)cout << "ans: " << ans.value() << endl;elsecout << "ans无效!" << endl;
}

hexists

用于查看哈希表的指定字段是否存在。函数原型：

bool hexists(const StringView &key, const StringView &field);

hdel

用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。函数原型：

long long hdel(const StringView &key, const StringView &field);template <typename Input>long long hdel(const StringView &key, Input first, Input last);template <typename T>long long hdel(const StringView &key, std::initializer_list<T> il) {return hdel(key, il.begin(), il.end());}

• 代码示例：

void test2(Redis &redis)
{std::cout << "hdel" << std::endl;redis.flushall();redis.hset("key", "f1", "111");redis.hset("key", "f2", "222");redis.hset("key", "f3", "333");long long result = redis.hdel("key", "f1");std::cout << "result: " << result << std::endl;result = redis.hdel("key", {"f2", "f3"});std::cout << "result: " << result << std::endl;long long len = redis.hlen("key");std::cout << "len: " << len << std::endl;
}

hkeys

用于获取哈希表中的所有域（field）。函数原型：

template <typename Output>
void hkeys(const StringView &key, Output output);

hvals

返回哈希表所有的值。函数原型：

template <typename Output>
void hvals(const StringView &key, Output output);

• 代码示例：

void test3(Redis &redis)
{cout << "hkeys 和 hvals" << endl;redis.flushall();redis.hset("key1", "f1", "111");redis.hset("key1", "f2", "222");redis.hset("key1", "f3", "333");vector<string> fields;auto itfie = back_inserter(fields);redis.hkeys("key1", itfie);for (auto &elem : fields){cout << "value: " << elem << endl;}vector<string> values;auto itval = back_inserter(values);redis.hvals("key1", itval);for (auto &elem : values){cout << "value: " << elem << endl;}
}

hmget

用于返回哈希表中，一个或多个给定字段的值。如果指定的字段不存在于哈希表，那么返回一个 nil 值。函数原型：

template <typename T, typename Output>void hmget(const StringView &key, std::initializer_list<T> il, Output output) {hmget(key, il.begin(), il.end(), output);}template <typename Input, typename Output>void hmget(const StringView &key, Input first, Input last, Output output);

hmset

用于同时将多个 field-value (字段-值)对设置到哈希表中。此命令会覆盖哈希表中已存在的字段。如果哈希表不存在，会创建一个空哈希表，并执行 HMSET 操作。函数原型：

template <typename Input>void hmset(const StringView &key, Input first, Input last);template <typename T>void hmset(const StringView &key, std::initializer_list<T> il) {hmset(key, il.begin(), il.end());}

• 代码示例：

void test4(Redis &redis)
{cout << "hmget 和 hmset" << endl;redis.flushall();redis.hmset("key", {make_pair("f1", "111"),make_pair("f2", "222"),make_pair("f3", "333")});vector<pair<string, string>> pairs = {make_pair("f4", "444"),make_pair("f5", "555"),make_pair("f6", "666")};redis.hmset("key", pairs.begin(), pairs.end());vector<string> values;auto it = back_inserter(values);redis.hmget("key", {"f1", "f2", "f3"}, it);for (auto &elem : values){cout << "value: " << elem << endl;}
}

zset

zadd

往zset中插入元素。函数原型如下：

long long zadd(const StringView &key,const StringView &member,double score,UpdateType type = UpdateType::ALWAYS,bool changed = false);template <typename Input>
long long zadd(const StringView &key,Input first,Input last,UpdateType type = UpdateType::ALWAYS,bool changed = false);template <typename T>
long long zadd(const StringView &key,std::initializer_list<T> il,UpdateType type = UpdateType::ALWAYS,bool changed = false);

zrange

获取zset指定范围内的元素。函数原型如下：

template <typename Output>
void zrange(const StringView &key, long long start, long long stop, Output output);

zrange支持两种主要的风格：

1. 只查询member，不带score。
2. 查询member同时带score。
   这两种风格关键就是看插入迭代器指向的容器的类型。指向的容器只是一个string，就是查询member，指向的容器包含的是一个pair，里面有string和double，就是查询member同时带有string。

• 代码示例：

void test1(Redis &redis)
{cout << "zadd 和 zrange" << endl;redis.flushall();redis.zadd("key1", "吕布", 99);redis.zadd("key1", {make_pair("赵云", 98), make_pair("典韦", 97)});vector<pair<string, double>> members = {make_pair("关羽", 95), make_pair("张飞", 93)};redis.zadd("key1", members.begin(), members.end());// 只查询membersvector<string> memberRedults;auto it = back_inserter(memberRedults);redis.zrange("key1", 0, -1, it);for (auto &elem : memberRedults)cout << "members: " << elem << endl;// 查询member和scorevector<pair<string, double>> memberWithScore;auto it2 = back_inserter(memberWithScore);redis.zrange("key1", 0, -1, it2);for (const auto &elem : memberWithScore)cout << elem.first << ":" << elem.second << endl;
}

zcard

获取zset中的元素个数，函数原型如下：

long long zcard(const StringView &key);

• 代码示例：

void test2(Redis &redis)
{cout << "zcard" << endl;redis.flushall();redis.zadd("key1", "吕布", 99);redis.zadd("key1", {make_pair("赵云", 98), make_pair("典韦", 97)});auto ans = redis.zcard("key1");cout << ans << endl;
}

zrem

删除zset中的元素。函数原型如下：

long long zrem(const StringView &key, const StringView &member);template <typename Input>long long zrem(const StringView &key, Input first, Input last);template <typename T>long long zrem(const StringView &key, std::initializer_list<T> il) {return zrem(key, il.begin(), il.end());}

• 代码示例：

void test3(Redis &redis)
{cout << "zrem" << endl;redis.flushall();redis.zadd("key1", "张三", 90);redis.zadd("key1", "李四", 92);redis.zadd("key1", "王五", 93);redis.zadd("key1", "赵六", 88);redis.zrem("key1", "李四");long long ans = redis.zcard("key1");cout << ans << endl;
}

zscore

获取member的score。函数原型如下：

OptionalDouble zscore(const StringView &key, const StringView &member);

zrank

获取member的排名，函数原型如下：

OptionalLongLong zrank(const StringView &key, const StringView &member);

• 代码示例：

void test4(Redis &redis)
{cout << "zscore 和 zrank" << endl;redis.flushall();redis.zadd("key1", "张三", 90);redis.zadd("key1", "李四", 92);redis.zadd("key1", "王五", 93);redis.zadd("key1", "赵六", 88);auto score = redis.zscore("key1", "王五");if (score)cout << "score: " << score.value() << endl;elsecout << "score无效" << endl;auto rank = redis.zrank("key1", "赵六");if (rank)cout << "rank: " << rank.value() << endl;elsecout << "rank 无效" << endl;
}