Redis常用操作

//DEL 删除指定key
DEL name
jedis.del(key)

//序列化key
DUMP name

//判断key是否存在
EXISTS name
jedis.exists(key)

//设置key过期时间
EXPIRE key
edis.expire(key, seconds)

//设置key过期时间 不过是时间戳格式 ，指定什么时间点过期
EXPIREAT
jedis.expireAt(key, unixTime)

// 查找所有符合给定模式 pattern 的 key
KEYS * 匹配数据库中所有 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
jedis.keys(key)

//将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
MIGRATE host port key destination-db timeout [COPY] [REPLACE]
MIGRATE 127.0.0.1 7777 greeting 0 1000 //把greeting 移到0库上 1000s超时

//将当前数据库的 key 移动到给定的数据库 db 当中。
MOVE key db

//移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )
PERSIST key
jedis.persist(key);

//这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
PEXPIREAT key milliseconds-timestamp

//这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
PTTL key

//从当前数据库中随机返回(不删除)一个 key 。
RANDOMKEY

//将 key 改名为 newkey
RENAME key newkey
jedis.rename(oldkey, newkey)

//当且仅当 newkey 不存在时，将 key 改名为 newkey
RENAMENX key newkey

//反序列化给定的序列化值，并将它和给定的 key 关联。参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。
RESTORE key ttl serialized-value

//返回或保存给定列表、集合、有序集合 key 中经过排序的元素。排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较
SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]
SORT today_cost DESC
SORT website
SORT website ALPHA
SORT rank LIMIT 0 5

//以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
TTL key
jedis.ttl(key)

//返回 key 所储存的值的类型。
TYPE key
jedis.type(key)

//SCAN 命令用于迭代当前数据库中的数据库键。
//SSCAN 命令用于迭代集合键中的元素。
//HSCAN 命令用于迭代哈希键中的键值对。
//ZSCAN 命令用于迭代有序集合中的元素（包括元素成员和元素分值）。
SCAN cursor [MATCH pattern] [COUNT count]

//如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
APPEND key value
jedis.append(key, value)

//计算给定字符串中，被设置为 1 的比特位的数量。 -1 表示最后一个位，而 -2 表示倒数第二个位，以此类推。
BITCOUNT key [start] [end]

//将 key 中储存的数字值减一。
DECR key

//将 key 所储存的值减去减量 decrement
DECRBY key decrement
DECRBY count 20

//返回 key 所关联的字符串值。
GET key
jedis.get(key)

//对 key 所储存的字符串值，获取指定偏移量上的位(bit)。当 offset 比字符串值的长度大，或者 key 不存在时，返回 0 。
GETBIT key offset

//返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
GETRANGE key start end

//将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
GETSET key value
jedis.getSet(key, value)

//将 key 中储存的数字值增一。 也可用做限速器，如限制接口的访问次数。
INCR key
jedis.incr(key)

//将 key 所储存的值加上增量 increment 。
INCRBY key increment
jedis.incrBy(key, integer)

//为 key 中所储存的值加上浮点数增量 increment 。
INCRBYFLOAT key increment

//返回所有(一个或多个)给定 key 的值。
MGET key [key ...]

//同时设置一个或多个 key-value 对。
MSET key value [key value ...]
MSET date "2012.3.30" time "11:00 a.m." weather "sunny"

//同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
MSETNX key value [key value ...]
MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"

//这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。
PSETEX key milliseconds value

//将字符串值 value 关联到 key 。如果 key 已经持有其他值， SET 就覆写旧值，无视类型。对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
SET key value [EX seconds] [PX milliseconds] [NX|XX]
SET key-with-expire-time "hello" EX 10086
SET key-with-pexpire-time "moto" PX 123321
jedis.set(key, value)

//对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。
SETBIT key offset value

//将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
SETEX key seconds value
jedis.setex(key, seconds, value)

//将 key 的值设为 value ，当且仅当 key 不存在。
SETNX key value
jedis.setnx(key, value)

//用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始。
SETRANGE key offset value
SET greeting "hello world"
SETRANGE greeting 6 "Redis"

//返回 key 所储存的字符串值的长度
STRLEN key

//删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
HDEL key field [field ...]
jedis.hdel(key, fields)

//查看哈希表 key 中，给定域 field 是否存在。
HEXISTS key field
jedis.hexists(key, field)

//返回哈希表 key 中给定域 field 的值。
HGET key field
jedis.hget(key, field)

//返回哈希表 key 中，所有的域和值。
HGETALL key
jedis.hgetAll(key)

//为哈希表 key 中的域 field 的值加上增量 increment 。
HINCRBY key field increment
hincrBy(key, field, value)

//为哈希表 key 中的域 field 加上浮点数增量 increment 。
HINCRBYFLOAT key field increment
HINCRBYFLOAT mykey field 0.1

//返回哈希表 key 中的所有域。
HKEYS key
jedis.hkeys(key)

//返回哈希表 key 中域的数量。
HLEN key
jedis.hlen(key)

//返回哈希表 key 中，一个或多个给定域的值。
HMGET key field [field ...]
jedis.hmget(key, fields)

//同时将多个 field-value (域-值)对设置到哈希表 key 中。
HMSET key field value [field value ...]
HMSET website google www.google.com yahoo www.yahoo.com
jedis.hmset(key, hash)

//将哈希表 key 中的域 field 的值设为 value 。
HSET key field value
jedis.hset(key, field, value)

//将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
HSETNX key field value
jedis.hsetnx(key, field, value)

//返回哈希表 key 中所有域的值。
HVALS key
jedis.hvals(key)

//hscan
HSCAN key cursor [MATCH pattern] [COUNT count]

//BLPOP 是列表的阻塞式(blocking)弹出原语。它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
BLPOP key [key ...] timeout

//它是 RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
BRPOP key [key ...] timeout
jedis.brpop(timeout, keys)

//BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。
BRPOPLPUSH source destination timeout
jedis.brpoplpush(source, destination, timeout)

//返回列表 key 中，下标为 index 的元素。
LINDEX key index
jedis.lindex(key, index)

//将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
LINSERT key BEFORE|AFTER pivot value
LINSERT mylist BEFORE "World" "There"

//返回列表 key 的长度。
LLEN key
jedis.llen(key)

//移除并返回列表 key 的头元素。
LPOP key
jedis.lpop(key)

//将一个或多个值 value 插入到列表 key 的表头
LPUSH key value [value ...]
LPUSH languages python
jedis.lpush(key, strings...)

//将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
LPUSHX
jedis.lpushx(key, string)

//返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
LRANGE key start stop
jedis.lrange(key, start, end)

//根据参数 count 的值，移除列表中与参数 value 相等的元素。
LREM key count value
jedis.lrem(key, count, value)

//将列表 key 下标为 index 的元素的值设置为 value 。
LSET key index value
jedis.lset(key, index, value)

//对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
LTRIM key start stop
jedis.ltrim(key, start, end)

//移除并返回列表 key 的尾元素。
RPOP key
jedis.rpop(key)

//命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：
//将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
//将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
RPOPLPUSH source destination

//将一个或多个值 value 插入到列表 key 的表尾(最右边)。
RPUSH key value [value ...]
jedis.rpush(key, string...)

//将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
RPUSHX key value

//将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
SADD key member [member ...]
jedis.sadd(key, members)

//返回集合 key 的基数(集合中元素的数量)。
SCARD key
jedis.scard(key)

//返回一个集合的全部成员，该集合是所有给定集合之间的差集。
SDIFF key [key ...]

//这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
SDIFFSTORE destination key [key ...]

//返回一个集合的全部成员，该集合是所有给定集合的交集。
SINTER key [key ...]

//这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
SINTERSTORE destination key [key ...]

//判断 member 元素是否集合 key 的成员。
SISMEMBER key member
jedis.sismember(key, member)

//返回集合 key 中的所有成员。
SMEMBERS key
jedis.smembers(key)

//将 member 元素从 source 集合移动到 destination 集合
SMOVE source destination member
jedis.smove(source, destination, value)

//移除并返回集合中的一个随机元素。
SPOP key
jedis.spop(key)

//如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。
SRANDMEMBER key [count]
jedis.srandmember(key)

//移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
SREM key member [member ...]
jedis.srem(key, members)

//返回一个集合的全部成员，该集合是所有给定集合的并集。
SUNION key [key ...]

//这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
SUNIONSTORE destination key [key ...]

//将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
ZADD key score member [[score member] [score member] ...]
jedis.zadd(key, score, member)

//返回有序集 key 的基数。
ZCARD key
jedis.zcard(key)

//返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
ZCOUNT key min max
jedis.zcount(key, min, max)

//为有序集 key 的成员 member 的 score 值加上增量 increment 。
ZINCRBY key increment member
jedis.zincrby(key, score, member)

//返回有序集 key 中，指定区间内的成员。
ZRANGE key start stop [WITHSCORES]
jedis.zrange(key, start, end)

//返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
jedis.zrangeByScore(key, min, max)

//返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
ZRANK key member
jedis.zrank(key, member)

//移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
ZREM key member [member ...]
jedis.zrem(key, members)

//移除有序集 key 中，指定排名(rank)区间内的所有成员。
ZREMRANGEBYRANK key start stop
jedis.zremrangeByRank(key, start, end)

//返回有序集 key 中，指定区间内的成员。值递减
ZREVRANGE key start stop [WITHSCORES]
jedis.zrevrange(key, start, end)

//返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
jedis.zrangeByScore(key, min, max)

//返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
ZREVRANK key member
jedis.zrevrank(key, member)

//返回有序集 key 中，成员 member 的 score 值。
ZSCORE key member
jedis.zscore(key, member)

//计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
jedis.zunionstore(dstkye, sets)

//计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
jedis.zinterstore(dstkey, sets)

//取消事务，放弃执行事务块内的所有命令。如果正在使用 WATCH 命令监视某个(或某些) key，那么取消所有监视，等同于执行命令 UNWATCH 。
DISCARD

//执行所有事务块内的命令。
EXEC

MULTI
INCR user_id
INCR user_id
EXEC

//标记一个事务块的开始。
MULTI

//取消 WATCH 命令对所有 key 的监视。
UNWATCH

//监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
WATCH key [key ...]