Redis实战 - 2.list、set和Sorted Set

时间 2020-04-28

标签 redis 实战 2.list list set sorted 栏目 Redis 繁體版

原文原文链接

List

Redis的List是经过Linked List（链表）来实现的String集合，因此插入数据的速度很快。html

可是缺点就是在数据量比较大的时候，访问某个数据的时间可能会很长，但针对这种状况，可使用Sorted Set，这个一会再说。redis

LPUSH，RPUSH，LRANGE

LPUSH会向List的左侧（头部）添加一个新的元素，而RPUSH会把新的元素添加到List的右侧（尾部）。数组

LRANGE命令能够按索引区间显示List的一部分，它的个试试LRANGE List-Key start end。若是想显示整个list的话，这两个索引就能够是0和-1，其中-1就表示最后一个元素。数据结构

注意：这里插入多个数，由于是链表，因此向左插入。dom

LPOP，RPOP

POP动做有两个效果：一个是获取到元素，另外一个是把元素从list中删除。ide

LPOP就是从左边（头部）POP，RPOP就是从右边（尾部）POP。 spa

LTRIM

LTRIM命令能够对list进行剪切，其格式为LTRIM list-key start end，返回的就是剪切的部分：设计

BRPOP，BLPOP

BRPOP和BLPOP这两个命令与RPOP和LPOP相似，可是当list里没有元素的时候，它们能够几秒钟，若是这期间有新的元素添加到了list里，那么就会中止等待返回该元素，不然就会一直等到设定的时间结束，而后返回null： 3d

此外您还应该研究一下RPOPLPUSH和BRPOPLPUSH这两个命令。code

.NET Core 操练LIST

static void List()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {

                IDatabase db = redis.GetDatabase();

                 db.KeyDelete("mylist"); //删除
                //LPUSH
                db.ListLeftPush("mylist","a");

                //RPUSH
                db.ListRightPush("mylist", new RedisValue[] {"a", "b", 5});

                //LRANGE
                var toDisplay = db.ListRange("mylist", 0, -1);

                foreach (RedisValue redisValue in toDisplay)
                {
                    Console.Write(redisValue+",");
                }
                //结果：a,a,b,5
                Console.WriteLine();
                
                //2.LPOP，RPOP 获取并删除
                Console.WriteLine("2.LPOP，RPOP 获取并删除");
                db.KeyDelete("mylist"); //删除
                db.ListLeftPush("mylist", new RedisValue[] {"a", "b", "c","d"});  //d,c,b,a
                
                RedisValue lpop =   db.ListLeftPop("mylist");
                Console.WriteLine(lpop); //结果：d

                RedisValue rpop = db.ListRightPop("mylist");
                Console.WriteLine(rpop); //结果：a

                //3.LTRIM 剪切
                 Console.WriteLine("3.LTRIM 剪切");
                db.KeyDelete("mylist"); //删除
                db.ListLeftPush("mylist", new RedisValue[] { "a", "b", "c", "d" });  //d,c,b,a

                db.ListTrim("mylist",0,1);

                var listtrim = db.ListRange("mylist", 0, -1);
               
                foreach (RedisValue redisValue in listtrim)
                {
                    Console.Write(redisValue + ",");
                }
                //结果：d,c
                Console.WriteLine();
            }
        }

SET

Redis的SET是无序的String集合，它里面的元素是不会重复的。

SADD

能够看到一次性能够添加一个或多个元素。

SMEMBERS

SMEMBERS能够获取set里全部的元素：

SISMEMBER

SISMEMBER能够判断某个元素是否在set里：返回1表示true，0表示false。

SINTER

SINTER能够查看多个set之间的交集：

SPOP

SPOP能够随机从set中移除一个或多个元素并返回：

SUNION

SUNION key1 [key2]

返回全部给定集合的并集

SUNIONSTORE

并集：把多个set合并到一个set里可使用SUNIONSTORE，格式是sunionstore 目标set set1 set2 ...：

复制

若是只有一个set须要合并的话，那么就至关因而复制：

SCARD

SCARD能够获取set的大小：

SRANDMEMBER

SRANDMEMBER能够随机获取set里面的元素，可是不会移除它们：

.NET Core 操练SET

static void SET()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {
                //1.SADD 添加
                IDatabase db = redis.GetDatabase();
                db.KeyDelete("set0");
                db.SetAdd("set0", new RedisValue[]{0,1,1,2,2,3,4,5,6,"1"}); 
                
                //2.SMEMBERS 查询全部
                var set0 = db.SetMembers("set0");
                string value = string.Empty;
                foreach (RedisValue redisValue in set0)
                {
                    value += redisValue + ",";
                }
                string remove = value.TrimEnd(','); 
                Console.WriteLine(remove);
                //结果：0，1，2，3，4，5，6 不会添加剧复,这里添加了2个1，2个2，结果只添加上1个，缘由？

                //3.SISMEMBER 能够判断某个元素是否在set里
                var result = db.SetContains("set0", "3");
                var result1 = db.SetContains("set0", "111");
                Console.WriteLine(result); //true
                Console.WriteLine(result1); //false

                //4.SINTER 查看多个set之间的交集
                db.KeyDelete(new RedisKey[] {"set1", "set2", "set3"});
                db.SetAdd("set1", new RedisValue[] {0, 1, 1, 2, 2, 3, 4, 5, 6});
                db.SetAdd("set2", new RedisValue[] { 1, 3, 5, 7,9});
                db.SetAdd("set3", new RedisValue[] {1, 5, 9,11});
                var intersection = db.SetCombine(SetOperation.Intersect, new RedisKey[] {"set1", "set2", "set3"});
                string valueCombine = string.Empty;
                foreach (RedisValue redisValue in intersection)
                {
                    valueCombine += redisValue + ",";
                }
                string removeCombine = valueCombine.TrimEnd(',');
                Console.WriteLine(removeCombine); 
                //结果：1，5

                //5.SPOP 随机从set中移除一个或多个元素并返回
                // var pop1 = db.SetPop("set0");
                // var pop2 = db.SetPop("set0");
                // var pop3 = db.SetPop("set0");
                // Console.WriteLine(pop1);
                // Console.WriteLine(pop2);
                // Console.WriteLine(pop3);
                //结果：6,4,5

                //6.SUNIONSTORE 并集：把多个set合并到一个set里可使用SUNIONSTORE，格式是sunionstore 目标set set1 set2 ...：
                //这里第2个参数的“targetset”，是目标集的key（新合成的key）
                var size = db.SetCombineAndStore(SetOperation.Union,"targetset", new RedisKey[] {"set1", "set2", "set3"});
                Console.WriteLine(size);  //10

                //7.SCARD 能够获取set的大小：
                var scardSize = db.SetLength("set0");
                Console.WriteLine(scardSize); // 7 = (0,1,2,3,4,5,6).length

                //8.SRANDMEMBER 能够随机获取set里面的元素，可是不会移除它们
                var random = db.SetRandomMember("set0");
                Console.WriteLine(random); //4
            } 
        }

Sorted SET

Sorted Set有点像Set和Hash的结合体。

和Set同样，它里面的元素是惟一的，类型是String，因此它能够理解为就是一个Set。

可是Set里面的元素是无序的，而Sorted Set里面的元素都带有一个浮点值，叫作分数（score），因此这一点和Hash有点像，由于每一个元素都映射到了一个值。

Sorted Set是有序的，规则以下：

若是A.score > B.score，那么A > B。
若是A.score == B.score，那么A和B的大小就经过比较字符串来决定了，而A和B的字符串是不会相等的，由于Sorted Set里面的值都是惟一的。

ZADD

ZADD能够添加元素到Sorted Set，就和Set的SADD命令差很少：能够看到ZADD的格式是：zadd key score element。

ZRANGE，ZREVRANGE

ZRANGE默认按分数由低到高把Sorted Set的元素显示出来： ZREVRANGE 从高到低：也能够一同把分数显示出来，使用参数WITHSCORES：

ZRANGEBYSCORE

ZRANGEBYSCORE能够按范围显示Sorted Set，格式是zrangebyscore key 分数下限分数上限：

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE能够按范围移除元素：该命令返回的是移除元素的个数。

其中-inf和inf分别表示负无穷和正无穷。

ZRANK

ZRANK命令能够得到元素的排名：排名从0开始。

ZREVRANK

ZREVRANK这个正好和ZRANK相反，就不说了。

词典分数（分数相同）

Sorted Set里分数相同的元素是按照词典分数（能够理解为比较字符串）进行排序的。

ZRANGEBYLEX

ZRANGEBYLEX能够按词典范围展现Sorted Set：

ZREVRANGEBYLEX

ZREVRANGEBYLEX 返回指定成员区间内的成员，按成员字典倒序排序, 分数必须相同。在某些业务场景中,须要对一个字符串数组按名称的字典顺序进行倒序排列时,可使用Redis中SortSet这种数据结构来处理。 http://www.redis.cn/commands/zrevrangebylex.html

ZREMRANGEBYLEX

ZREMRANGEBYLEX 删除名称按字典由低到高排序成员之间全部成员。不要在成员分数不一样的有序集合中使用此命令, 由于它是基于分数一致的有序集合设计的,若是使用,会致使删除的结果不正确。待删除的有序集合中,分数最好相同,不然删除结果会不正常。 http://www.redis.cn/commands/zremrangebylex.html

ZLEXCOUNT

ZLEXCOUNT 命令用于计算有序集合中指定成员之间的成员数量。 http://www.redis.cn/commands/zlexcount.html

.NET core操练Sorted Set

static void SortSet()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {

                IDatabase db = redis.GetDatabase();
                //1.ZADD，ZRANGE 添加，ZRANGE排序：默认按分数由低到高把Sorted Set的元素显示出来：
                db.SortedSetAdd("players", "张三", 89d);
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("李四",75d),
                    new SortedSetEntry("王五",78d),
                    new SortedSetEntry("赵六",91d),
                    new SortedSetEntry("钱七",100d),
                    new SortedSetEntry("孙八",50d),
                    new SortedSetEntry("李九",65d),
                    new SortedSetEntry("唐三三",88),
                });
                //ZRANGE
                var sortedSet = db.SortedSetRangeByRank("players", start: 0, stop: -1);
                foreach (RedisValue value in sortedSet)
                {
                    Console.WriteLine(value);
                }
                // 孙八
                // 李九
                // 李四
                // 王五
                // 唐三三
                // ....

                //2.ZREVRANGE，WITHSCORES
                //ZREVRANGE 从高到低：也能够一同把分数显示出来，使用参数WITHSCORES：
                var sortedSetWITHSCORES = db.SortedSetRangeByRankWithScores("players", start: 0, stop: -1,order:Order.Descending);
                foreach (SortedSetEntry value in sortedSetWITHSCORES)
                {
                    Console.WriteLine(value);
                }
                //钱七:100
                //赵六:91
                //张三:89
                //唐三三:88
                //王五:78
                // ....
                Console.WriteLine();
                
                //3.ZRANGEBYSCORE 能够按范围显示Sorted Set，格式是zrangebyscore key 分数下限 分数上限：
                var sortedSetZRANGEBYSCORE = db.SortedSetRangeByScoreWithScores("players", start: 60, stop: 90);
                foreach (SortedSetEntry value in sortedSetZRANGEBYSCORE)
                {
                    Console.WriteLine(value);
                }
                // 李九：65
                // 李四：75
                // 王五：78
                // 唐三三：88
                // 张三:89
                 Console.WriteLine();

                //4.ZREMRANGEBYSCORE 能够按范围移除元素
                //double.NegativeInfinity:负无穷 (redis命令：-inf)
                var ZREMRANGEBYSCORE =
                    db.SortedSetRemoveRangeByScore("players", start: double.NegativeInfinity, stop: 60);
                var sortedSetfor = db.SortedSetRangeByScoreWithScores("players", start: Double.MinValue, stop: Double.MaxValue);
                foreach (SortedSetEntry value in sortedSetfor)
                {
                    Console.WriteLine(value);
                }
                // 李九：65
                // 李四：75
                // 王五：78
                // 唐三三：88
                // 张三：89
                // 赵六：91
                // 钱七：100
                Console.WriteLine();

                //5.ZRANK 能够得到元素的排名
                var rank = db.SortedSetRank("players", "唐三三");
                Console.WriteLine(rank); //3

                //6.ZRANGEBYLEX 能够得到元素的排名，高到低
                db.KeyDelete("players");
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("Alan smith",0),
                    new SortedSetEntry("Chuck Van Halen",0),
                    new SortedSetEntry("Filippo Inzaghi",0),
                    new SortedSetEntry("Michael Jackson",0),
                    new SortedSetEntry("Di Matteo",0),
                    new SortedSetEntry("Charlie Sheen",0),
                    new SortedSetEntry("Eric Evans",0),
                });

                var ZRANGEBYLEX = db.SortedSetRangeByValue("players", "C", "F");
                foreach (var value in ZRANGEBYLEX)
                {
                    Console.WriteLine(value);
                }
                // Charlie Sheen
                // Chuck Uan Halen
                // Di Matteo
                // Eric Evans

                db.KeyDelete("players");
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("李四",75d),
                    new SortedSetEntry("王五",78d),
                    new SortedSetEntry("赵六",91d),
                    new SortedSetEntry("钱七",100d),
                    new SortedSetEntry("孙八",50d),
                    new SortedSetEntry("李九",65d),
                    new SortedSetEntry("唐三三",88),
                });

                var ZRANGEBYLEX1 = db.SortedSetRangeByValue("players", "C", "F");
                foreach (var value in ZRANGEBYLEX1)
                {
                    Console.WriteLine(value);
                }
                //中文为null
            }
        }

参考：

草根专栏，Redis in .NET Core 入门：(4) LIST和SET 草根专栏，Redis in .NET Core 入门：(5) Sorted SET 杨旭(Video)，Redis in ASP.NET Core 3. List, Set, Sorted Set