redislib

package
v0.0.0-...-e6ef893 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 5, 2024 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ListSite_BEFORE = "BEFORE" //在pivot之前，写入value
	ListSite_AFTER  = "AFTER"  //在pivot之后，写入value

)

Variables

View Source 
var (
	ErrParam = errors.New("Param Error.")
)

Functions

func BytesMap 

func BytesMap(result interface{}, err error) (map[string][]byte, error)

func RedisSetAddr 

func RedisSetAddr(addr string) redisoptions

设置redis地址,带端口

func RedisSetAuth 

func RedisSetAuth(auth string) redisoptions

设置redis,auth(进入密码)

func RedisSetErrRetry 

func RedisSetErrRetry(errRetry int) redisoptions

出错重试次数,至少是1

func RedisSetIdleTimeout 

func RedisSetIdleTimeout(idleTimeout time.Duration) redisoptions

最大的空闲连接等待时间，超过此时间后，空闲连接将被关闭(秒)

func RedisSetIndexDB 

func RedisSetIndexDB(indexdb int) redisoptions

设置redis默认的indexdb

func RedisSetMaxActive 

func RedisSetMaxActive(maxactive int) redisoptions

最大的激活连接数，表示同时最多有N个连接 ，为0事表示没有限制

func RedisSetMaxIdle 

func RedisSetMaxIdle(maxidle int) redisoptions

设置redis最大的空闲连接数，表示即使没有redis连接时依然可以保持N个空闲的连接，而不被清除，随时处于待命状态

func RedisSeterrFunc 

func RedisSeterrFunc(errF errFunc) redisoptions

设置错误处理回调

func RedisUsing 

func RedisUsing(rd *RedisHandleModel, f func(rd *RedisHandleModel))

Redis的使用生命周期

Types

type RedisAccess 

type RedisAccess struct {
	DBConobj *redis.Pool //redis连接池
	// contains filtered or unexported fields
}

RedisAccess redis 管理器

func NewRedisAccess 

func NewRedisAccess(opts ...redisoptions) *RedisAccess

NewRedisAccess 生成新的管理器

func (*RedisAccess) Close 

func (access *RedisAccess) Close()

Close 关闭池子，一般只有关服的时候才用到

func (*RedisAccess) GetConn 

func (access *RedisAccess) GetConn() *RedisHandleModel

GetConn 拿到一个可用的连接，你要在这句之后写上：defer conn.Close() 用来在使用完之后把连接放回池子里去

type RedisBitOperation 

type RedisBitOperation int
const (
	Bit_Defualt RedisBitOperation = iota //无效
	Bit_And                              //逻辑与
	Bit_Or                               //逻辑或
	Bit_Xor                              //逻辑异或
	Bit_Not                              //逻辑非
)

type RedisHandleModel 

type RedisHandleModel struct {
	redis.Conn
	// contains filtered or unexported fields
}

RedisHandleModel 自己把reids的一些常用命令写在这里

func (*RedisHandleModel) Append 

func (rd *RedisHandleModel) Append(key, val string) (int, error)

如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。 返回值： 追加 value 之后， key 中字符串的长度。

func (*RedisHandleModel) Auth 

func (rd *RedisHandleModel) Auth(pwd string) error

AUTH password 通过设置配置文件中 requirepass 项的值(使用命令 CONFIG SET requirepass password )，可以使用密码来保护 Redis 服务器。 返回 error==nil 就是成功的

func (*RedisHandleModel) BitCount 

func (rd *RedisHandleModel) BitCount(key string, start, end int) (int, error)

BITCOUNT key [start] [end] 计算给定字符串中，被设置为 1 的比特位的数量。 一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。 start 和 end 参数的设置和 GETRANGE 命令类似，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，以此类推。 不存在的 key 被当成是空字符串来处理，因此对一个不存在的 key 进行 BITCOUNT 操作，结果为 0 。 返回值： 被设置为 1 的位的数量。

如果 start==end 时，表示所有数据

func (*RedisHandleModel) Bitop 

func (rd *RedisHandleModel) Bitop(bitopt RedisBitOperation, deskey string, keys ...string) (int, error)

func (*RedisHandleModel) Blpop 

func (rd *RedisHandleModel) Blpop(timeout string, keys ...string) (string, string, error)

BLPOP key [key ...] timeout 简答说就是从这几个key的列表中读一个数据出来，如果没有就等待（阻塞）时间为timeout， timeout==0为无限等待； 返回数据为：从哪个key读出来的，读出来的值，可能的错误； 说明： BLPOP 是列表的阻塞式(blocking)弹出原语。 它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。 例： 当 BLPOP 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。 当存在多个给定 key 时， BLPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。 假设现在有 job 、 command 和 request 三个列表，其中 job 不存在， command 和 request 都持有非空列表。考虑以下命令： BLPOP job command request 0 BLPOP 保证返回的元素来自 command ，因为它是按”查找 job -> 查找 command -> 查找 request “这样的顺序，第一个找到的非空列表。

func (*RedisHandleModel) Brpop 

func (rd *RedisHandleModel) Brpop(timeout string, keys ...string) (string, string, error)

BRPOP key [key ...] timeout BRPOP 是列表的阻塞式(blocking)弹出原语。 与BLPOP一样，只是弹出元素的位置不同

func (*RedisHandleModel) Close 

func (rd *RedisHandleModel) Close() error

func (*RedisHandleModel) Decr 

func (rd *RedisHandleModel) Decr(key string) (int, error)

将 key 中储存的数字值减一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 返回值： 执行 DECR 命令之后 key 的值。

func (*RedisHandleModel) Decrby 

func (rd *RedisHandleModel) Decrby(key string, dec int) (int, error)

将 key 所储存的值减去减量 decrement 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 返回值： 减去 decrement 之后， key 的值。

func (*RedisHandleModel) Del 

func (rd *RedisHandleModel) Del(keys ...interface{}) (int, error)

DEL key [key ...] 删除给定的一个或多个 key 。 不存在的 key 会被忽略。 时间复杂度： O(N)， N 为被删除的 key 的数量。 删除单个字符串类型的 key ，时间复杂度为O(1)。 删除单个列表、集合、有序集合或哈希表类型的 key ，时间复杂度为O(M)， M 为以上数据结构内的元素数量。 返回值： 被删除 key 的数量。

func (*RedisHandleModel) Dispose 

func (rd *RedisHandleModel) Dispose()

func (*RedisHandleModel) Do 

func (rd *RedisHandleModel) Do(commandName string, args ...interface{}) (reply interface{}, err error)

func (*RedisHandleModel) Exists 

func (rd *RedisHandleModel) Exists(key string) (int, error)

EXISTS key 检查给定 key 是否存在。 返回值： 若 key 存在，返回 1 ，否则返回 0 。

func (*RedisHandleModel) Expire 

func (rd *RedisHandleModel) Expire(key string, ex int64) (int, error)

EXPIRE key seconds 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 返回值： 设置成功返回 1 。 当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

func (*RedisHandleModel) Expireat 

func (rd *RedisHandleModel) Expireat(key string, unix int) (int, error)

EXPIREAT key timestamp EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

例： redis> EXPIREAT cache 1355292000 # 这个 key 将在 2012.12.12 过期 (integer) 1 redis> TTL cache (integer) 45081860

func (*RedisHandleModel) Get 

func (rd *RedisHandleModel) Get(key string) (string, error)

当 key 不存在时，返回 nil ，否则，返回 key 的值。 如果 key 不是字符串类型，那么返回一个错误。

func (*RedisHandleModel) GetBit 

func (rd *RedisHandleModel) GetBit(key string, offset int) (int, error)

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

func (*RedisHandleModel) GetBytes 

func (rd *RedisHandleModel) GetBytes(key string) ([]byte, error)

当 key 不存在时，返回 nil ，否则，返回 key 的值。 如果 key 不是字符串类型，那么返回一个错误。

func (*RedisHandleModel) GetRange 

func (rd *RedisHandleModel) GetRange(key string, start, end int) (string, error)

GETRANGE key start end 返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。 负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。 GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。 时间复杂度： O(N)， N 为要返回的字符串的长度。 复杂度最终由字符串的返回值长度决定，但因为从已有字符串中取出子字符串的操作非常廉价(cheap)，所以对于长度不大的字符串，该操作的复杂度也可看作O(1)。 返回值： 截取得出的子字符串。

func (*RedisHandleModel) GetSet 

func (rd *RedisHandleModel) GetSet(key, val string) (string, error)

GETSET key value 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 当 key 存在但不是字符串类型时，返回一个错误。 返回值： 返回给定 key 的旧值。 当 key 没有旧值时，也即是， key 不存在时，返回 nil 。

func (*RedisHandleModel) HScan 

func (rd *RedisHandleModel) HScan(key string, cursor int, match string, count int) (int, []string, error)

HSCAN key cursor [MATCH pattern] [COUNT count] 命令用于迭代哈希键中的键值对。

func (*RedisHandleModel) HScanBytes 

func (rd *RedisHandleModel) HScanBytes(key string, cursor int, match string, count int) (int, map[string][]byte, error)

func (*RedisHandleModel) Hdel 

func (rd *RedisHandleModel) Hdel(key string, fields ...string) (int, error)
HDEL key field [field ...]

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。 返回值: 被成功移除的域的数量，不包括被忽略的域

func (*RedisHandleModel) Hexists 

func (rd *RedisHandleModel) Hexists(key, field string) (int, error)

HEXISTS key field 查看哈希表 key 中，给定域 field 是否存在。 返回值： 如果哈希表含有给定域，返回 1 。 如果哈希表不含有给定域，或 key 不存在，返回 0 。

func (*RedisHandleModel) Hget 

func (rd *RedisHandleModel) Hget(key, field string) (string, error)

HGET key field 返回哈希表 key 中给定域 field 的值。 返回值： 给定域的值。 当给定域不存在或是给定 key 不存在时，返回 nil 。

func (*RedisHandleModel) HgetBytes 

func (rd *RedisHandleModel) HgetBytes(key, field string) ([]byte, error)

func (*RedisHandleModel) HgetallByBytesMap 

func (rd *RedisHandleModel) HgetallByBytesMap(key string) (map[string][]byte, error)

同 HgetallByStringMap

func (*RedisHandleModel) HgetallByInt64Map 

func (rd *RedisHandleModel) HgetallByInt64Map(key string) (map[string]int64, error)

同 HgetallByStringMap

func (*RedisHandleModel) HgetallByIntMap 

func (rd *RedisHandleModel) HgetallByIntMap(key string) (map[string]int, error)

同 HgetallByStringMap

func (*RedisHandleModel) HgetallByStringMap 

func (rd *RedisHandleModel) HgetallByStringMap(key string) (map[string]string, error)

HGETALL key 返回哈希表 key 中，所有的域和值。 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。 返回值： 以列表形式返回哈希表的域和域的值。 若 key 不存在，返回空列表。

返回值为Map，分为三种不同类型的key：string,int,int64类型

func (*RedisHandleModel) Hincrby 

func (rd *RedisHandleModel) Hincrby(key, field string, inc int) (int, error)

HINCRBY key field increment 为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数，相当于对给定域进行减法操作。 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。 如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。 本操作的值被限制在 64 位(bit)有符号数字表示之内。 返回值： 执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。

func (*RedisHandleModel) HincrbyFloat 

func (rd *RedisHandleModel) HincrbyFloat(key, field string, inc float64) (float64, error)

同Hincrby 只是返回值类型为float64

func (*RedisHandleModel) Hkeys 

func (rd *RedisHandleModel) Hkeys(key string) ([]string, error)

HKEYS key 返回哈希表 key 中的所有域。 时间复杂度： O(N)， N 为哈希表的大小。 返回值： 一个包含哈希表中所有域的表。 当 key 不存在时，返回一个空表。

func (*RedisHandleModel) Hlen 

func (rd *RedisHandleModel) Hlen(key string) (int, error)

HLEN key 返回哈希表 key 中域的数量。 时间复杂度： O(1) 返回值： 哈希表中域的数量。 当 key 不存在时，返回 0 。

func (*RedisHandleModel) Hmget 

func (rd *RedisHandleModel) Hmget(key string, fields ...string) (map[string]string, error)

HMGET key field [field ...] 返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

返回一个与传入field对应的map[string]string 如果对应的值为nil的话，这里的表现为“”

func (*RedisHandleModel) Hmset 

func (rd *RedisHandleModel) Hmset(key string, fieldvals ...interface{}) (string, error)

HMSET key field value [field value ...] 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。 返回值： 如果命令执行成功，返回 OK 。 当 key 不是哈希表(hash)类型时，返回一个错误。

func (*RedisHandleModel) HsetNx 

func (rd *RedisHandleModel) HsetNx(key, field, val string) (int, error)

HSETNX key field value 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。 若域 field 已经存在，该操作无效。 如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。 返回值： 设置成功，返回 1 。 如果给定域已经存在且没有操作被执行，返回 0 。

func (*RedisHandleModel) Hvals 

func (rd *RedisHandleModel) Hvals(key string) ([]string, error)

HVALS key 返回哈希表 key 中所有域的值。 时间复杂度： O(N)， N 为哈希表的大小。 返回值： 一个包含哈希表中所有值的表。 当 key 不存在时，返回一个空表。

func (*RedisHandleModel) Incr 

func (rd *RedisHandleModel) Incr(key string) (int, error)

INCR key 将 key 中储存的数字值增一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 返回值： 执行 INCR 命令之后 key 的值。

func (*RedisHandleModel) Incrby 

func (rd *RedisHandleModel) Incrby(key string, inc int) (int, error)

INCRBY key increment 将 key 所储存的值加上增量 increment 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 返回值： 加上 increment 之后， key 的值。

func (*RedisHandleModel) IncrbyFloat 

func (rd *RedisHandleModel) IncrbyFloat(key string, inc float64) (float64, error)

INCRBYFLOAT key increment 为 key 中所储存的值加上浮点数增量 increment 。 如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。 如果命令执行成功，那么 key 的值会被更新为（执行加法之后的）新值，并且新值会以字符串的形式返回给调用者。 无论是 key 的值，还是增量 increment ，都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示， 但是，执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存，也即是，它们总是由一个数字，一个（可选的）小数点和一个任意位的小数部分组成（比如 3.14 、 69.768 ，诸如此类)， 小数部分尾随的 0 会被移除，如果有需要的话，还会将浮点数改为整数（比如 3.0 会被保存成 3 ）。 除此之外，无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 的计算结果也最多只能表示小数点的后十七位。 当以下任意一个条件发生时，返回一个错误： key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型） key 当前的值或者给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number）

func (*RedisHandleModel) Keys 

func (rd *RedisHandleModel) Keys(pat string) ([]string, error)

KEYS pattern

查找所有符合给定模式 pattern 的 key 。

KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。 特殊符号用 \ 隔开 注：KEYS 的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题， 如果你需要从一个数据集中查找特定的 key ，你最好还是用 Redis 的集合结构(set)来代替。 返回值： 符合给定模式的 key 列表。

func (*RedisHandleModel) LLen 

func (rd *RedisHandleModel) LLen(key string) (int, error)

LLEN key 返回列表 key 的长度。 如果 key 不存在，则 key 被解释为一个空列表，返回 0 . 如果 key 不是列表类型，返回一个错误。

func (*RedisHandleModel) Lindex 

func (rd *RedisHandleModel) Lindex(key string, index int) (string, error)

LINDEX key index 返回列表 key 中，下标为 index 的元素。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 如果 key 不是列表类型，返回一个错误。

func (*RedisHandleModel) Linsert 

func (rd *RedisHandleModel) Linsert(key string, site RedisListSite, pivot, val string) (int, error)

LINSERT key BEFORE|AFTER pivot value 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。 当 pivot 不存在于列表 key 时，不执行任何操作。 当 key 不存在时， key 被视为空列表，不执行任何操作。 如果 key 不是列表类型，返回一个错误。 时间复杂度: O(N)， N 为寻找 pivot 过程中经过的元素数量。 返回值: 如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0 。

func (*RedisHandleModel) Lpop 

func (rd *RedisHandleModel) Lpop(key string) (string, error)

LPOP key 移除并返回列表 key 的头元素。 返回值： 列表的头元素。 当 key 不存在时，返回 nil 。

func (*RedisHandleModel) Lpush 

func (rd *RedisHandleModel) Lpush(key, val string) (int, error)

LPUSH key value [value ...] 将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ， 这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 返回值： 执行 LPUSH 命令后，列表的长度。

func (*RedisHandleModel) LpushX 

func (rd *RedisHandleModel) LpushX(key, val string) (int, error)

LPUSHX key value 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。 和 LPUSH 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。 返回值： LPUSHX 命令执行之后，表的长度。

func (*RedisHandleModel) Lpushs 

func (rd *RedisHandleModel) Lpushs(key string, vals ...string) (int, error)

LPUSH key value [value ...] 将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ， 这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 返回值： 执行 LPUSH 命令后，列表的长度。

func (*RedisHandleModel) Lrange 

func (rd *RedisHandleModel) Lrange(key string, start, stop int) ([]string, error)

LRANGE key start stop 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 例子： 执行 LRANGE list 0 10 ，结果是一个包含11个元素的列表 时间复杂度: O(S+N)， S 为偏移量 start ， N 为指定区间内元素的数量。 返回值: 一个列表，包含指定区间内的元素。

func (*RedisHandleModel) Lrem 

func (rd *RedisHandleModel) Lrem(key string, count int, val string) (int, error)

LREM key count value 根据参数 count 的值，移除列表中与参数 value 相等的元素。 count 的值可以是以下几种： count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。 count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。 count = 0 : 移除表中所有与 value 相等的值。 时间复杂度： O(N)， N 为列表的长度。 返回值： 被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

func (*RedisHandleModel) Lset 

func (rd *RedisHandleModel) Lset(key string, index int, val string) (string, error)

LSET key index value 将列表 key 下标为 index 的元素的值设置为 value 。 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。 关于列表下标的更多信息，请参考 LINDEX 命令。 时间复杂度： 对头元素或尾元素进行 LSET 操作，复杂度为 O(1)。 其他情况下，为 O(N)， N 为列表的长度。 返回值： 操作成功返回 ok ，否则返回错误信息。

func (*RedisHandleModel) Ltrim 

func (rd *RedisHandleModel) Ltrim(key string, start, stop int) (string, error)

LTRIM key start stop 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 当 key 不是列表类型时，返回一个错误。 超出范围的下标 超出范围的下标值不会引起错误。 如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。 如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。 时间复杂度: O(N)， N 为被移除的元素的数量。 返回值: 命令执行成功时，返回 ok 。

func (*RedisHandleModel) MGet 

func (rd *RedisHandleModel) MGet(keys ...interface{}) ([]string, error)

返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。 返回值： 一个包含所有给定 key 的值的列表。

func (*RedisHandleModel) MSet 

func (rd *RedisHandleModel) MSet(keyvals ...interface{})

MSET key value [key value ...] 同时设置一个或多个 key-value 对。 返回值： 总是返回 OK (因为 MSET 不可能失败)

func (*RedisHandleModel) MsetNx 

func (rd *RedisHandleModel) MsetNx(keyvals ...interface{}) (int, error)

MSETNX key value [key value ...] 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。 即使只有一个给定 key 已存在， MSETNX 也会拒绝执行所有给定 key 的设置操作。 MSETNX 是原子性的，因此它可以用作设置多个不同 key 表示不同字段(field)的唯一 性逻辑对象(unique logic object)，所有字段要么全被设置，要么全不被设置。 返回值： 当所有 key 都成功设置，返回 1 。 如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。

func (*RedisHandleModel) Multi 

func (rd *RedisHandleModel) Multi(f func()) error

func (*RedisHandleModel) Persist 

func (rd *RedisHandleModel) Persist(key string) (int, error)

PERSIST key 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。 返回值： 当生存时间移除成功时，返回 1 . 如果 key 不存在或 key 没有设置生存时间，返回 0 。

func (*RedisHandleModel) Ping 

func (rd *RedisHandleModel) Ping() error

使用客户端向 Redis 服务器发送一个 PING ，如果服务器运作正常的话，会返回一个 PONG 。 返回 error==nil 就是成功的

func (*RedisHandleModel) RedisWatch 

func (rd *RedisHandleModel) RedisWatch(f func() error, keys ...interface{}) error

redis的事务模式

func (*RedisHandleModel) Rename 

func (rd *RedisHandleModel) Rename(key, newkey string) (string, error)

RENAME key newkey

将 key 改名为 newkey 。 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。 当 newkey 已经存在时， RENAME 命令将覆盖旧值。 返回值： 改名成功时提示 OK ，失败时候返回一个错误。

func (*RedisHandleModel) RenameNx 

func (rd *RedisHandleModel) RenameNx(key, newkey string) (int, error)

RENAMENX key newkey

当且仅当 newkey 不存在时，将 key 改名为 newkey 。 当 key 不存在时，返回一个错误。 返回值： 修改成功时，返回 1 。 如果 newkey 已经存在，返回 0 。

func (*RedisHandleModel) Rpop 

func (rd *RedisHandleModel) Rpop(key string) (string, error)

RPOP key 移除并返回列表 key 的尾元素。 返回值： 列表的尾元素。 当 key 不存在时，返回 nil 。

func (*RedisHandleModel) RpopLpush 

func (rd *RedisHandleModel) RpopLpush(source, dest string) (string, error)

RPOPLPUSH source destination 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作： 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。 举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ， 执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。 如果 source 不存在，值 nil 被返回，并且不执行其他动作。 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。 时间复杂度： O(1) 返回值： 被弹出的元素。

func (*RedisHandleModel) Rpush 

func (rd *RedisHandleModel) Rpush(key, val string) (int, error)

RPUSH key value [value ...] 将一个或多个值 value 插入到列表 key 的表尾(最右边)。 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ， 得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。 返回值： 执行 RPUSH 操作后，表的长度。

func (*RedisHandleModel) RpushX 

func (rd *RedisHandleModel) RpushX(key, val string) (int, error)

RPUSHX key value 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。 和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。 返回值： RPUSHX 命令执行之后，表的长度。

func (*RedisHandleModel) Rpushs 

func (rd *RedisHandleModel) Rpushs(key string, vals ...string) (int, error)

RPUSH key value [value ...] 将一个或多个值 value 插入到列表 key 的表尾(最右边)。 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ， 得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。 返回值： 执行 RPUSH 操作后，表的长度。

func (*RedisHandleModel) SScan 

func (rd *RedisHandleModel) SScan(key string, cursor int, match string, count int) (int, []string, error)

SSCAN key cursor [MATCH pattern] [COUNT count] 命令用于迭代集合键中的元素。

func (*RedisHandleModel) Sadd 

func (rd *RedisHandleModel) Sadd(key string, member string) (int, error)

SADD key member [member ...] 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。 当 key 不是集合类型时，返回一个错误。 时间复杂度: O(N)， N 是被添加的元素的数量。 返回值: 被添加到集合中的新元素的数量，不包括被忽略的元素。

func (*RedisHandleModel) Sadds 

func (rd *RedisHandleModel) Sadds(key string, members ...string) (int, error)

同Sadd

func (*RedisHandleModel) Scan 

func (rd *RedisHandleModel) Scan(cursor int, match string, count int) (int, []string, error)

SCAN cursor [MATCH pattern] [COUNT count] cursor 0 MATCH "" count 10 SCAN 命令是一个基于游标的迭代器（cursor based iterator）： SCAN 命令每次被调用之后， 都会向用户返回一个新的游标， 用户在下次迭代时需要使用这个新游标作为 SCAN 命令的游标参数， 以此来延续之前的迭代过程。 当 SCAN 命令的游标参数被设置为 0 时， 服务器将开始一次新的迭代， 而当服务器向用户返回值为 0 的游标时， 表示迭代已结束。 返回： 1) "17" 2) 1) "key:12"

  1. "key:8"
  2. "key:4"
  3. "key:14"
  4. "key:16"
  5. "key:17"
  6. "key:15"
  7. "key:10"
  8. "key:3"
  9. "key:7"
  10. "key:1"

func (*RedisHandleModel) Scard 

func (rd *RedisHandleModel) Scard(key string) (int, error)

SCARD key 返回集合 key 的基数(集合中元素的数量)。 返回值： 集合的基数。 当 key 不存在时，返回 0 。

func (*RedisHandleModel) Sdiff 

func (rd *RedisHandleModel) Sdiff(keys ...interface{}) ([]string, error)

SDIFF key [key ...] 返回一个集合的全部成员，该集合是所有给定集合之间的差集。 不存在的 key 被视为空集。 时间复杂度: O(N)， N 是所有给定集合的成员数量之和。 返回值: 交集成员的列表。

func (*RedisHandleModel) SdiffStore 

func (rd *RedisHandleModel) SdiffStore(dest string, keys ...string) (int, error)

SDIFFSTORE destination key [key ...] 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。 时间复杂度: O(N)， N 是所有给定集合的成员数量之和。 返回值: 结果集中的元素数量。

func (*RedisHandleModel) Select 

func (rd *RedisHandleModel) Select(index int) error

SELECT index 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。 默认使用 0 号数据库。 返回 error==nil 就是成功的

func (*RedisHandleModel) Set 

func (rd *RedisHandleModel) Set(key string, val string, ex int64, n RedisSetParam) (interface{}, error)

SET key value [EX seconds] [PX milliseconds] [NX|XX] EX second ：设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value 。EX==-1表示不设置过期时间 PX millisecond ：设置键的过期时间为 millisecond 毫秒。 SET key value PX millisecond 效果等同于 PSETEX key millisecond value 。(不使用) NX ：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。 XX ：只在键已经存在时，才对键进行设置操作。

func (*RedisHandleModel) SetBit 

func (rd *RedisHandleModel) SetBit(key string, offset, val int) (int, error)

对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。 位的设置或清除取决于 value 参数，可以是 0 也可以是 1 。 当 key 不存在时，自动生成一个新的字符串值。 字符串会进行伸展(grown)以确保它可以将 value 保存在指定的偏移量上。当字符串值进行伸展时，空白位置以 0 填充。 offset 参数必须大于或等于 0 ，小于 2^32 (bit 映射被限制在 512 MB 之内)。 返回值： 指定偏移量原来储存的位数据

func (*RedisHandleModel) SetBytes 

func (rd *RedisHandleModel) SetBytes(key string, val []byte, ex int64, n RedisSetParam) (interface{}, error)

func (*RedisHandleModel) SetRange 

func (rd *RedisHandleModel) SetRange(key string, offset int, val string) (int, error)

SETRANGE key offset value 用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始。 不存在的 key 当作空白字符串处理。 SETRANGE 命令会确保字符串足够长以便将 value 设置在指定的偏移量上，如果给定 key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长， 

但你设置的 offset 是 10 )，那么原字符和偏移量之间的空白将用零字节(zerobytes, "\x00" )来填充。

注意你能使用的最大偏移量是 2^29-1(536870911) ，因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内。如果你需要使用比这更大的空间，你可以使用多个 key 。 当生成一个很长的字符串时，Redis 需要分配内存空间，该操作有时候可能会造成服务器阻塞(block)。 在2010年的Macbook Pro上，设置偏移量为 536870911(512MB 内存分配)，耗费约 300 毫秒， 设置偏移量为 134217728(128MB 内存分配)，耗费约 80 毫秒，设置偏移量 33554432(32MB 内存分配)， 耗费约 30 毫秒，设置偏移量为 8388608(8MB 内存分配)，耗费约 8 毫秒。 注意若首次内存分配成功之后，再对同一个 key 调用 SETRANGE 操作，无须再重新内存。 时间复杂度： 对小(small)的字符串，平摊复杂度O(1)。(关于什么字符串是”小”的，请参考 APPEND 命令) 否则为O(M)， M 为 value 参数的长度。 返回值： 被 SETRANGE 修改之后，字符串的长度。

例： # 对空字符串/不存在的 key 进行 SETRANGE redis> EXISTS empty_string (integer) 0 redis> SETRANGE empty_string 5 "Redis!" # 对不存在的 key 使用 SETRANGE (integer) 11 redis> GET empty_string # 空白处被"\x00"填充 "\x00\x00\x00\x00\x00Redis!"

func (*RedisHandleModel) Sinter 

func (rd *RedisHandleModel) Sinter(keys ...interface{}) ([]string, error)

SINTER key [key ...] 返回一个集合的全部成员，该集合是所有给定集合的交集。 不存在的 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。 时间复杂度: O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。 返回值: 交集成员的列表。

func (*RedisHandleModel) SinterStore 

func (rd *RedisHandleModel) SinterStore(dest string, keys ...string) (int, error)

SINTERSTORE destination key [key ...] 这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。 时间复杂度: O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。 返回值: 结果集中的成员数量。

func (*RedisHandleModel) Sismember 

func (rd *RedisHandleModel) Sismember(key, member string) (int, error)

SISMEMBER key member 判断 member 元素是否集合 key 的成员。 返回值: 如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

func (*RedisHandleModel) Smembers 

func (rd *RedisHandleModel) Smembers(key string) ([]string, error)

SMEMBERS key 返回集合 key 中的所有成员。 不存在的 key 被视为空集合。 时间复杂度: O(N)， N 为集合的基数。 返回值: 集合中的所有成员。

func (*RedisHandleModel) Smove 

func (rd *RedisHandleModel) Smove(source, dest, member string) (int, error)

SMOVE source destination member 将 member 元素从 source 集合移动到 destination 集合。 SMOVE 是原子性操作。 如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。 否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。 当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。 当 source 或 destination 不是集合类型时，返回一个错误。 返回值: 如果 member 元素被成功移除，返回 1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

func (*RedisHandleModel) Spop 

func (rd *RedisHandleModel) Spop(key string) (string, error)

SPOP key 移除并返回集合中的一个随机元素。 如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。 返回值: 被移除的随机元素。 当 key 不存在或 key 是空集时，返回 nil 。

func (*RedisHandleModel) SrandMember 

func (rd *RedisHandleModel) SrandMember(key string, count int) ([]string, error)

SRANDMEMBER key [count] 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。 从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数： 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。 时间复杂度: 只提供 key 参数时为 O(1) 。 如果提供了 count 参数，那么为 O(N) ，N 为返回数组的元素个数。 返回值: 只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。 如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组。

func (*RedisHandleModel) Srem 

func (rd *RedisHandleModel) Srem(key string, members ...string) (int, error)

SREM key member [member ...] 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。 当 key 不是集合类型，返回一个错误。 返回值: 被成功移除的元素的数量，不包括被忽略的元素。

func (*RedisHandleModel) StrLen 

func (rd *RedisHandleModel) StrLen(key string) (int, error)

STRLEN key 返回 key 所储存的字符串值的长度。 当 key 储存的不是字符串值时，返回一个错误。 返回值： 字符串值的长度。 当 key 不存在时，返回 0 。

func (*RedisHandleModel) Sunion 

func (rd *RedisHandleModel) Sunion(keys ...interface{}) ([]string, error)

SUNION key [key ...] 返回一个集合的全部成员，该集合是所有给定集合的并集。 不存在的 key 被视为空集。 时间复杂度: O(N)， N 是所有给定集合的成员数量之和。 返回值: 并集成员的列表。

func (*RedisHandleModel) SunionStore 

func (rd *RedisHandleModel) SunionStore(dest string, keys ...string) (int, error)

SUNIONSTORE destination key [key ...] 这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 已经存在，则将其覆盖。 destination 可以是 key 本身。 时间复杂度: O(N)， N 是所有给定集合的成员数量之和。 返回值: 结果集中的元素数量。

func (*RedisHandleModel) TTL 

func (rd *RedisHandleModel) TTL(key string) (int, error)

TTL key 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。 返回值： 当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间。

func (*RedisHandleModel) Type 

func (rd *RedisHandleModel) Type(key string) (string, error)

TYPE key 返回 key 所储存的值的类型。 返回值： none (key不存在) string (字符串) list (列表) set (集合) zset (有序集) hash (哈希表)

func (*RedisHandleModel) ZScan 

func (rd *RedisHandleModel) ZScan(key string, cursor int, match string, count int) (int, []string, error)

ZSCAN key cursor [MATCH pattern] [COUNT count] 命令用于迭代有序集合中的元素（包括元素成员和元素分值）。

func (*RedisHandleModel) Zadd 

func (rd *RedisHandleModel) Zadd(key string, score interface{}, member string) (int, error)

ZADD key score member [[score member] [score member] ...] 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。 score 值可以是整数值或双精度浮点数。 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。 当 key 存在但不是有序集类型时，返回一个错误。 对有序集的更多介绍请参见 sorted set 。 时间复杂度: O(M*log(N))， N 是有序集的基数， M 为成功添加的新成员的数量。 返回值: 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

func (*RedisHandleModel) Zadds 

func (rd *RedisHandleModel) Zadds(key string, li map[string]interface{}) (int, error)

看Zadd

func (*RedisHandleModel) Zcard 

func (rd *RedisHandleModel) Zcard(key string) (int, error)

ZCARD key 返回有序集 key 的基数。 返回值: 当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。

func (*RedisHandleModel) Zcount 

func (rd *RedisHandleModel) Zcount(key string, min, max interface{}) (int, error)

ZCOUNT key min max 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。 区间及无限 min 和 max 可以是 -inf 和 +inf ，这样一来， 你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。 时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为值在 min 和 max 之间的元素的数量。 返回值: score 值在 min 和 max 之间的成员的数量。

func (*RedisHandleModel) Zincrby 

func (rd *RedisHandleModel) Zincrby(key string, inc float64, member string) (string, error)

ZINCRBY key increment member 为有序集 key 的成员 member 的 score 值加上增量 increment 。 可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。 当 key 不是有序集类型时，返回一个错误。 score 值可以是整数值或双精度浮点数。 时间复杂度: O(log(N)) 返回值: member 成员的新 score 值，以字符串形式表示。

func (*RedisHandleModel) Zrange 

func (rd *RedisHandleModel) Zrange(key string, start, stop int) ([]string, error)

ZRANGE key start stop [WITHSCORES] 返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。 超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。 可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。 返回值: 指定区间内，成员列表。

func (*RedisHandleModel) ZrangeByScore 

func (rd *RedisHandleModel) ZrangeByScore(key string, min, max interface{}) ([]string, error)

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列。 时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为被结果集的基数。 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。 区间及无限 min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。 举个例子： ZRANGEBYSCORE zset (1 5 返回所有符合条件 1 < score <= 5 的成员，而 ZRANGEBYSCORE zset (5 (10 则返回所有符合条件 5 < score < 10 的成员。

func (*RedisHandleModel) ZrangeByScoreLimit 

func (rd *RedisHandleModel) ZrangeByScoreLimit(key string, min, max interface{}, offset, count int) ([]string, error)

看ZrangeByScore

func (*RedisHandleModel) ZrangeByScoreWithScore 

func (rd *RedisHandleModel) ZrangeByScoreWithScore(key string, min, max interface{}) (map[string]string, error)

看ZrangeByScore

func (*RedisHandleModel) ZrangeByScoreWithScoreLimit 

func (rd *RedisHandleModel) ZrangeByScoreWithScoreLimit(key string, min, max interface{}, offset, count int) (map[string]string, error)

看ZrangeByScore

func (*RedisHandleModel) ZrangeWithScores 

func (rd *RedisHandleModel) ZrangeWithScores(key string, start, stop int) (map[string]string, error)

看Zrange 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) ZrangeWithScoresByInt 

func (rd *RedisHandleModel) ZrangeWithScoresByInt(key string, start, stop int) (map[string]int, error)

看Zrange 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) Zrank 

func (rd *RedisHandleModel) Zrank(key, member string) (int, error)

ZRANK key member 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。 使用 ZREVRANK 命令可以获得成员按 score 值递减(从大到小)排列的排名。 时间复杂度: O(log(N)) 返回值: 如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

func (*RedisHandleModel) Zrem 

func (rd *RedisHandleModel) Zrem(key string, members ...string) (int, error)

ZREM key member [member ...] 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。 当 key 存在但不是有序集类型时，返回一个错误。 时间复杂度: O(M*log(N))， N 为有序集的基数， M 为被成功移除的成员的数量。 返回值: 被成功移除的成员的数量，不包括被忽略的成员。

func (*RedisHandleModel) ZremRangeByRank 

func (rd *RedisHandleModel) ZremRangeByRank(key string, start, stop int) (int, error)

ZREMRANGEBYRANK key start stop 移除有序集 key 中，指定排名(rank)区间内的所有成员。 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。 时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。 返回值: 被移除成员的数量。

func (*RedisHandleModel) ZremRangeByScore 

func (rd *RedisHandleModel) ZremRangeByScore(key string, min, max interface{}) (int, error)

ZREMRANGEBYSCORE key min max 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE 命令。 时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。 返回值: 被移除成员的数量。

func (*RedisHandleModel) ZrevRange 

func (rd *RedisHandleModel) ZrevRange(key string, start, stop int) ([]string, error)

ZREVRANGE key start stop [WITHSCORES] 返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。 时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) ZrevRangeByScore 

func (rd *RedisHandleModel) ZrevRangeByScore(key string, min, max interface{}) ([]string, error)

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count] 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。 除了成员按 score 值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。 时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为结果集的基数。 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) ZrevRangeByScoreLimit 

func (rd *RedisHandleModel) ZrevRangeByScoreLimit(key string, min, max interface{}, offset, count int) ([]string, error)

看ZrevRangeByScore

func (*RedisHandleModel) ZrevRangeByScoreWithScore 

func (rd *RedisHandleModel) ZrevRangeByScoreWithScore(key string, min, max interface{}) (map[string]string, error)

看ZrevRangeByScore

func (*RedisHandleModel) ZrevRangeByScoreWithScoreLimit 

func (rd *RedisHandleModel) ZrevRangeByScoreWithScoreLimit(key string, min, max interface{}, offset, count int) (map[string]string, error)

看ZrevRangeByScore

func (*RedisHandleModel) ZrevRangeWithScores 

func (rd *RedisHandleModel) ZrevRangeWithScores(key string, start, stop int) (map[string]string, error)

看ZrevRange 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) ZrevRangeWithScoresByInt 

func (rd *RedisHandleModel) ZrevRangeWithScoresByInt(key string, start, stop int) (map[string]int, error)

看ZrevRange 返回值: 指定区间内，带有 score 值(可选)的有序集成员的列表。

func (*RedisHandleModel) ZrevRank 

func (rd *RedisHandleModel) ZrevRank(key, member string) (int, error)

ZREVRANK key member 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。 时间复杂度: O(log(N)) 返回值: 如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

func (*RedisHandleModel) Zscore 

func (rd *RedisHandleModel) Zscore(key, member string) (string, error)

ZSCORE key member 返回有序集 key 中，成员 member 的 score 值。 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。 返回值: member 成员的 score 值，以字符串形式表示。

type RedisListSite 

type RedisListSite string

type RedisSetParam 

type RedisSetParam int

Set的NX XX的参数 

const (
	Set_No_NX_XX RedisSetParam = iota //不使用模式
	Set_NX                            //只在键不存在时，才对键进行设置操作
	Set_XX                            //只在键已经存在时，才对键进行设置操作
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.