redis cmd 使用样例

时间：2017-07-22 18:28:10 阅读：1334 评论：0 收藏：0 [点我收藏+]

标签：shu comment err gzip return ip地址 aof文件服务端方式

Redis 命令參考

一 Redis介绍

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。

Redis能执行在大多数POSIX(Linux, *BSD, OS X 和Solaris等)系统上。官方没有支持Windows的版本号。眼下最新的版本号是2.2.11，这个版本号主要是修复了一个2.2.7版本号中遍历方式优化带来的一个bug。

　　和普通的Key-Value结构不同，Redis的Key支持灵活的数据结构。除了strings，还有hashes、lists、 sets 和sorted sets等结构。正是这些灵活的数据结构，丰富了Redis的应用场景，能满足很多其它业务上的灵活存储需求。

　　Redis的数据都保存在内存中，并且底层实现上是自己写了epoll event loop部分，而没有採用开源的libevent等通用框架，所以读写效率非常高。为了实现数据的持久化。Redis支持定期刷新(可通过配置实现)或写日志的方式来保存数据到磁盘。

　　1、数据类型

　　作为Key-value型数据库，Redis也提供了键(Key)和键值(Value)的映射关系。可是，除了常规的数值或字符串，Redis的键值还能够是下面形式之中的一个：

　　●Lists (列表)

　　●Sets (集合)

　　●Sorted sets (有序集合)

　　●Hashes (哈希表)

　　键值的数据类型决定了该键值支持的操作。Redis支持诸如列表、集合或有序集合的交集、并集、查集等高级原子操作;同一时候，假设键值的类型是普通数字，Redis则提供自增等原子操作。

　　2、持久化

　　通常，Redis将数据存储于内存中。或被配置为使用虚拟内存。通过两种方式能够实现数据持久化：使用截图的方式，将内存中的数据不断写入磁盘;或使用类似MySQL的日志方式，记录每次更新的日志。前者性能较高，可是可能会引起一定程度的数据丢失;后者相反。

　　3、主从同步

　　Redis支持将数据同步到多台从库上，这样的特性对提高读取性能很故意。

　　4、性能

　　相比须要依赖磁盘记录每一个更新的数据库。基于内存的特性无疑给Redis带来了很优秀的性能。

读写操作之间有显著的性能差异。

　　5、提供API的语言

　　●C

　　●C++

　　●C#

　　●Clojure

　　●Common Lisp

　　●Erlang

　　●Haskell

　　●Java

　　●Javascript

　　●Lua

　　●Objective-C

　　●Perl

　　●PHP

　　●Python

　　●Ruby

　　●Scala

　　●Go

　　●Tcl

6、适用场合

　　毫无疑问。Redis开创了一种新的数据存储思路，使用Redis，我们不用在面对功能单调的数据库时，把精力放在怎样把大象放进冰箱这种问题上，而是利用Redis灵活多变的数据结构和数据操作，为不同的大象构建不同的冰箱。

希望你喜欢这个比喻。

　　以下是Redis适用的一些场景:

　　(1)、取最新N个数据的操作

　　比方典型的取你站点的最新文章。通过以下方式，我们能够将最新的5000条评论的ID放在Redis的List集合中。并将超出集合部分从数据库获取。

　　使用LPUSH latest.comments命令。向list集合中插入数据

　　插入完毕后再用LTRIM latest.comments 0 5000命令使其永远仅仅保存近期5000个ID

　　然后我们在client获取某一页评论时能够用以下的逻辑

FUNCTION get_latest_comments(start,num_items):
id_list = redis.lrange("latest.comments",start,start+num_items-1)
IF id_list.length < num_items
id_list = SQL_DB("SELECT ... ORDER BY time LIMIT ...")
END
RETURN id_list
END

　　假设你还有不同的筛选维度。比方某个分类的最新N条。那么你能够再建一个按此分类的List，仅仅存ID的话，Redis是很高效的。

　　(2)、排行榜应用，取TOP N操作

　　这个需求与上面需求的不同之处在于，前面操作以时间为权重，这个是以某个条件为权重，比方按顶的次数排序，这时候就须要我们的sorted set出马了，将你要排序的值设置成sorted set的score，将详细的数据设置成对应的value。每次仅仅须要运行一条ZADD命令就可以。

　　(3)、须要精准设定过期时间的应用

　　比方你能够把上面说到的sorted set的score值设置成过期时间的时间戳，那么就能够简单地通过过期时间排序，定时清除过期数据了，不仅是清除Redis中的过期数据，你全然能够把Redis里这个过期时间当成是对数据库中数据的索引，用Redis来找出哪些数据须要过期删除。然后再精准地从数据库中删除对应的记录。

　　(4)、计数器应用

　　Redis的命令都是原子性的，你能够轻松地利用INCR，DECR命令来构建计数器系统。

　　(5)、Uniq操作。获取某段时间全部数据排重值

　　这个使用Redis的set数据结构最合适了，仅仅须要不断地将数据往set中扔即可了，set意为集合，所以会自己主动排重。

　　(6)、实时系统，反垃圾系统

　　通过上面说到的set功能，你能够知道一个终端用户是否进行了某个操作。能够找到其操作的集合并进行分析统计对照等。没有做不到，仅仅有想不到。

　　(7)、Pub/Sub构建实时消息系统

　　Redis的Pub/Sub系统能够构建实时的消息系统，比方非常多用Pub/Sub构建的实时聊天系统的样例。

　　(8)、构建队列系统

　　使用list能够构建队列系统，使用sorted set甚至能够构建有优先级的队列系统。

　　(9)、缓存

　　这个不必说了。性能优于Memcached。数据结构很多其它样化。

二、安装及使用

步骤一: 下载Redis

　　下载安装包：wget http://redis.googlecode.com/files/redis-2.2.12.tar.gz

　　[root@localhost 4setup]# wget http://redis.googlecode.com/files/redis-2.2.12.tar.gz

　　--19:06:56-- http://redis.googlecode.com/files/redis-2.2.12.tar.gz

　　正在解析主机 redis.googlecode.com... 74.125.71.82

　　Connecting to redis.googlecode.com|74.125.71.82|:80... 已连接。

　　已发出 HTTP 请求，正在等待回应... 200 OK

　　长度：455240 (445K) [application/x-gzip]

　　Saving to: `redis-2.2.12.tar.gz‘

　　100%[==========================================>] 455,240 34.8K/s in 13s

　　19:07:16 (34.8 KB/s) - `redis-2.2.12.tar.gz‘ saved [455240/455240]

　　[root@localhost 4setup]#

　　步骤二: 编译源程序

　　[root@localhost 4setup]# ll

　　总计 29168

　　-rw-r--r-- 1 root root 455240 2011-07-22 redis-2.2.12.tar.gz

　　[root@localhost 4setup]# tar xzf redis-2.2.12.tar.gz

　　[root@localhost 4setup]# cd redis-2.2.12

　　[root@localhost redis-2.2.12]# make

　　cd src && make all

　　make[1]: Entering directory `/root/4setup/redis-2.2.12/src‘

　　步骤三: 启动Redis服务

　　src/redis-server

　　[root@localhost redis-2.2.12]# src/redis-server

　　[6246] 05 Aug 19:17:22 # Warning: no config file specified, using the default config. In order to specify a config file use ‘redis-server /path/to/redis.conf‘

　　[6246] 05 Aug 19:17:22 * Server started, Redis version 2.2.12

　　[6246] 05 Aug 19:17:22 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add ‘vm.overcommit_memory = 1‘ to /etc/sysctl.conf and then reboot or run the command ‘sysctl vm.overcommit_memory=1‘ for this to take effect.

　　[6246] 05 Aug 19:17:22 * The server is now ready to accept connections on port 6379

　　[6246] 05 Aug 19:17:22 - 0 clients connected (0 slaves), 539544 bytes in use

　　Redis 服务端的默认连接port是 6379。

使用指定配置文件启动

src/redis-server redis.conf

　　步骤四: 将Redis作为 Linux 服务随机启动

　　vi /etc/rc.local, 使用vi编辑器打开随机启动配置文件，并在当中增加以下一行代码。

　　/root/4setup/redis-2.2.12/src/redis-server

　　步骤五: client连接验证

　　新打开一个Session输入：src/redis-cli，假设出现以下提示，那么您就能够開始Redis之旅了。

　　[root@localhost redis-2.2.12]# src/redis-cli

　　redis 127.0.0.1:6379>

　　步骤六: 查看Redis日志

　　查看server端session。就可以对Redis的执行状况进行查看或分析了。

　　[6246] 05 Aug 19:24:33 - 0 clients connected (0 slaves), 539544 bytes in use

　　[6246] 05 Aug 19:24:37 - Accepted 127.0.0.1:51381

　　[6246] 05 Aug 19:24:38 - 1 clients connected (0 slaves), 547372 bytes in use

　　以上的几个步骤就OK了!!这样一个简单的Redis数据库就能够畅通无阻地执行起来了。

　　步骤七: 停止Redis实例

　　最简单的方法是在启动实例的session中，直接使用Control-C来将实例停止。

　　我们还能够用client来停止服务。如能够用shutdown来停止Redis实例, 详细例如以下:

　　[root@localhost redis-2.2.12]# src/redis-cli shutdown

三、配置Redis

使用配置文件启动：src/redis-server redis.conf

主要配置项：

Redis支持非常多的參数，但都有默认值。

　　●daemonize:

　　默认情况下，redis不是在后台执行的，假设须要在后台执行，把该项的值更改为yes。

　　●pidfile

　　当Redis在后台执行的时候，Redis默认会把pid文件放在/var/run/redis.pid，你能够配置到其它地址。当执行多个redis服务时，须要指定不同的pid文件和port。

　　●bind

　　指定Redis仅仅接收来自于该IP地址的请求。假设不进行设置。那么将处理全部请求，在生产环境中最好设置该项。

　　●port

　　监听port。默觉得6379。

　　●timeout

　　设置client连接时的超时时间，单位为秒。

当client在这段时间内没有发出不论什么指令。那么关闭该连接。

　　●loglevel

　　log等级分为4级，debug, verbose, notice, 和warning。

生产环境下一般开启notice。

　　●logfile

　　配置log文件地址，默认使用标准输出，即打印在命令行终端的窗体上。

　　●databases

　　设置数据库的个数，能够使用SELECT 命令来切换数据库。默认使用的数据库是0。

　　●save

　　设置Redis进行数据库镜像的频率。

　　if(在60秒之内有10000个keys发生变化时){

　　进行镜像备份

　　}else if(在300秒之内有10个keys发生了变化){

　　进行镜像备份

　　}else if(在900秒之内有1个keys发生了变化){

　　进行镜像备份

　　}

　　●rdbcompression

　　在进行镜像备份时。是否进行压缩。

　　●dbfilename

　　镜像备份文件的文件名称。

　　●dir

　　数据库镜像备份的文件放置的路径。这里的路径跟文件名称要分开配置是由于Redis在进行备份时，先会将当前数据库的状态写入到一个暂时文件里。等备份完毕时，再把该该暂时文件替换为上面所指定的文件，而这里的暂时文件和上面所配置的备份文件都会放在这个指定的路径其中。

　　●slaveof

　　设置该数据库为其它数据库的从数据库。

　　●masterauth

　　当主数据库连接须要password验证时，在这里指定。

　　●requirepass

　　设置client连接后进行不论什么其它指定前须要使用的password。警告：由于redis速度相当快。所以在一台比較好的server下，一个外部的用户能够在一秒钟进行150K次的password尝试，这意味着你须要指定很很强大的password来防止暴力破解。

　　●maxclients

　　限制同一时候连接的客户数量。

当连接数超过这个值时，redis将不再接收其它连接请求。client尝试连接时将收到error信息。

　　●maxmemory

　　设置redis可以使用的最大内存。当内存满了的时候，假设还接收到set命令，redis将先尝试剔除设置过expire信息的key，而无论该key的过期时间还没有到达。在删除时，将依照过期时间进行删除。最早将要被过期的key将最先被删除。假设带有expire信息的key都删光了。那么将返回错误。

这样。redis将不再接收写请求，仅仅接收get请求。maxmemory的设置比較适合于把redis当作于类似memcached的缓存来使用。

　　●appendonly

　　默认情况下。redis会在后台异步的把数据库镜像备份到磁盘，可是该备份是非常耗时的，并且备份也不能非常频繁。假设发生诸如拉闸限电、拔插头等状况，那么将造成比較大范围的数据丢失。所以redis提供了第二种更加高效的数据库备份及灾难恢复方式。

开启append only模式之后，redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件里。当redis又一次启动时。会从该文件恢复出之前的状态。

可是这样会造成appendonly.aof文件过大，所以redis还支持了BGREWRITEAOF指令，对appendonly.aof进行又一次整理。

所以我觉得推荐生产环境下的做法为关闭镜像。开启appendonly.aof，同一时候能够选择在訪问较少的时间每天对appendonly.aof进行重写一次。

　　●appendfsync

　　设置对appendonly.aof文件进行同步的频率。always表示每次有写操作都进行同步，everysec表示对写操作进行累积，每秒同步一次。这个须要依据实际业务场景进行配置。

　　●vm-enabled

　　是否开启虚拟内存支持。由于redis是一个内存数据库，并且当内存满的时候，无法接收新的写请求，所以在redis 2.0中，提供了虚拟内存的支持。可是须要注意的是，redis中，全部的key都会放在内存中，在内存不够时，仅仅会把value值放入交换区。这样保证了尽管使用虚拟内存，但性能基本不受影响，同一时候，你须要注意的是你要把vm-max-memory设置到足够来放下你的全部的key。

　　●vm-swap-file

　　设置虚拟内存的交换文件路径。

　　●vm-max-memory

　　这里设置开启虚拟内存之后。redis将使用的最大物理内存的大小。默觉得0，redis将把他全部的能放到交换文件的都放到交换文件里。以尽量少的使用物理内存。在生产环境下，须要依据实际情况设置该值，最好不要使用默认的0。

　　●vm-page-size

　　设置虚拟内存的页大小。假设你的value值比較大。比方说你要在value中放置博客、新闻之类的全部文章内容，就设大一点，假设要放置的都是非常小的内容，那就设小一点。

　　●vm-pages

　　设置交换文件的总的page数量，须要注意的是，page table信息会放在物理内存中，每8个page就会占领RAM中的1个byte。总的虚拟内存大小 = vm-page-size * vm-pages。

　　●vm-max-threads

　　设置VM IO同一时候使用的线程数量。由于在进行内存交换时，对数据有编码和解码的过程。所以虽然IO设备在硬件上本上不能支持非常多的并发读写，可是还是假设你所保存的vlaue值比較大。将该值设大一些。还是可以提升性能的。

　　●glueoutputbuf

　　把小的输出缓存放在一起。以便可以在一个TCP packet中为client发送多个响应。详细原理和真实效果我不是非常清楚。所以依据凝视，你不是非常确定的时候就设置成yes。

　　●hash-max-zipmap-entries

　　在redis 2.0中引入了hash数据结构。当hash中包括超过指定元素个数而且最大的元素没有超过临界时，hash将以一种特殊的编码方式(大大降低内存使用)来存储。这里能够设置这两个临界值。

　　●activerehashing

　　开启之后。redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行又一次hash，可以减少内存的使用。当你的使用场景中。有很严格的实时性须要，不可以接受Redis时不时的对请求有2毫秒的延迟的话。把这项配置为no。假设没有这么严格的实时性要求，可以设置为yes。以便可以尽可能快的释放内存。

四、操作Redis

1、插入数据

　　redis 127.0.0.1:6379> set name wwl

　　OK

　　设置一个key-value对。

　　2、查询数据

　　redis 127.0.0.1:6379> get name

　　"wwl"

　　取出key所相应的value。

　　3、删除键值

　　redis 127.0.0.1:6379> del name

　　删除这个key及相应的value。

　　4、验证键是否存在

　　redis 127.0.0.1:6379> exists name

　　(integer) 0

　　当中0，代表此key不存在;1代表存在。

五、各类型的基本操作

1）strings类型及操作

　　string是最简单的类型，你能够理解成与Memcached是一模一样的类型，一个key相应一个value。其上支持的操作与Memcached的操作类似。

但它的功能更丰富。

　　string类型是二进制安全的。意思是redis的string能够包括不论什么数据，比方jpg图片或者序列化的对象。从内部实现来看事实上string能够看作byte数组，最大上限是1G字节，以下是string类型的定义:

　　struct sdshdr {

　　long len;

　　long free;

　　char buf[];

　　};

　　len是buf数组的长度。

　　free是数组中剩余可用字节数，由此能够理解为什么string类型是二进制安全的了，由于它本质上就是个byte数组。当然能够包括不论什么数据了

　　buf是个char数组用于存贮实际的字符串内容，事实上char和c#中的byte是等价的。都是一个字节。

　　另外string类型能够被部分命令按int处理.比方incr等命令，假设仅仅用string类型。redis就能够被看作加上持久化特性的memcached。

当然redis对string类型的操作比memcached还是多非常多的，详细操作方法例如以下：

　　1、set

　　设置key相应的值为string类型的value。

　　比如我们加入一个name= HongWan的键值对。能够这样做:

　　redis 127.0.0.1:6379> set name HongWan

　　OK

　　redis 127.0.0.1:6379>

　　2、setnx

　　设置key相应的值为string类型的value。

假设key已经存在。返回0，nx是not exist的意思。

　　比如我们加入一个name= HongWan_new的键值对。能够这样做:

　　redis 127.0.0.1:6379> get name

　　"HongWan"

　　redis 127.0.0.1:6379> setnx name HongWan_new

　　(integer) 0

　　redis 127.0.0.1:6379> get name

　　"HongWan"

　　redis 127.0.0.1:6379>

　　因为原来name有一个相应的值。所以本次的改动不生效，且返回码是0。

　　3、setex

　　设置key相应的值为string类型的value，并指定此键值相应的有效期。

　　比如我们加入一个haircolor= red的键值对，并指定它的有效期是10秒，能够这样做:

　　redis 127.0.0.1:6379> setex haircolor 10 red

　　OK

　　redis 127.0.0.1:6379> get haircolor

　　"red"

　　redis 127.0.0.1:6379> get haircolor

　　(nil)

　　redis 127.0.0.1:6379>

　　可见因为最后一次的调用是10秒以后了，所以取不到haicolor这个键相应的值。

　　4、setrange

　　设置指定key的value值的子字符串。

　　比如我们希望将HongWan的126邮箱替换为gmail邮箱。那么我们能够这样做:

　　redis 127.0.0.1:6379> get name

　　"HongWan@126.com"

　　redis 127.0.0.1:6379> setrange name 8 gmail.com

　　(integer) 17

　　redis 127.0.0.1:6379> get name

　　"HongWan@gmail.com"

　　redis 127.0.0.1:6379>

　　当中的8是指从下标为8(包括8)的字符開始替换

　　5、mset

　　一次设置多个key的值，成功返回ok表示全部的值都设置了，失败返回0表示没有不论什么值被设置。

　　redis 127.0.0.1:6379> mset key1 HongWan1 key2 HongWan2

　　OK

　　redis 127.0.0.1:6379> get key1

　　"HongWan1"

　　redis 127.0.0.1:6379> get key2

　　"HongWan2"

　　redis 127.0.0.1:6379>

　　6、msetnx

　　一次设置多个key的值，成功返回ok表示全部的值都设置了。失败返回0表示没有不论什么值被设置，可是不会覆盖已经存在的key。

　　redis 127.0.0.1:6379> get key1

　　"HongWan1"

　　redis 127.0.0.1:6379> get key2

　　"HongWan2"

　　redis 127.0.0.1:6379> msetnx key2 HongWan2_new key3 HongWan3

　　(integer) 0

　　redis 127.0.0.1:6379> get key2

　　"HongWan2"

　　redis 127.0.0.1:6379> get key3

　　(nil)

　　能够看出假设这条命令返回0，那么里面操作都会回滚，都不会被运行。

　　7、get

　　获取key相应的string值,假设key不存在返回nil。

　　比如我们获取一个库中存在的键name，能够非常快得到它相应的value

　　redis 127.0.0.1:6379> get name

　　"HongWan"

　　redis 127.0.0.1:6379>

　　我们获取一个库中不存在的键name1，那么它会返回一个nil以表时无此键值对

　　redis 127.0.0.1:6379> get name1

　　(nil)

　　redis 127.0.0.1:6379>

　　8、getset

　　设置key的值。并返回key的旧值。

　　redis 127.0.0.1:6379> get name

　　"HongWan"

　　redis 127.0.0.1:6379> getset name HongWan_new

　　"HongWan"

　　redis 127.0.0.1:6379> get name

　　"HongWan_new"

　　redis 127.0.0.1:6379>

　　接下来我们看一下假设key不存的时候会什么样儿?

　　redis 127.0.0.1:6379> getset name1 aaa

　　(nil)

　　redis 127.0.0.1:6379>

　　可见。假设key不存在，那么将返回nil

　　9、getrange

　　获取指定key的value值的子字符串。

　　详细样比例如以下:

　　redis 127.0.0.1:6379> get name

　　"HongWan@126.com"

　　redis 127.0.0.1:6379> getrange name 0 6

　　"HongWan"

　　redis 127.0.0.1:6379>

　　字符串左面下标是从0開始的

　　redis 127.0.0.1:6379> getrange name -7 -1

　　"126.com"

　　redis 127.0.0.1:6379>

　　字符串右面下标是从-1開始的

　　redis 127.0.0.1:6379> getrange name 7 100

　　"@126.com"

　　redis 127.0.0.1:6379>

　　当下标超出字符串长度时，将默觉得是同方向的最大下标

　　10、mget

　　一次获取多个key的值。假设相应key不存在。则相应返回nil。

　　详细样比例如以下:

　　redis 127.0.0.1:6379> mget key1 key2 key3

　　1) "HongWan1"

　　2) "HongWan2"

　　3) (nil)

　　redis 127.0.0.1:6379>

　　key3因为没有这个键定义，所以返回nil。

　　11、incr

　　对key的值做加加操作,并返回新的值。注意incr一个不是int的value会返回错误，incr一个不存在的key，则设置key为1

　　redis 127.0.0.1:6379> set age 20

　　OK

　　redis 127.0.0.1:6379> incr age

　　(integer) 21

　　redis 127.0.0.1:6379> get age

　　"21"

　　redis 127.0.0.1:6379>

　　12、incrby

　　同incr类似。加指定值。key不存在时候会设置key。并觉得原来的value是 0

　　redis 127.0.0.1:6379> get age

　　"21"

　　redis 127.0.0.1:6379> incrby age 5

　　(integer) 26

　　redis 127.0.0.1:6379> get name

　　"HongWan@gmail.com"

　　redis 127.0.0.1:6379> get age

　　"26"

　　redis 127.0.0.1:6379>

　　13、decr

　　对key的值做的是减减操作，decr一个不存在key，则设置key为-1

　　redis 127.0.0.1:6379> get age

　　"26"

　　redis 127.0.0.1:6379> decr age

　　(integer) 25

　　redis 127.0.0.1:6379> get age

　　"25"

　　redis 127.0.0.1:6379>

　　14、decrby

　　同decr，减指定值。

　　redis 127.0.0.1:6379> get age

　　"25"

　　redis 127.0.0.1:6379> decrby age 5

　　(integer) 20

　　redis 127.0.0.1:6379> get age

　　"20"

　　redis 127.0.0.1:6379>

　　decrby全然是为了可读性，我们全然能够通过incrby一个负值来实现相同效果。反之中的一个样。

　　redis 127.0.0.1:6379> get age

　　"20"

　　redis 127.0.0.1:6379> incrby age -5

　　(integer) 15

　　redis 127.0.0.1:6379> get age

　　"15"

　　redis 127.0.0.1:6379>

　　15、append

　　给指定key的字符串值追加value,返回新字符串值的长度。

比如我们向name的值追加一个@126.com字符串，那么能够这样做:

　　redis 127.0.0.1:6379> append name @126.com

　　(integer) 15

　　redis 127.0.0.1:6379> get name

　　"HongWan@126.com"

　　redis 127.0.0.1:6379>

　　16、strlen

　　取指定key的value值的长度。

　　redis 127.0.0.1:6379> get name

　　"HongWan_new"

　　redis 127.0.0.1:6379> strlen name

　　(integer) 11

　　redis 127.0.0.1:6379> get age

　　"15"

　　redis 127.0.0.1:6379> strlen age

　　(integer) 2

　　redis 127.0.0.1:6379>

2）hash

Redis hash是一个string类型的field和value的映射表.它的加入、删除操作都是O(1)(平均)。hash特别适合用于存储对象。相较于将对象的每一个字段存成单个string类型。

将一个对象存储在hash类型中会占用更少的内存，而且能够更方便的存取整个对象。省内存的原因是新建一个hash对象时開始是用zipmap(又称为small hash)来存储的。这个zipmap事实上并非hash table，可是zipmap相比正常的hash实现能够节省不少hash本身须要的一些元数据存储开销。虽然zipmap的加入，删除，查找都是O(n)，可是因为一般对象的field数量都不太多。所以使用zipmap也是非常快的,也就是说加入删除平均还是O(1)。假设field或者value的大小超出一定限制后。Redis会在内部自己主动将zipmap替换成正常的hash实现. 这个限制能够在配置文件里指定

　　hash-max-zipmap-entries 64 #配置字段最多64个。

　　hash-max-zipmap-value 512 #配置value最大为512字节。

　　1、hset

　　设置hash field为指定值，假设key不存在，则先创建。

　　redis 127.0.0.1:6379> hset myhash field1 Hello

　　(integer) 1

　　redis 127.0.0.1:6379>

　　2、hsetnx

　　设置hash field为指定值。假设key不存在，则先创建。

假设field已经存在。返回0，nx是not exist的意思。

　　redis 127.0.0.1:6379> hsetnx myhash field "Hello"

　　(integer) 1

　　redis 127.0.0.1:6379> hsetnx myhash field "Hello"

　　(integer) 0

　　redis 127.0.0.1:6379>

　　第一次运行是成功的，但第二次运行同样的命令失败，原因是field已经存在了。

　　3、hmset

　　同一时候设置hash的多个field。

　　redis 127.0.0.1:6379> hmset myhash field1 Hello field2 World

　　OK

　　redis 127.0.0.1:6379>

　　4、hget

　　获取指定的hash field。

　　redis 127.0.0.1:6379> hget myhash field1

　　"Hello"

　　redis 127.0.0.1:6379> hget myhash field2

　　"World"

　　redis 127.0.0.1:6379> hget myhash field3

　　(nil)

　　redis 127.0.0.1:6379>

　　因为数据库没有field3，所以取到的是一个空值nil。

　　5、hmget

　　获取所有指定的hash filed。

　　redis 127.0.0.1:6379> hmget myhash field1 field2 field3

　　1) "Hello"

　　2) "World"

　　3) (nil)

　　redis 127.0.0.1:6379>

　　因为数据库没有field3。所以取到的是一个空值nil。

　　6、hincrby

　　指定的hash filed 加上给定值。

　　redis 127.0.0.1:6379> hset myhash field3 20

　　(integer) 1

　　redis 127.0.0.1:6379> hget myhash field3

　　"20"

　　redis 127.0.0.1:6379> hincrby myhash field3 -8

　　(integer) 12

　　redis 127.0.0.1:6379> hget myhash field3

　　"12"

　　redis 127.0.0.1:6379>

　　在本例中我们将field3的值从20降到了12，即做了一个减8的操作。

　　7、hexists

　　測试指定field是否存在。

　　redis 127.0.0.1:6379> hexists myhash field1

　　(integer) 1

　　redis 127.0.0.1:6379> hexists myhash field9

　　(integer) 0

　　redis 127.0.0.1:6379>

　　通过上例能够说明field1存在，但field9是不存在的。

　　8、hlen

　　返回指定hash的field数量。

　　redis 127.0.0.1:6379> hlen myhash

　　(integer) 4

　　redis 127.0.0.1:6379>

　　通过上例能够看到myhash中有4个field。

　　9、hdel

　　返回指定hash的field数量。

　　redis 127.0.0.1:6379> hlen myhash

　　(integer) 4

　　redis 127.0.0.1:6379> hdel myhash field1

　　(integer) 1

　　redis 127.0.0.1:6379> hlen myhash

　　(integer) 3

　　redis 127.0.0.1:6379>

　　10、hkeys

　　返回hash的全部field。

　　redis 127.0.0.1:6379> hkeys myhash

　　1) "field2"

　　2) "field"

　　3) "field3"

　　redis 127.0.0.1:6379>

　　说明这个hash中有3个field。

　　11、hvals

　　返回hash的全部value。

　　redis 127.0.0.1:6379> hvals myhash

　　1) "World"

　　2) "Hello"

　　3) "12"

　　redis 127.0.0.1:6379>

　　说明这个hash中有3个field。

　　12、hgetall

　　获取某个hash中所有的filed及value。

　　redis 127.0.0.1:6379> hgetall myhash

　　1) "field2"

　　2) "World"

　　3) "field"

　　4) "Hello"

　　5) "field3"

　　6) "12"

　　redis 127.0.0.1:6379>

　　可见，一下子将myhash中全部的field及相应的value都取出来了。

3）list

Redis的list类型事实上就是一个每一个子元素都是string类型的双向链表。链表的最大长度是(2的32次方)。我们能够通过push,pop操作从链表的头部或者尾部加入删除元素。这使得list既能够用作栈，也能够用作队列。

　　有意思的是list的pop操作还有堵塞版本号的。当我们[lr]pop一个list对象时。假设list是空。或者不存在，会马上返回nil。可是堵塞版本号的b[lr]pop能够则能够堵塞，当然能够加超时时间，超时后也会返回nil。

为什么要堵塞版本号的pop呢，主要是为了避免轮询。举个简单的样例假设我们用list来实现一个工作队列。

运行任务的thread能够调用堵塞版本号的pop去获取任务这样就能够避免轮询去检查是否有任务存在。

当任务来时候工作线程能够马上返回，也能够避免轮询带来的延迟。说了这么多，接下来看一下实际操作的方法吧：

　　1、lpush

　　在key相应list的头部加入字符串元素：

redis 127.0.0.1:6379> lpush mylist "world"
(integer) 1
redis 127.0.0.1:6379> lpush mylist "hello"
(integer) 2
redis 127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "world"
redis 127.0.0.1:6379>

　　在此处我们先插入了一个world，然后在world的头部插入了一个hello。当中lrange是用于取mylist的内容。

　　2、rpush

　　在key相应list的尾部加入字符串元素：

redis 127.0.0.1:6379> rpush mylist2 "hello"
(integer) 1
redis 127.0.0.1:6379> rpush mylist2 "world"
(integer) 2
redis 127.0.0.1:6379> lrange mylist2 0 -1
1) "hello"
2) "world"
redis 127.0.0.1:6379>

　　在此处我们先插入了一个hello。然后在hello的尾部插入了一个world。

　　3、linsert

　　在key相应list的特定位置之前或之后加入字符串元素：

redis 127.0.0.1:6379> rpush mylist3 "hello"
(integer) 1
redis 127.0.0.1:6379> rpush mylist3 "world"
(integer) 2
redis 127.0.0.1:6379> linsert mylist3 before "world" "there"
(integer) 3
redis 127.0.0.1:6379> lrange mylist3 0 -1
1) "hello"
2) "there"
3) "world"
redis 127.0.0.1:6379>

　　在此处我们先插入了一个hello，然后在hello的尾部插入了一个world，然后又在world的前面插入了there。

　　4、lset

　　设置list中指定下标的元素值(下标从0開始)：

redis 127.0.0.1:6379> rpush mylist4 "one"
(integer) 1
redis 127.0.0.1:6379> rpush mylist4 "two"
(integer) 2
redis 127.0.0.1:6379> rpush mylist4 "three"
(integer) 3
redis 127.0.0.1:6379> lset mylist4 0 "four"
OK
redis 127.0.0.1:6379> lset mylist4 -2 "five"
OK
redis 127.0.0.1:6379> lrange mylist4 0 -1
1) "four"
2) "five"
3) "three"
redis 127.0.0.1:6379>

　　在此处我们依次插入了one,two,three，然后将标是0的值设置为four，再将下标是-2的值设置为five。

　　5、lrem

　　从key相应list中删除count个和value同样的元素。

　　count>0时，按从头到尾的顺序删除，详细例如以下：

redis 127.0.0.1:6379> rpush mylist5 "hello"
(integer) 1
redis 127.0.0.1:6379> rpush mylist5 "hello"
(integer) 2
redis 127.0.0.1:6379> rpush mylist5 "foo"
(integer) 3
redis 127.0.0.1:6379> rpush mylist5 "hello"
(integer) 4
redis 127.0.0.1:6379> lrem mylist5 2 "hello"
(integer) 2
redis 127.0.0.1:6379> lrange mylist5 0 -1
1) "foo"
2) "hello"
redis 127.0.0.1:6379>

　　count<0时，按从尾到头的顺序删除，详细例如以下：

redis 127.0.0.1:6379> rpush mylist6 "hello"
(integer) 1
redis 127.0.0.1:6379> rpush mylist6 "hello"
(integer) 2
redis 127.0.0.1:6379> rpush mylist6 "foo"
(integer) 3
redis 127.0.0.1:6379> rpush mylist6 "hello"
(integer) 4
redis 127.0.0.1:6379> lrem mylist6 -2 "hello"
(integer) 2
redis 127.0.0.1:6379> lrange mylist6 0 -1
1) "hello"
2) "foo"
redis 127.0.0.1:6379>

　　count=0时。删除所有，详细例如以下：

redis 127.0.0.1:6379> rpush mylist7 "hello"
(integer) 1
redis 127.0.0.1:6379> rpush mylist7 "hello"
(integer) 2
redis 127.0.0.1:6379> rpush mylist7 "foo"
(integer) 3
redis 127.0.0.1:6379> rpush mylist7 "hello"
(integer) 4
redis 127.0.0.1:6379> lrem mylist7 0 "hello"
(integer) 3
redis 127.0.0.1:6379> lrange mylist7 0 -1
1) "foo"
redis 127.0.0.1:6379>

　　6、ltrim

　　保留指定key 的值范围内的数据：

redis 127.0.0.1:6379> rpush mylist8 "one"
(integer) 1
redis 127.0.0.1:6379> rpush mylist8 "two"
(integer) 2
redis 127.0.0.1:6379> rpush mylist8 "three"
(integer) 3
redis 127.0.0.1:6379> rpush mylist8 "four"
(integer) 4
redis 127.0.0.1:6379> ltrim mylist8 1 -1
OK
redis 127.0.0.1:6379> lrange mylist8 0 -1
1) "two"
2) "three"
3) "four"
redis 127.0.0.1:6379>

　　7、lpop

　　从list的头部删除元素，并返回删除元素：

redis 127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "world"
redis 127.0.0.1:6379> lpop mylist
"hello"
redis 127.0.0.1:6379> lrange mylist 0 -1
1) "world"
redis 127.0.0.1:6379>

　　8、rpop

　　从list的尾部删除元素。并返回删除元素：

redis 127.0.0.1:6379> lrange mylist2 0 -1
1) "hello"
2) "world"
redis 127.0.0.1:6379> rpop mylist2
"world"
redis 127.0.0.1:6379> lrange mylist2 0 -1
1) "hello"
redis 127.0.0.1:6379>

　　9、rpoplpush

　　从第一个list的尾部移除元素并加入到第二个list的头部,最后返回被移除的元素值，整个操作是原子的.假设第一个list是空或者不存在返回nil：

redis 127.0.0.1:6379> lrange mylist5 0 -1
1) "three"
2) "foo"
3) "hello"
redis 127.0.0.1:6379> lrange mylist6 0 -1
1) "hello"
2) "foo"
redis 127.0.0.1:6379> rpoplpush mylist5 mylist6
"hello"
redis 127.0.0.1:6379> lrange mylist5 0 -1
1) "three"
2) "foo"
redis 127.0.0.1:6379> lrange mylist6 0 -1
1) "hello"
2) "hello"
3) "foo"
redis 127.0.0.1:6379>

　　10、lindex

　　返回名称为key的list中index位置的元素：

redis 127.0.0.1:6379> lrange mylist5 0 -1
1) "three"
2) "foo"
redis 127.0.0.1:6379> lindex mylist5 0
"three"
redis 127.0.0.1:6379> lindex mylist5 1
"foo"
redis 127.0.0.1:6379>

　　11、llen

　　返回key相应list的长度：

redis 127.0.0.1:6379> llen mylist5
(integer) 2
redis 127.0.0.1:6379>

4）sets

Redis的set是string类型的无序集合。

set元素最大能够包括(2的32次方)个元素。

　　set的是通过hash table实现的，所以加入、删除和查找的复杂度都是O(1)。

hash table会随着加入或者删除自己主动的调整大小。须要注意的是调整hash table大小时候须要同步(获取写锁)会堵塞其它读写操作。可能不久后就会改用跳表(skip list)来实现，跳表已经在sorted set中使用了。

关于set集合类型除了主要的加入删除操作，其它实用的操作还包括集合的取并集(union)。交集(intersection)，差集(difference)。通过这些操作能够非常easy的实现sns中的好友推荐和blog的tag功能。以下具体介绍set相关命令：

　　1、sadd

　　向名称为key的set中加入元素：

　　redis 127.0.0.1:6379> sadd myset "hello"

　　(integer) 1

　　redis 127.0.0.1:6379> sadd myset "world"

　　(integer) 1

　　redis 127.0.0.1:6379> sadd myset "world"

　　(integer) 0

　　redis 127.0.0.1:6379> smembers myset

　　1) "world"

　　2) "hello"

　　redis 127.0.0.1:6379>

　　本例中，我们向myset中加入了三个元素。但因为第三个元素跟第二个元素是同样的。所以第三个元素没有加入成功。最后我们用smembers来查看myset中的全部元素。

　　2、srem

　　删除名称为key的set中的元素member：

　　redis 127.0.0.1:6379> sadd myset2 "one"

　　(integer) 1

　　redis 127.0.0.1:6379> sadd myset2 "two"

　　(integer) 1

　　redis 127.0.0.1:6379> sadd myset2 "three"

　　(integer) 1

　　redis 127.0.0.1:6379> srem myset2 "one"

　　(integer) 1

　　redis 127.0.0.1:6379> srem myset2 "four"

　　(integer) 0

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379>

　　本例中，我们向myset2中加入了三个元素后，再调用srem来删除one和four，但因为元素中没有four所以。此条srem命令运行失败。

　　3、spop

　　随机返回并删除名称为key的set中一个元素：

　　本例中，我们向myset3中加入了三个元素后，再调用spop来随机删除一个元素。能够看到three元素被删除了。

　　4、sdiff

　　返回全部给定key与第一个key的差集：

　　本例中，我们能够看到myset2中的元素与myset3中不同的仅仅是three，所以仅仅有three被查出来了。而不是three和one。由于one是myset3的元素。

　　我们也能够将myset2和myset3换个顺序来看一下结果：

　　redis 127.0.0.1:6379> sdiff myset3 myset2

　　1) "one"

　　redis 127.0.0.1:6379>

　　这个结果中仅仅显示了，myset3中的元素与myset2中不同的元素。

　　5、sdiffstore

　　返回全部给定key与第一个key的差集，并将结果存为还有一个key：

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> sdiffstore myset4 myset2 myset3

　　(integer) 1

　　redis 127.0.0.1:6379> smembers myset4

　　1) "three"

　　redis 127.0.0.1:6379>

　　6、sinter

　　返回全部给定key的交集：

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> sinter myset2 myset3

　　1) "two"

　　redis 127.0.0.1:6379>

　　通过本例的结果能够看出, myset2和myset3的交集two被查出来了。

　　7、sinterstore

　　返回全部给定key的交集。并将结果存为还有一个key

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> sinterstore myset5 myset2 myset3

　　(integer) 1

　　redis 127.0.0.1:6379> smembers myset5

　　1) "two"

　　redis 127.0.0.1:6379>

　　通过本例的结果能够看出, myset2和myset3的交集被保存到myset5中了

　　8、sunion

　　返回全部给定key的并集

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> sunion myset2 myset3

　　1) "three"

　　2) "one"

　　3) "two"

　　redis 127.0.0.1:6379>

　　通过本例的结果能够看出, myset2和myset3的并集被查出来了

　　9、sunionstore

　　返回全部给定key的并集，并将结果存为还有一个key

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> sunionstore myset6 myset2 myset3

　　(integer) 3

　　redis 127.0.0.1:6379> smembers myset6

　　1) "three"

　　2) "one"

　　3) "two"

　　redis 127.0.0.1:6379>

　　通过本例的结果能够看出, myset2和myset3的并集被保存到myset6中了

　　10、smove

　　从第一个key相应的set中移除member并加入到第二个相应set中

　　redis 127.0.0.1:6379> smembers myset2

　　1) "three"

　　2) "two"

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> smove myset2 myset7 three

　　(integer) 1

　　redis 127.0.0.1:6379> smembers myset7

　　1) "three"

　　redis 127.0.0.1:6379>

　　通过本例能够看到，myset2的three被移到myset7中了

　　11、scard

　　返回名称为key的set的元素个数

　　redis 127.0.0.1:6379> scard myset2

　　(integer) 1

　　redis 127.0.0.1:6379>

　　通过本例能够看到。myset2的成员数量为1

　　12、sismember

　　測试member是否是名称为key的set的元素

　　redis 127.0.0.1:6379> smembers myset2

　　1) "two"

　　redis 127.0.0.1:6379> sismember myset2 two

　　(integer) 1

　　redis 127.0.0.1:6379> sismember myset2 one

　　(integer) 0

　　redis 127.0.0.1:6379>

　　通过本例能够看到，two是myset2的成员，而one不是。

　　13、srandmember

　　随机返回名称为key的set的一个元素，可是不删除元素

　　redis 127.0.0.1:6379> smembers myset3

　　1) "two"

　　2) "one"

　　redis 127.0.0.1:6379> srandmember myset3

　　"two"

　　redis 127.0.0.1:6379> srandmember myset3

　　"one"

　　redis 127.0.0.1:6379>

5）sorted sets

和set一样sorted set也是string类型元素的集合，不同的是每一个元素都会关联一个double类型的score。sorted set的实现是skip list和hash table的混合体。

　　当元素被加入到集合中时，一个元素到score的映射被加入到hash table中，所以给定一个元素获取score的开销是O(1),还有一个score到元素的映射被加入到skip list，并依照score排序，所以就能够有序的获取集合中的元素。加入，删除操作开销都是O(log(N))和skip list的开销一致,redis的skip list实现用的是双向链表,这样就能够逆序从尾部取元素。

sorted set最常常的使用方式应该是作为索引来使用.我们能够把要排序的字段作为score存储。对象的id当元素存储。

以下是sorted set相关命令

　　1、zadd

　　向名称为key的zset中加入元素member，score用于排序。假设该元素已经存在。则依据score更新该元素的顺序

　　redis 127.0.0.1:6379> zadd myzset 1 "one"

　　(integer) 1

　　redis 127.0.0.1:6379> zadd myzset 2 "two"

　　(integer) 1

　　redis 127.0.0.1:6379> zadd myzset 3 "two"

　　(integer) 0

　　redis 127.0.0.1:6379> zrange myzset 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "3"

　　redis 127.0.0.1:6379>

　　本例中我们向myzset中加入了one和two。而且two被设置了2次，那么将以最后一次的设置为准，最后我们将全部元素都显示出来并显示出了元素的score。

　　2、zrem

　　删除名称为key的zset中的元素member

　　redis 127.0.0.1:6379> zrange myzset 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "3"

　　redis 127.0.0.1:6379> zrem myzset two

　　(integer) 1

　　redis 127.0.0.1:6379> zrange myzset 0 -1 withscores

　　1) "one"

　　2) "1"

　　redis 127.0.0.1:6379>

　　能够看到two被删除了

　　3、zincrby

　　假设在名称为key的zset中已经存在元素member。则该元素的score添加increment;否则向集合中加入该元素。其score的值为increment

　　redis 127.0.0.1:6379> zadd myzset2 1 "one"

　　(integer) 1

　　redis 127.0.0.1:6379> zadd myzset2 2 "two"

　　(integer) 1

　　redis 127.0.0.1:6379> zincrby myzset2 2 "one"

　　"3"

　　redis 127.0.0.1:6379> zrange myzset2 0 -1 withscores

　　1) "two"

　　2) "2"

　　3) "one"

　　4) "3"

　　redis 127.0.0.1:6379>

　　本例中将one的score从1添加了2，添加到了3

　　4、zrank

　　返回名称为key的zset中member元素的排名(按score从小到大排序)即下标

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zrank myzset3 two

　　(integer) 1

　　redis 127.0.0.1:6379>

　　本例中将two的下标是1，我这里取的是下标，而不是score

　　5、zrevrank

　　返回名称为key的zset中member元素的排名(按score从大到小排序)即下标

　　按从大到小排序的话two是第三个元素。下标是2

　　6、zrevrange

　　返回名称为key的zset(按score从大到小排序)中的index从start到end的全部元素

　　redis 127.0.0.1:6379> zrevrange myzset3 0 -1 withscores

　　1) "five"

　　2) "5"

　　3) "three"

　　4) "3"

　　5) "two"

　　6) "2"

　　7) "one"

　　8) "1"

　　redis 127.0.0.1:6379>

　　首先按score从大到小排序，再取出所有元素

　　7、zrangebyscore

　　返回集合中score在给定区间的元素

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zrangebyscore myzset3 2 3 withscores

　　1) "two"

　　2) "2"

　　3) "three"

　　4) "3"

　　redis 127.0.0.1:6379>

　　本例中，返回了score在2~3区间的元素

　　8、zcount

　　返回集合中score在给定区间的数量

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zcount myzset3 2 3

　　(integer) 2

　　redis 127.0.0.1:6379>

　　本例中。计算了score在2~3之间的元素数目

　　9、zcard

　　返回集合中元素个数

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zcard myzset3

　　(integer) 4

　　redis 127.0.0.1:6379>

　　从本例看出myzset3这个集全的元素数量是4

　　10、zscore

　　返回给定元素相应的score

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zscore myzset3 two

　　"2"

　　redis 127.0.0.1:6379>

　　此例中我们成功的将two的score取出来了。

　　11、zremrangebyrank

　　删除集合中排名在给定区间的元素

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　7) "five"

　　8) "5"

　　redis 127.0.0.1:6379> zremrangebyrank myzset3 3 3

　　(integer) 1

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　redis 127.0.0.1:6379>

　　在本例中我们将myzset3中按从小到大排序结果的下标为3的元素删除了。

　　12、zremrangebyscore

　　删除集合中score在给定区间的元素

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "one"

　　2) "1"

　　3) "two"

　　4) "2"

　　5) "three"

　　6) "3"

　　redis 127.0.0.1:6379> zremrangebyscore myzset3 1 2

　　(integer) 2

　　redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores

　　1) "three"

　　2) "3"

　　redis 127.0.0.1:6379>

　　在本例中我们将myzset3中按从小到大排序结果的score在1~2之间的元素删除了。

redis cmd 使用样例

标签：shu comment err gzip return ip地址 aof文件服务端方式

原文地址：http://www.cnblogs.com/mthoutai/p/7221767.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行