redis基本使用

一、redis安装

1、ubuntu在线安装

root@bogon:~# apt-get install redis-server
root@bogon:~# ps -aux|grep redis
root@bogon:~# netstat -nlt|grep 6379 
root@bogon:~# /etc/init.d/redis-server status
root@bogon:~# redis-cli
127.0.0.1:6379> set a 111
OK
127.0.0.1:6379> get a
"111"
root@bogon:~# apt-get install php7.2-redis
root@bogon:~# find / -name php.ini
root@bogon:~# vim /etc/php/7.2/apache2/php.ini
添加extension=redis.so
root@bogon:~# /etc/init.d/apache2 restart  重启apache服务器
root@bogon:~# vim /etc/redis/redis.conf
requirepass 123456 取消注释，修改密码为123456
root@bogon:~# /etc/init.d/redis-server restart 重启redis服务器

2、源码包的位置一般放在 /usr/local/src 里面
安装步骤：
（1）cd /usr/local/src
（2）tar -zxvf redis-4.0.9.tar.gz
（3）cd ./redis-4.0.9
（4）(不需要编译安装，直接使用make命令)
（5）make
（6）make PREFIX=/usr/local/redis install（安装redis服务到指定目录）
（7）mkdir /etc/redis（给redis创建一个配置文件的目录，一般配置文件在/etc目录下）
（8）cp redis.conf /etc/redis/ （复制redis配置文件）
（9）cd /usr/local/redis/bin（里面有redis服务命令）
（10） ./redis-server（启动服务端，前面一定要加 ./，必须进入bin目录）
（11）（将第10步服务关闭，将redis服务改为后台运行）
（12） ./redis-server /etc/redis/redis.conf

问题点1：如何让redis服务在后台运行
解决：修改redis配置文件
vim /etc/redis/redis.conf
将daemonize no 改为daemonize yes
问题点2：如何查看redis服务开启成功
解决：（1）使用ps命令 ：ps axu | grep redis-server

（2）使用netstat命令： netstat -tunple | grep 6379

问题点3：如何关闭后台的redis服务
解决：使用pkill命令： pkill -9 redis-server

使用客户端连接 ./redis-cli -h 192.168.. -p 6379

二、redis数据类型

1、string类型

适合最简单的k-v存储，类似于memcached的存储结构，短信验证码，配置信息等，就用这种类型来存储
(1) set和get命令

127.0.0.1:6379> set username chaoyang
OK
127.0.0.1:6379> get username
"chaoyang"

(2) incr：自增，对某个key的value值进行自增+1

127.0.0.1:6379> set age 23
OK
127.0.0.1:6379> get age
"23"
127.0.0.1:6379> incr age
(integer) 24
127.0.0.1:6379> get age
"24"

(3) decr：自减，对某个key的value进行自减1

127.0.0.1:6379> get age
"24"
127.0.0.1:6379> decr age
(integer) 23
127.0.0.1:6379> get age
"23"

(4) incrby：指定自增的数字 （age+5）

127.0.0.1:6379> get age
"23"
127.0.0.1:6379> incrby age 5
(integer) 28
127.0.0.1:6379> get age
"28"

(5) decrby：指定自减数字 （age-8）

127.0.0.1:6379> get age
"28"
127.0.0.1:6379> decrby age 8
(integer) 20
127.0.0.1:6379> get age
"20"

(6) keys：获取所有的key

127.0.0.1:6379> keys *
 "age"
 "name"
"username"

问题点1：redis的key一般是怎么设计的？有一张数据表，怎么把表的数据存到redis中？
有一张数据库表it_user，主键是id

id	username	age
1	Tom	36
2	Mark	45

解决：
①把表名作为key的前缀（it_user）
②把表的主键字段放在①中前缀的后面，一般用冒号分割(it_user:id)
③对应记录的主键值作为key的第三部分(it_user:id :1)
④把mysql的其他字段名作为第4部分(it_user:id :1:username、it_user:id :1:age)
⑤把表里的数据存到redis里

    127.0.0.1:6379>set it_user:id :1:username Tom
    127.0.0.1:6379> set it_user:id :1:age 36
    127.0.0.1:6379> set it_user:id :2:username  Mark
    127.0.0.1:6379> set it_user:id :2:age 45

⑥获取用户id为1的所有的字段信息

    127.0.0.1:6379> keys it_user :id:1:*

2、hash类型

一般key为ID或者唯一标示，value对应的就是详情了。如商品详情，个人信息详情，新闻详情等
hash类型类似于php的关联数组，形成这样的数组

   $userInfo=array('name'=>'asion','age'=>12,'email'=>'[email protected]','hobby'=>'sing');

(1) hset命令：设置单个值

127.0.0.1:6379> hset userInfo age 12
(integer) 1

(2) hget命令：获取单个值

127.0.0.1:6379> hget userInfo age
"12"

(3) hmset命令 ：设置多个值

127.0.0.1:6379> hmset userInfo email [email protected] hobby sing
OK

(4) hgetall命令 ：获取hash全部的值

127.0.0.1:6379> hgetall userInfo
1) "name"
2) "asion"
3) "age"
4) "12"
5) "email"
6) "[email protected]"
7) "hobby"
8) "sing"

3、list类型

因为list是有序的，适合根据写入的时间来排序，如：最新的***，消息队列等
列表最多可存储 232 - 1 元素 (4294967295, 每个列表可存储40多亿)
redis的list类型被称为链表类型，链表概图如下：

(1) lpush命令：从链表的头部放入数据(A->B->C)

(2) rpush命令：从链表的尾部放入数据(C->B->A)

(3) lrange命令：返回链表中指定区间的元素，其中0表示第一个元素，1表示第二个元素，以此类推，
也可以用负数下标，-1表示列表最后一个元素，-2表示链表倒数第二个元素

(4) lpop命令:弹出链表最左侧（头部）的数据，弹出数据后，链表中就不存在该数据了

(5) rpop命令：与lpop相反，弹出链表最右侧（最后一个）的数据

问题点1：链表数据结构应用于哪些实际项目
例如：统计最近登录的10个用户
（1）如果使用mysql统计，则sql如下：select * from user order by logintime desc limit 10;
（2）换成redis实现：创建一个list类型，从链表最左侧添加新登录的用户主键ID，如果链表中的单元超过10个，只需要把最右侧的单元弹出即可

4、set类型：无序集合

可以简单的理解为ID-List的模式，如微博中一个人有哪些好友，set最牛的地方在于，可以对两个set提供交集、并集、差集操作。例
如：查找两个人共同的好友等
redis的set类型被成为集合类型
set集合满足三个特点：①无序性：集合里面的数据是没有顺序的
②唯一性：集合里面的数据是唯一性，不可重复的
③确定性：集合里面的个数是确定的
set集合概图：

集合常见运算：
①交集（A∩B）：集合公共的部分，集合A和集合B的交集是2
②并集（A∪B）：集合全部的部分，集合A和集合B的并集是1 2 3
③差集（A-B）：A-B在集合A里面出现，但不能再集合B里面出现,集合A-集合B的结果是 1
(1) sadd：向集合里面添加元素

(2) smembers：获取集合的元素

(3) srem:移除集合中一个或多个元素

(4)spop：随机弹出某一个元素

集合的实际使用场景：一般redis的集合用于社交类型的网站里面做好友关系的展示
例如实现好友的推荐、共同好友…
案例：
①设计四个用户

②设计好友的集合
用户id为3的好友为1 、2

用户id为45的好友为2、3

③求取好友关系
获取3号和45号的共同好友（求交集） sinter

获取3号和45号的全部好友（求并集） sunion
3号给45号推荐好友（求差集） sdiff

5、zset类型：有序集合

比较适合类似于top 10等不根据插入的时间来排序的数据
zset 和 set 一样也是string类型元素的集合,且不允许重复的成员，不同的是每个元素都会关联一个double类型的分数。redis正是通过分数（即上面说的权重）来为集合中的成员进行从小到大的排序。
有序集合特点：①有序性 ②唯一性 ③确定性
有序集合概图：

(1)zadd命令：添加集合元素，如果元素存在则更新对应的权重

(2)zrange命令：获取集合元素

(3)zscore命令：命令返回有序集中成员的分数值（自己理解是返回成员的权重信息）

三、php操作redis

1、php操作redis

$redis=new redis();
$host="127.0.0.1";
$port="6379";
$redis->connect($host,$port);
$redis->set('linux','linux testing');
$data=$redis->get('linux');
echo $data;
?>

结果：linux testing

2、redis的安全问题

redis操作的时候，默认不需要客户端提供认证信息，不需要密码即可对redis进行操作,本身是很危险的，所以有必要开启redis的认证功能
修改redis.conf文件

[root@iz2ze3b608hhazmstr89iqz bin]# vim /etc/redis/redis.conf
requirepass admin88 【找到这一句并修改】

重启redis服务

[root@iz2ze3b608hhazmstr89iqz bin]# pkill -9 redis-server
[root@iz2ze3b608hhazmstr89iqz bin]# cd /usr/local/redis/bin
[root@iz2ze3b608hhazmstr89iqz bin]# ./redis-server /etc/redis/redis.conf
[root@iz2ze3b608hhazmstr89iqz bin]# ./redis-cli

127.0.0.1:6379> set test testdata 结果如下图，没有权限

解决办法：（1）127.0.0.1:6379>auth admin88 【客户端连接成功后，再执行这一步输入密码】

（2）[root@iz2ze3b608hhazmstr89iqz bin]# ./redis-cli -h 127.0.0.1 -p 6379 -a admin88 【客户端连接的时候输入密码】

3、redis的持久化

（1）简介

redis为了本身数据的安全和完整性，会把内存中的数据按照一定的方法同步到电脑的硬盘中 ，这个过程被成为持久化操作。
下次再启动redis服务的时候，会把磁盘上面保存的数据重新加载到内存中
常见的持久化操作：
a.基于快照的持久化操作：
redis会按照一定的周期把内存里的数据同步到磁盘文件里面
b.基于日志文件的追加：
redis会把redis数据造成更改的命令记录到日志文件里面，然后在一次重启的时候，执行一下日志文件里面对redis写的操作，达到
数据的还原

（2）基于快照的持久化操作

 [root@iz2ze3b608hhazmstr89iqz bin]# vim /etc/redis/redis.conf

save 900 1：如果在900秒之内对redis的key进行过1次操作，则会把内存里的数据同步到磁盘文件
save 300 10：如果在300秒之内对redis的key进行过10次操作，则会把内存里的数据同步到磁盘文件
save 60 10000：如果在60秒之内对redis的key进行过10000次操作，则会把内存里的数据同步到磁盘文件

①保存到哪个磁盘文件？在哪个目录？如下图：

dbfilename dump.rdb ：基于快照持久化保存的文件名称
dir ./ ：保存的目录，默认是相对于启动文件 redis-server的位置
②测试一下

（3）基于日志文件的追加
vim /etc/redis/redis.conf

appendonly yes ：开启基于文件的持久化操作
appendonly.aof ：文件的名称

备份文件的周期：
appendfsync always：代表只要存在对redis数据造成更改的操作，都要记录到磁盘文件
appendfsync everysec：代表每一秒中把对redis数据造成更改的操作都记录到磁盘文件
appendfsync no：完全交给操作系统来完成，意思是操作系统不繁忙的时候会把对redis进行数据造成更改的操作都记录到磁 盘文件上，这种操作最不可靠

测试一下：

四、其他

$redis = new Redis();
$redis->connect('127.0.0.1',6379,1);//短链接，本地host，端口为6379，超过1秒放弃链接
$redis->pconnect('127.0.0.1',6379,1);//长链接，本地host，端口为6379，超过1秒放弃链接
$redis->auth('password');//redis设置密码后，用于验证登录密码，返回【true | false】
$redis->select(0);//选择redis库,0~15 共16个库
$redis->close();//释放资源
$redis->ping(); //服务器运行正常，返回pong
$redis->ttl('key');//返回剩余过期时间[-1 | timestamps]
$redis->persist('key');//移除key的过期时间，使其永久有效，成功返回1
$redis->sort('key',[$array]);//返回或保存给定列表、集合、有序集合key中经过排序的元素，$array为参数limit等！【配合$array很强大】 [array|false]
/*2.共性的运算归类*/
$redis->expire('key',10);//设置失效时间[true | false]
$redis->move('key',15);//把当前库中的key移动到15库中[0|1]
/*3.Server*/
$redis->dbSize();//返回当前库中的key的个数
$redis->flushAll();//清空整个redis[总true]
$redis->flushDB();//清空当前redis库[总true]
$redis->save();//同步??把数据存储到磁盘-dump.rdb[true]
$redis->bgsave();//异步？？把数据存储到磁盘-dump.rdb[true]
$redis->info();//查询当前redis的状态 [verson:2.4.5....]
$redis->lastSave();//上次存储时间key的时间[timestamp]
$redis->watch('key','keyn');//监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断 [true]
$redis->unwatch('key','keyn');//取消监视一个(或多个) key [true]
$redis->multi(Redis::MULTI);//开启事务，事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令在一个原子时间内执行。
$redis->multi(Redis::PIPELINE);//开启管道，事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令在一个原子时间内执行。
$redis->exec();//执行所有事务块内的命令，；【事务块内所有命令的返回值，按命令执行的先后顺序排列，当操作被打断时，返回空值 false】
/*4.String，键值对，创建更新同操作*/
$redis->setOption(Redis::OPT_PREFIX,'hf_');//设置表前缀为hf_
$redis->set('key',1);//设置key=aa value=1 [true]
$redis->mset($arr);//设置一个或多个键值[true]
$redis->setnx('key','value');//key=value,key存在返回false[|true]
$redis->setex('key',10,'value');//key=value，有效期为10秒[true]
$redis->get('key');//获取key [value]
$redis->mget($arr);//(string|arr),返回所查询键的值
$redis->del($key_arr);//(string|arr)删除key，支持数组批量删除【返回删除个数】
$redis->delete($key_str,$key2,$key3);//删除keys,[del_num]
$redis->getset('old_key','new_value');//先获得key的值，然后重新赋值,[old_value | false]
$redis->strlen('key');//获取当前key的长度
$redis->append('key','string');//把string追加到key现有的value中[追加后的个数]
$redis->incr('key');//自增1，如不存在key,赋值为1(只对整数有效)[new_num | false]
$redis->incrby('key',$num);//自增$num,不存在为赋值,值需为整数[new_num | false]
$redis->decr('key');//自减1，[new_num | false]
$redis->decrby('key',$num);//自减$num，[ new_num | false]
/*5.List栈的结构,注意表头表尾,创建更新分开操作*/
$redis->lpush('key','value');//增，只能将一个值value插入到列表key的表头，不存在就创建 [列表的长度 |false]
$redis->rpush('key','value');//增，只能将一个值value插入到列表key的表尾 [列表的长度 |false]
$redis->lInsert('key', Redis::AFTER, 'value', 'new_value');//增，将值value插入到列表key当中，位于值value之前或之后。[new_len | false]
$redis->lpushx('key','value');//将value插入到列表key的表头，列表不存在不创建
$redis->rpushx('key','value');//将value插入到列表key的表尾，列表不存在不创建
$redis->lpop('key');//删，移除并返回列表key的头元素,[被删元素 | false]
$redis->rpop('key');//删，移除并返回列表key的尾元素,[被删元素 | false]
$redis->lrem('key','value',0);//删，根据参数count的值，移除列表中与参数value相等的元素count=(0|-n表头向尾|+n表尾向头移除n个value) [被移除的数量 | 0]
$redis->llen('key');//返回列表key的长度,不存在key返回0， [ len | 0]
$redis->ltrim('key',start,end);//删，列表修剪，保留(start,end)之间的值 [true|false]
$redis->lset('key',index,'new_v');//改，从表头数，将列表key下标为第index的元素的值为new_v, [true | false]
$redis->lindex('key',index);//查，返回列表key中，下标为index的元素[value|false]
$redis->lrange('key',0,-1);//返回名称为key的list中start至end之间的元素（end为 -1 ，返回所有）
/*6.Set，没有重复的member，创建更新同操作*/
$redis->sadd('key','value1','value2','valuen');//增，改，将一个或多个member元素加入到集合key当中，已经存在于集合的member元素将被忽略。[insert_num]
$redis->srem('key','value1','value2','valuen');//删，移除集合key中的一个或多个member元素，不存在的member元素会被忽略 [del_num | false]
$redis->smembers('key');//查，返回集合key中的所有成员 [array | '']
$redis->sismember('key','member');//判断member元素是否是集合key的成员 [1 | 0]
$redis->spop('key');//删，移除并返回集合中的一个随机元素 [member | false]
$redis->srandmember('key');//查，返回集合中的一个随机元素 [member | false]
$redis->sinter('key1','key2','keyn');//查，返回所有给定集合的交集 [array | false]
$redis->sunion('key1','key2','keyn');//查，返回所有给定集合的并集 [array | false]
$redis->sdiff('key1','key2','keyn');//查，返回所有给定集合的差集 [array | false]
$redis->scard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
$redis->sMove('key1', 'key2', 'member');//移动，将member元素从key1集合移动到key2集合。[1 | 0]
/*7.Zset，没有重复的member，有排序顺序,创建更新同操作*/
$redis->zAdd('key',$score1,$member1,$scoreN,$memberN);//增，改，将一个或多个member元素及其score值加入到有序集key当中。[num | 0]
$redis->zrem('key','member1','membern');//删，移除有序集key中的一个或多个成员，不存在的成员将被忽略。[del_num | 0]
$redis->zscore('key','member');//查,通过值反拿权 [num | null]
$redis->zrange('key',$start,$stop);//查，通过(score从小到大)【排序名次范围】拿member值，返回有序集key中，【指定区间内】的成员 [array | null]
$redis->zrevrange('key',$start,$stop);//查，通过(score从大到小)【排序名次范围】拿member值，返回有序集key中，【指定区间内】的成员 [array | null]
$redis->zrangebyscore('key',$min,$max[,$config]);//查，通过scroe权范围拿member值，返回有序集key中，指定区间内的(从小到大排)成员[array | null]
$redis->zrevrangebyscore('key',$max,$min[,$config]);//查，通过scroe权范围拿member值，返回有序集key中，指定区间内的(从大到小排)成员[array | null]
$redis->zrank('key','member');//查，通过member值查(score从小到大)排名结果中的【member排序名次】[order | null]
$redis->zrevrank('key','member');//查，通过member值查(score从大到小)排名结果中的【member排序名次】[order | null]
$redis->ZINTERSTORE();//交集
$redis->ZUNIONSTORE();//差集
$redis->zcard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
$redis->zcount('key',0,-1);//返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。[num | 0]
/*8.Hash，表结构，创建更新同操作*/
$redis->hset('key','field','value');//增，改，将哈希表key中的域field的值设为value,不存在创建,存在就覆盖【1 | 0】
$redis->hget('key','field');//查，取值【value|false】
$arr = array('one'=>1,2,3);$arr2 = array('one',0,1);
$redis->hmset('key',$arr);//增，改，设置多值$arr为(索引|关联)数组,$arr[key]=field, [ true ]
$redis->hmget('key',$arr2);//查，获取指定下标的field，[$arr | false]
$redis->hgetall('key');//查，返回哈希表key中的所有域和值。[当key不存在时，返回一个空表]
$redis->hkeys('key');//查，返回哈希表key中的所有域。[当key不存在时，返回一个空表]
$redis->hvals('key');//查，返回哈希表key中的所有值。[当key不存在时，返回一个空表]
$redis->hdel('key',$arr2);//删，删除指定下标的field,不存在的域将被忽略,[num | false]
$redis->hexists('key','field');//查看hash中是否存在field,[1 | 0]
$redis->hincrby('key','field',$int_num);//为哈希表key中的域field的值加上量(+|-)num,[new_num | false]
$redis->hlen('key');//返回哈希表key中域的数量。[ num | 0]
//Redis::__construct构造函数
$redis = new Redis();
//setex 带生存时间的写入值
$redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
//setnx 判断是否重复的，写入值
$redis->setnx('key', 'value');
//delete  删除指定key的值
//返回已经删除key的个数（长整数）
$redis->delete('key1', 'key2');
$redis->delete(array('key3', 'key4', 'key5'));
/*
multi, exec, discard
进入或者退出事务模式
参数可选Redis::MULTI或Redis::PIPELINE. 默认是 Redis::MULTI
Redis::MULTI：将多个操作当成一个事务执行
Redis::PIPELINE:让（多条）执行命令简单的，更加快速的发送给服务器，但是没有任何原子性的保证
discard:删除一个事务
返回值
multi()，返回一个redis对象，并进入multi-mode模式，一旦进入multi-mode模式，以后调用的所有方法都会返回相同的对象，只到exec(）方法被调用。
*/
/*
watch, unwatch （代码测试后，不能达到所说的效果）
监测一个key的值是否被其它的程序更改。如果这个key在watch 和 exec （方法）间被修改，这个 MULTI/EXEC 事务的执行将失败（return false）
unwatch  取消被这个程序监测的所有key
参数，一对key的列表*/
$redis->watch('x');

$ret = $redis->multi() ->incr('x') ->exec();
/*
subscribe *
方法回调。注意，该方法可能在未来里发生改变
publish *
发表内容到某一个通道。注意，该方法可能在未来里发生改变
exists
判断key是否存在。存在 true 不在 false
*/
/*
getMultiple
传参
由key组成的数组
返回参数
如果key存在返回value，不存在返回false
*/
$redis->set('key1', 'value1'); 
$redis->set('key2', 'value2');
$redis->set('key3', 'value3');
$redis->getMultiple(array('key1', 'key2', 'key3'));
$redis->lRem('key1', 'A', 2);

//blPop/brPop
$redis->blPop('key1', 'key2', 10);
//lpop命令的block版本。即当timeout为0时，若遇到名称为key i的list不存在或该list为空，则命令结束。如果timeout>0，则遇到上述情况时，等待timeout秒，如果问题没有解决，则对keyi+1开始的list执行pop操作

//lSize
$redis->lSize('key');
//返回名称为key的list有多少个元素

//lIndex, lGet
$redis->lGet('key', 0);
//返回名称为key的list中index位置的元素

//lSet
$redis->lSet('key', 0, 'X');
//给名称为key的list中index位置的元素赋值为value
//lTrim, listTrim
$redis->lTrim('key', start, end);
//截取名称为key的list，保留start至end之间的元素

//lRem, lRemove
$redis->lRem('key', 'A', 2);
//删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素

//lInsert
//在名称为为key的list中，找到值为pivot 的value，并根据参数Redis::BEFORE | Redis::AFTER，来确定，newvalue 是放在 pivot 的前面，或者后面。如果key不存在，不会插入，如果 pivot不存在，return -1
$redis->delete('key1'); $redis->lInsert('key1', Redis::AFTER, 'A', 'X'); $redis->lPush('key1', 'A'); $redis->lPush('key1', 'B'); $redis->lPush('key1', 'C'); $redis->lInsert('key1', Redis::BEFORE, 'C', 'X');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'C', 'Y');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'W', 'value');

//rpoplpush
//返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
$redis->delete('x', 'y');
$redis->lPush('x', 'abc'); $redis->lPush('x', 'def'); $redis->lPush('y', '123'); $redis->lPush('y', '456'); // move the last of x to the front of y. var_dump($redis->rpoplpush('x', 'y'));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1));

/*
string(3) "abc"
array(1) { [0]=> string(3) "def" }
array(3) { [0]=> string(3) "abc" [1]=> string(3) "456" [2]=> string(3) "123" }
*/
//SET操作相关
//sAdd
//向名称为key的set中添加元素value,如果value存在，不写入，return false
$redis->sAdd(key , value);

//sRem, sRemove
//删除名称为key的set中的元素value
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3');
$redis->sRem('key1', 'set2');

//sMove
//将value元素从名称为srckey的集合移到名称为dstkey的集合
$redis->sMove(seckey, dstkey, value);

//sIsMember, sContains
//名称为key的集合中查找是否有value元素，有ture 没有 false
$redis->sIsMember(key, value);

//sCard, sSize
//返回名称为key的set的元素个数
//
//sPop
//随机返回并删除名称为key的set中一个元素
//
//sRandMember
//随机返回名称为key的set中一个元素，不删除
//
//sInter
//求交集
//
//sInterStore
//求交集并将交集保存到output的集合
$redis->sInterStore('output', 'key1', 'key2', 'key3')

//sUnion
//求并集
$redis->sUnion('s0', 's1', 's2');
//s0,s1,s2 同时求并集
//
//sUnionStore
//求并集并将并集保存到output的集合
$redis->sUnionStore('output', 'key1', 'key2', 'key3')；

//sDiff
//求差集
//
//sDiffStore
//求差集并将差集保存到output的集合
//
//sMembers, sGetMembers
//返回名称为key的set的所有元素
//
/*
sort
排序，分页等
参数
'by' => 'some_pattern_*',
'limit' => array(0, 1),
'get' => 'some_other_pattern_*' or an array of patterns,
'sort' => 'asc' or 'desc',
'alpha' => TRUE,
'store' => 'external-key'
*/
//例子
$redis->delete('s'); $redis->sadd('s', 5); $redis->sadd('s', 4); $redis->sadd('s', 2); $redis->sadd('s', 1); $redis->sadd('s', 3);
var_dump($redis->sort('s')); // 1,2,3,4,5
var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5

//string命令
//getSet
//返回原来key中的值，并将value写入key
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
$newValue = $redis->get('x'); // return 'lol'
  
//append
//string，名称为key的string的值在后面加上value
$redis->set('key', 'value1');  
$redis->append('key', 'value2');  
$redis->get('key');  
  
//getRange （方法不存在）
//返回名称为key的string中start至end之间的字符
$redis->set('key', 'string value');  
$redis->getRange('key', 0, 5);  
$redis->getRange('key', -5, -1);  
  
//setRange （方法不存在）
//改变key的string中start至end之间的字符为value
$redis->set('key', 'Hello world');  
$redis->setRange('key', 6, "redis");  
$redis->get('key');  
  
//strlen
//得到key的string的长度
$redis->strlen('key');  
  
//getBit/setBit
//返回2进制信息
  
//zset（sorted set）操作相关
//zAdd(key, score, member)：向名称为key的zset中添加元素member，score用于排序。如果该元素已经存在，则根据score更新该元素的顺序。
$redis->zAdd('key', 1, 'val1');  
$redis->zAdd('key', 0, 'val0');  
$redis->zAdd('key', 5, 'val5');  
$redis->zRange('key', 0, -1); // array(val0, val1, val5)  
  
//zRange(key, start, end,withscores)：返回名称为key的zset（元素已按score从小到大排序）中的index从start到end的所有元素
$redis->zAdd('key1', 0, 'val0');  
$redis->zAdd('key1', 2, 'val2');  
$redis->zAdd('key1', 10, 'val10');  
$redis->zRange('key1', 0, -1); // with scores $redis->zRange('key1', 0, -1, true);  
  
//zDelete, zRem
//zRem(key, member) ：删除名称为key的zset中的元素member
$redis->zAdd('key', 0, 'val0');  
$redis->zAdd('key', 2, 'val2');  
$redis->zAdd('key', 10, 'val10');  
$redis->zDelete('key', 'val2');  
$redis->zRange('key', 0, -1);   
  
//zRevRange(key, start, end,withscores)：返回名称为key的zset（元素已按score从大到小排序）中的index从start到end的所有元素.withscores: 是否输出socre的值，默认false，不输出
$redis->zAdd('key', 0, 'val0');  
$redis->zAdd('key', 2, 'val2');  
$redis->zAdd('key', 10, 'val10');  
$redis->zRevRange('key', 0, -1); // with scores $redis->zRevRange('key', 0, -1, true);  
  
//zRangeByScore, zRevRangeByScore
$redis->zRangeByScore(key, star, end, array(withscores， limit ));  
//返回名称为key的zset中score >= star且score <= end的所有元素
  
//zCount
$redis->zCount(key, star, end);  
//返回名称为key的zset中score >= star且score <= end的所有元素的个数
  
//zRemRangeByScore, zDeleteRangeByScore
$redis->zRemRangeByScore('key', star, end);  
//删除名称为key的zset中score >= star且score <= end的所有元素，返回删除个数
  
//zSize, zCard
//返回名称为key的zset的所有元素的个数
//
//zScore
$redis->zScore(key, val2);  
//返回名称为key的zset中元素val2的score
//
//zRank, zRevRank
$redis->zRevRank(key, val);  
//返回名称为key的zset（元素已按score从小到大排序）中val元素的rank（即index，从0开始），若没有val元素，返回“null”。zRevRank 是从大到小排序
  
//zIncrBy
$redis->zIncrBy('key', increment, 'member');  
//如果在名称为key的zset中已经存在元素member，则该元素的score增加increment；否则向集合中添加该元素，其score的值为increment

/*
zUnion/zInter  
参数  
keyOutput  
arrayZSetKeys  
arrayWeights  
aggregateFunction Either "SUM", "MIN", or "MAX": defines the behaviour to use on duplicate entries during the zUnion.  
对N个zset求并集和交集，并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score，在进行AGGREGATE运算前，都要乘以对于的WEIGHT参数。如果没有提供WEIGHT，默认为1。默认的AGGREGATE是SUM，即结果集合中元素的score是所有集合对应元素进行SUM运算的值，而MIN和MAX是指，结果集合中元素的score是所有集合对应元素中最小值和最大值。  
  */
//Hash操作
//hSet
$redis->hSet('h', 'key1', 'hello');  
//向名称为h的hash中添加元素key1—>hello
  
//hGet
$redis->hGet('h', 'key1');  
//返回名称为h的hash中key1对应的value（hello）
  
//hLen
$redis->hLen('h');  
//返回名称为h的hash中元素个数
  
//hDel
$redis->hDel('h', 'key1');  
//删除名称为h的hash中键为key1的域
  
//hKeys
$redis->hKeys('h');  
//返回名称为key的hash中所有键
  
//hVals
$redis->hVals('h')  
//返回名称为h的hash中所有键对应的value
  
//hGetAll
$redis->hGetAll('h');  
//返回名称为h的hash中所有的键（field）及其对应的value
  
//hExists
$redis->hExists('h', 'a');  
//名称为h的hash中是否存在键名字为a的域
  
//hIncrBy
$redis->hIncrBy('h', 'x', 2);  
//将名称为h的hash中x的value增加2
  
//hMset
$redis->hMset('user:1', array('name' => 'Joe', 'salary' => 2000));  
//向名称为key的hash中批量添加元素
  
//hMGet
$redis->hmGet('h', array('field1', 'field2'));  
//返回名称为h的hash中field1,field2对应的value
  
//redis 操作相关
//flushDB
//清空当前数据库
  
//flushAll
//清空所有数据库
  
//randomKey
//随机返回key空间的一个key
$key = $redis->randomKey();  
  
//select
//选择一个数据库
//move
//转移一个key到另外一个数据库
$redis->select(0); // switch to DB 0  
$redis->set('x', '42'); // write 42 to x  
$redis->move('x', 1); // move to DB 1  
$redis->select(1); // switch to DB 1  
$redis->get('x'); // will return 42  
  
//rename, renameKey
//给key重命名
$redis->set('x', '42');  
$redis->rename('x', 'y');  
$redis->get('y'); // → 42  
$redis->get('x'); // → `FALSE`  
  
//renameNx
//与remane类似，但是，如果重新命名的名字已经存在，不会替换成功
//
//setTimeout, expire
//设定一个key的活动时间（s）
$redis->setTimeout('x', 3);  
  
//expireAt
//key存活到一个unix时间戳时间
$redis->expireAt('x', time() + 3);  
  
//keys, getKeys
//返回满足给定pattern的所有key
$keyWithUserPrefix = $redis->keys('user*');  
  
//dbSize
//查看现在数据库有多少key
$count = $redis->dbSize();  
  
//auth
//密码认证
$redis->auth('foobared');  
  
//bgrewriteaof
//使用aof来进行数据库持久化
$redis->bgrewriteaof();  
  
//slaveof
//选择从服务器
$redis->slaveof('10.0.1.7', 6379);  
?>