redis

func (*BitField) Get ¶

func (b *BitField) Get(typ DataType, offset int) *BitField

Get type offset

返回指定的二进制位范围

func (*BitField) IncrBy ¶

func (b *BitField) IncrBy(typ DataType, offset, increment int) *BitField

IncrBy type offset increment

对指定的二进制位范围执行加法操作，并返回它的旧值

func (*BitField) Overflow ¶

func (b *BitField) Overflow(f BitFieldOverflow) *BitField

Overflow WARP|SAT|FAIL

用户可以通过 OVERFLOW 命令以及以下展示的三个参数， 指定 BITFIELD 命令在执行自增或者自减操作时， 碰上向上溢出（overflow）或者向下溢出（underflow）情况时的行为：

  WRAP ： 使用回绕（wrap around）方法处理有符号整数和无符号整数的溢出情况。
  对于无符号整数来说， 回绕就像使用数值本身与能够被储存的最大无符号整数执行取模计算， 这也是 C 语言的标准行为。
  对于有符号整数来说， 上溢将导致数字重新从最小的负数开始计算， 而下溢将导致数字重新从最大的正数开始计算。
  比如说， 如果我们对一个值为 127 的 i8 整数执行加一操作， 那么将得到结果 -128 。
  SAT ： 使用饱和计算（saturation arithmetic）方法处理溢出， 也即是说， 下溢计算的结果为最小的整数值，
  而上溢计算的结果为最大的整数值。 举个例子， 如果我们对一个值为 120 的 i8 整数执行加 10 计算，
  那么命令的结果将为 i8 类型所能储存的最大整数值 127 。 与此相反， 如果一个针对 i8 值的计算造成了下溢，
  那么这个 i8 值将被设置为 -127 。
  FAIL ： 在这一模式下， 命令将拒绝执行那些会导致上溢或者下溢情况出现的计算， 并向用户返回空值表示计算未被执行。

需要注意的是， OVERFLOW 子命令只会对紧随着它之后被执行的 INCRBY 命令产生效果，
这一效果将一直持续到与它一同被执行的下一个 OVERFLOW 命令为止。 在默认情况下， INCRBY 命令使用 WRAP 方式来处理溢出计算。

func (*BitField) Run ¶

func (b *BitField) Run() ([]int64, error)

Run ...

func (*BitField) Set ¶

func (b *BitField) Set(typ DataType, offset, value int) *BitField

Set type offset, value

对指定的二进制位范围进行设置，并返回它的旧值

func (*HScan) ALL ¶

func (r *HScan) ALL() (map[string]string, error)

ALL ...

func (*HScan) Each ¶

func (r *HScan) Each(f func(k int, field, value string) error) error

Each ...

func (*HScan) Next ¶

func (r *HScan) Next() (map[string]string, error)

Next ...

func (*Object) Encoding ¶

func (r *Object) Encoding() (string, error)

Encoding <key> 返回给定 key 锁储存的值所使用的内部表示(representation)。

func (*Object) IdleTime ¶

func (r *Object) IdleTime() (int, error)

IdleTime <key> 返回给定 key 自储存以来的空闲时间(idle， 没有被读取也没有被写入)，以秒为单位。

func (*Object) RefCount ¶

func (r *Object) RefCount() (int, error)

RefCount <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。

func (*PubSub) Channels ¶

func (r *PubSub) Channels(patterns ...string) ([]string, error)

Channels [pattern]

列出当前的活跃频道。

活跃频道指的是那些至少有一个订阅者的频道， 订阅模式的客户端不计算在内。

pattern 参数是可选的：

  如果不给出 pattern 参数，那么列出订阅与发布系统中的所有活跃频道。
  如果给出 pattern 参数，那么只列出和给定模式 pattern 相匹配的那些活跃频道。

复杂度： O(N) ， N 为活跃频道的数量（对于长度较短的频道和模式来说，将进行模式匹配的复杂度视为常数）。

返回值
  一个由活跃频道组成的列表。

func (*PubSub) NumPattern ¶

func (r *PubSub) NumPattern() (int, error)

NumPattern ...

返回订阅模式的数量。

注意， 这个命令返回的不是订阅模式的客户端的数量， 而是客户端订阅的所有模式的数量总和。

复杂度： O(1) 。

返回值
  一个整数回复（Integer reply）。

func (*PubSub) NumSubscribe ¶

func (r *PubSub) NumSubscribe(channels ...string) (map[string]int, error)

NumSubscribe [channel-1 ... channel-N]

返回给定频道的订阅者数量， 订阅模式的客户端不计算在内。

复杂度： O(N) ， N 为给定频道的数量。

返回值
  一个多条批量回复（Multi-bulk reply），回复中包含给定的频道，以及频道的订阅者数量。
  格式为：频道 channel-1 ， channel-1 的订阅者数量，频道 channel-2 ， channel-2 的订阅者数量，诸如此类。
  回复中频道的排列顺序和执行命令时给定频道的排列顺序一致。 不给定任何频道而直接调用这个命令也是可以的， 在这种情况下， 命令只返回一个空列表。

func (*Redis) Append ¶

func (r *Redis) Append(key, value string) (int, error)

Append key value

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

func (*Redis) Auth ¶

func (r *Redis) Auth(password string) error

Auth password

可用版本： >= 1.0.0
时间复杂度： O(1)

通过设置配置文件中 requirepass 项的值(使用命令 CONFIG SET requirepass password )，可以使用密码来保护 Redis 服务器。

如果开启了密码保护的话，在每次连接 Redis 服务器之后，就要使用 AUTH 命令解锁，解锁之后才能使用其他 Redis 命令。

如果 AUTH 命令给定的密码 password 和配置文件中的密码相符的话，服务器会返回 OK 并开始接受命令输入。

另一方面，假如密码不匹配的话，服务器将返回一个错误，并要求客户端需重新输入密码。

因为 Redis 高性能的特点，在很短时间内尝试猜测非常多个密码是有可能的，因此请确保使用的密码足够复杂和足够长，以免遭受密码猜测攻击。

返回值：
  密码匹配时返回 OK ，否则返回一个错误。

func (*Redis) BLPop ¶

func (r *Redis) BLPop(timeout time.Duration, key string, keys ...string) (map[string]string, error)

BLPop key [key ...] timeout

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 “这样的顺序，第一个找到的非空列表。

阻塞行为

  如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。

  超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

func (*Redis) BRPop ¶

func (r *Redis) BRPop(timeout time.Duration, key string, keys ...string) (map[string]string, error)

BRPop key [key ...] timeout

可用版本： >= 2.0.0
时间复杂度： O(1)

BRPOP 是列表的阻塞式(blocking)弹出原语。

它是 RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。

关于阻塞操作的更多信息，请查看 BLPOP 命令， BRPOP 除了弹出元素的位置和 BLPOP 不同之外，其他表现一致。

返回值：
  假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
  反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

func (*Redis) BRPopLPush ¶

func (r *Redis) BRPopLPush(source, destination string, timeout time.Duration) (NullString, error)

BRPopLPush source destination timeout

BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。

当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

更多相关信息，请参考 RPOPLPUSH 命令。

可用版本：>= 2.2.0
时间复杂度： O(1)
返回值：
  假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
  反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。

func (*Redis) BitCount ¶

func (r *Redis) BitCount(key string, startEnd ...int) (int, error)

BitCount key [start] [end]

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

时间复杂度： O(N)
返回值：
  被设置为 1 的位的数量。

func (*Redis) BitField ¶

func (r *Redis) BitField(key string) *BitField

BitField key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]

Available since 3.2.0.
Time complexity: O(1) for each subcommand specified

BITFIELD 命令可以将一个 Redis 字符串看作是一个由二进制位组成的数组， 并对这个数组中储存的长度不同的整数进行访问 （被储存的整数无需进行对齐）。
换句话说， 通过这个命令， 用户可以执行诸如 “对偏移量 1234 上的 5 位长有符号整数进行设置”、 “获取偏移量 4567 上的 31 位长无符号整数”等操作。
此外， BITFIELD 命令还可以对指定的整数执行加法操作和减法操作， 并且这些操作可以通过设置妥善地处理计算时出现的溢出情况。

BITFIELD 命令可以在一次调用中同时对多个位范围进行操作： 它接受一系列待执行的操作作为参数， 并返回一个数组作为回复， 数组中的每个元素就是对应操作的执行结果。

注意：

  使用 GET 子命令对超出字符串当前范围的二进制位进行访问（包括键不存在的情况）， 超出部分的二进制位的值将被当做是 0 。
  使用 SET 子命令或者 INCRBY 子命令对超出字符串当前范围的二进制位进行访问将导致字符串被扩大， 被扩大的部分会使用值为 0 的二进制位进行填充。
  在对字符串进行扩展时， 命令会根据字符串目前已有的最远端二进制位， 计算出执行操作所需的最小长度。

以下是 BITFIELD 命令支持的子命令：

  GET <type> <offset> —— 返回指定的二进制位范围。
  SET <type> <offset> <value> —— 对指定的二进制位范围进行设置，并返回它的旧值。
  INCRBY <type> <offset> <increment> —— 对指定的二进制位范围执行加法操作，并返回它的旧值。用户可以通过向 increment 参数传入负值来实现相应的减法操作。

除了以上三个子命令之外， 还有一个子命令， 它可以改变之后执行的 INCRBY 子命令在发生溢出情况时的行为：

  OVERFLOW [WRAP|SAT|FAIL]

当被设置的二进制位范围值为整数时， 用户可以在类型参数的前面添加 i 来表示有符号整数， 或者使用 u 来表示无符号整数。
比如说， 我们可以使用 u8 来表示 8 位长的无符号整数， 也可以使用 i16 来表示 16 位长的有符号整数。

BITFIELD 命令最大支持 64 位长的有符号整数以及 63 位长的无符号整数， 其中无符号整数的 63 位长度限制是由于 Redis 协议目前还无法返回 64 位长的无符号整数而导致的。

func (*Redis) BitOp ¶

func (r *Redis) BitOp(op BitOp, destkey string, keys ...string) (int, error)

BitOp operation destkey key [key ...]

Available since 2.6.0.
Time complexity: O(N)

对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。

operation 可以是 AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种：

  BITOP AND destkey key [key ...] ，对一个或多个 key 求逻辑并，并将结果保存到 destkey 。
  BITOP OR destkey key [key ...] ，对一个或多个 key 求逻辑或，并将结果保存到 destkey 。
  BITOP XOR destkey key [key ...] ，对一个或多个 key 求逻辑异或，并将结果保存到 destkey 。
  BITOP NOT destkey key ，对给定 key 求逻辑非，并将结果保存到 destkey 。
  除了 NOT 操作之外，其他操作都可以接受一个或多个 key 作为输入。

处理不同长度的字符串

 当 BITOP 处理不同长度的字符串时，较短的那个字符串所缺少的部分会被看作 0 。
 空的 key 也被看作是包含 0 的字符串序列。

返回值：
  保存到 destkey 的字符串的长度，和输入 key 中最长的字符串长度相等。

func (*Redis) Decr ¶

func (r *Redis) Decr(key string) (int, error)

Decr key

可用版本： >= 1.0.0
时间复杂度： O(1)

将 key 中储存的数字值减一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

返回值：
  执行 DECR 命令之后 key 的值。

func (*Redis) DecrBy ¶

func (r *Redis) DecrBy(key string, decrement int) (int, error)

DecrBy key decrement

可用版本： >= 1.0.0
时间复杂度： O(1)

将 key 所储存的值减去减量 decrement 。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。
关于更多递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。

返回值：
  减去 decrement 之后， key 的值。

func (*Redis) Del ¶

func (r *Redis) Del(key string, keys ...string) (int, error)

Del key [key ...]

可用版本： >= 1.0.0
时间复杂度： O(N)， N 为被删除的 key 的数量。

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

返回值：
  被删除 key 的数量

func (*Redis) Discard ¶

func (r *Redis) Discard() error

Discard ...

取消事务，放弃执行事务块内的所有命令。

如果正在使用 WATCH 命令监视某个(或某些) key，那么取消所有监视，等同于执行命令 UNWATCH 。

可用版本：>= 2.0.0
时间复杂度：O(1)。

返回值：
  总是返回 OK 。

func (*Redis) Dump ¶

func (r *Redis) Dump(key string) (NullString, error)

Dump key

可用版本： >= 2.6.0
时间复杂度：
  查找给定键的复杂度为 O(1) ，对键进行序列化的复杂度为 O(N*M) ，其中 N 是构成 key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。
  如果序列化的对象是比较小的字符串，那么复杂度为 O(1) 。

序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为 Redis 键。
序列化生成的值有以下几个特点：

它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。
值的编码格式和 RDB 文件保持一致。
RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么 Redis 会拒绝对这个值进行反序列化操作。
序列化的值不包括任何生存时间信息。

返回值：
  如果 key 不存在，那么返回 nil 。
  否则，返回序列化之后的值。

func (*Redis) Echo ¶

func (r *Redis) Echo(message string) (NullString, error)

Echo message

可用版本： >= 1.0.0
时间复杂度： O(1)

打印一个特定的信息 message ，测试时使用。

返回值：
  message 自身。

func (*Redis) Exec ¶

func (r *Redis) Exec()

Exec ...

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

假如某个(或某些) key 正处于 WATCH 命令的监视之下，且事务块中有和这个(或这些) key 相关的命令，那么 EXEC 命令只在这个(或这些) key 没有被其他命令所改动的情况下执行并生效，否则该事务被打断(abort)。

可用版本：>= 1.2.0
时间复杂度：事务块内所有命令的时间复杂度的总和。

返回值：
  事务块内所有命令的返回值，按命令执行的先后顺序排列。
  当操作被打断时，返回空值 nil 。

func (*Redis) Exists ¶

func (r *Redis) Exists(key string) (bool, error)

Exists key

可用版本：>= 1.0.0
时间复杂度： O(1)

检查给定 key 是否存在。

返回值：
  若 key 存在，返回 1 ，否则返回 0

func (*Redis) Expire ¶

func (r *Redis) Expire(key string, t time.Duration) (bool, error)

Expire key seconds

可用版本： >= 1.0.0
时间复杂度： O(1)

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。
生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。

比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPush 命令，或者对一个哈希表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。

另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。

RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。

使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久的』(persistent) key 。

更新生存时间

  可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。

过期时间的精确度

  在 Redis 2.4 版本中，过期时间的延迟在 1 秒钟之内 —— 也即是，就算 key 已经过期，但它还是可能在过期之后一秒钟之内被访问到，而在新的 Redis 2.6 版本中，延迟被降低到 1 毫秒之内。

  Redis 2.1.3 之前的不同之处

  在 Redis 2.1.3 之前的版本中，修改一个带有生存时间的 key 会导致整个 key 被删除，这一行为是受当时复制(replication)层的限制而作出的，现在这一限制已经被修复。

返回值：
  设置成功返回 1 。
  当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

注意：这里没有实现EXPIRE命令

func (*Redis) ExpireAt ¶

func (r *Redis) ExpireAt(key string, t time.Time) (bool, error)

ExpireAt key timestamp

可用版本： >= 1.2.0
时间复杂度： O(1)

EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。

不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

返回值：
  如果生存时间设置成功，返回 1 。
  当 key 不存在或没办法设置生存时间，返回 0 。

注意：这里没有实现EXPIREAT方法

func (*Redis) FlushDB ¶

func (r *Redis) FlushDB() error

FlushDB ...

func (*Redis) GeoAdd ¶

func (r *Redis) GeoAdd(key string, geo GeoLocation, geos ...GeoLocation) (int, error)

GeoAdd key longitude latitude member [longitude latitude member ...]

将给定的空间元素（纬度、经度、名字）添加到指定的键里面。 这些数据会以有序集合的形式被储存在键里面， 从而使得像 GEORADIUS 和 GEORADIUSBYMEMBER 这样的命令可以在之后通过位置查询取得这些元素。

GEOADD 命令以标准的 x,y 格式接受参数， 所以用户必须先输入经度， 然后再输入纬度。 GEOADD 能够记录的坐标是有限的： 非常接近两极的区域是无法被索引的。 精确的坐标限制由 EPSG:900913 / EPSG:3785 / OSGEO:41001 等坐标系统定义， 具体如下：

有效的经度介于 -180 度至 180 度之间。
有效的纬度介于 -85.05112878 度至 85.05112878 度之间。
当用户尝试输入一个超出范围的经度或者纬度时， GEOADD 命令将返回一个错误。

可用版本：>= 3.2.0
时间复杂度：每添加一个元素的复杂度为 O(log(N)) ， 其中 N 为键里面包含的位置元素数量。

返回值：
  新添加到键里面的空间元素数量， 不包括那些已经存在但是被更新的元素。

func (*Redis) GeoDist ¶

func (r *Redis) GeoDist(key, member1, member2 string, unit ...string) (float64, error)

GeoDist key member1 member2 [unit]

返回两个给定位置之间的距离。

如果两个位置之间的其中一个不存在， 那么命令返回空值。

指定单位的参数 unit 必须是以下单位的其中一个：

  m 表示单位为米。
  km 表示单位为千米。
  mi 表示单位为英里。
  ft 表示单位为英尺。

如果用户没有显式地指定单位参数， 那么 GEODIST 默认使用米作为单位。

GEODIST 命令在计算距离时会假设地球为完美的球形， 在极限情况下， 这一假设最大会造成 0.5% 的误差。

可用版本：>= 3.2.0
复杂度：O(log(N))

返回值：
  计算出的距离会以双精度浮点数的形式被返回。 如果给定的位置元素不存在， 那么命令返回空值。

func (*Redis) GeoHash ¶

func (r *Redis) GeoHash(key, member string, members ...string) ([]string, error)

GeoHash key member [member ...]

返回一个或多个位置元素的 Geohash 表示。

可用版本：>= 3.2.0
时间复杂度：寻找每个位置元素的复杂度为 O(log(N)) ， 其中 N 为给定键包含的位置元素数量。

返回值：
  一个数组， 数组的每个项都是一个 geohash 。 命令返回的 geohash 的位置与用户给定的位置元素的位置一一对应。

func (*Redis) GeoPos ¶

func (r *Redis) GeoPos(key, member string, members ...string) ([]*GeoLocation, error)

GeoPos key member [member ...]

从键里面返回所有给定位置元素的位置（经度和纬度）。

因为 GEOPOS 命令接受可变数量的位置元素作为输入， 所以即使用户只给定了一个位置元素， 命令也会返回数组回复。

可用版本：>= 3.2.0
时间复杂度：获取每个位置元素的复杂度为 O(log(N)) ， 其中 N 为键里面包含的位置元素数量。

返回值：
  GEOPOS 命令返回一个数组， 数组中的每个项都由两个元素组成： 第一个元素为给定位置元素的经度， 而第二个元素则为给定位置元素的纬度。
  当给定的位置元素不存在时， 对应的数组项为空值。

func (*Redis) GeoRadius ¶

func (r *Redis) GeoRadius(key string, longitude, latitude, radius float64, unit string)

GeoRadius key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [ASC|DESC] [COUNT count]

以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。

范围可以使用以下其中一个单位：

  m 表示单位为米。
  km 表示单位为千米。
  mi 表示单位为英里。
  ft 表示单位为英尺。

在给定以下可选项时， 命令会返回额外的信息：

  WITHDIST ： 在返回位置元素的同时， 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。
  WITHCOORD ： 将位置元素的经度和维度也一并返回。
  WITHHASH ： 以 52 位有符号整数的形式， 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试， 实际中的作用并不大。

命令默认返回未排序的位置元素。 通过以下两个参数， 用户可以指定被返回位置元素的排序方式：

  ASC ： 根据中心的位置， 按照从近到远的方式返回位置元素。
  DESC ： 根据中心的位置， 按照从远到近的方式返回位置元素。

在默认情况下， GEORADIUS 命令会返回所有匹配的位置元素。 虽然用户可以使用 COUNT <count> 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。

可用版本：>= 3.2.0
时间复杂度：O(N+log(M))， 其中 N 为指定半径范围内的位置元素数量， 而 M 则是被返回位置元素的数量。

返回值：
  GEORADIUS 命令返回一个数组， 具体来说：

    在没有给定任何 WITH 选项的情况下， 命令只会返回一个像 ["New York","Milan","Paris"] 这样的线性（linear）列表。
    在指定了 WITHCOORD 、 WITHDIST 、 WITHHASH 等选项的情况下， 命令返回一个二层嵌套数组， 内层的每个子数组就表示一个元素。

  在返回嵌套数组时， 子数组的第一个元素总是位置元素的名字。 至于额外的信息， 则会作为子数组的后续元素， 按照以下顺序被返回：

    以浮点数格式返回的中心与位置元素之间的距离， 单位与用户指定范围时的单位一致。
    geohash 整数。
    由两个元素组成的坐标，分别为经度和纬度。

举个例子， GEORADIUS Sicily 15 37 200 km withcoord withdist 这样的命令返回的每个子数组都是类似以下格式的：

["Palermo","190.4424",["13.361389338970184","38.115556395496299"]]

func (*Redis) GeoRadiusByMember ¶

func (r *Redis) GeoRadiusByMember()

GeoRadiusByMember key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [ASC|DESC] [COUNT count]

这个命令和 GEORADIUS 命令一样， 都可以找出位于指定范围内的元素， 但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的， 而不是像 GEORADIUS 那样， 使用输入的经度和纬度来决定中心点。

关于 GEORADIUSBYMEMBER 命令的更多信息， 请参考 GEORADIUS 命令的文档。

可用版本：>= 3.2.0
时间复杂度：O(log(N)+M)， 其中 N 为指定范围之内的元素数量， 而 M 则是被返回的元素数量。

返回值：
  一个数组， 数组中的每个项表示一个范围之内的位置元素。

func (*Redis) Get ¶

func (r *Redis) Get(key string) (NullString, error)

Get key

可用版本： >= 1.0.0
时间复杂度： O(1)

返回 key 所关联的字符串值。
如果 key 不存在那么返回特殊值 nil 。
假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。

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

func (*Redis) GetBit ¶

func (r *Redis) GetBit(key string, offset int) (int, error)

GetBit key offset

可用版本： >= 2.2.0
时间复杂度： O(1)

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

返回值：
  字符串值指定偏移量上的位(bit)。

func (*Redis) GetRange ¶

func (r *Redis) GetRange(key string, start, end int) (string, error)

GetRange key start end

可用版本： >= 2.4.0
时间复杂度： O(N)， N 为要返回的字符串的长度。

返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。
GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

复杂度最终由字符串的返回值长度决定，但因为从已有字符串中取出子字符串的操作非常廉价(cheap)，所以对于长度不大的字符串，该操作的复杂度也可看作O(1)。

返回值：
  截取得出的子字符串。

func (*Redis) GetSet ¶

func (r *Redis) GetSet(key, value string) (NullString, error)

GetSet key value

可用版本： >= 1.0.0
时间复杂度： O(1)

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

返回值：
  返回给定 key 的旧值。
  当 key 没有旧值时，也即是， key 不存在时，返回 nil 。

func (*Redis) HDel ¶

func (r *Redis) HDel(field string, fields ...string) (int, error)

HDel key field [field ...]

可用版本：>= 2.0.0
时间复杂度: O(N)， N 为要删除的域的数量。

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

在Redis2.4以下的版本里， HDEL 每次只能删除单个域，如果你需要在一个原子时间内删除多个域，请将命令包含在 MULTI / EXEC 块内。

返回值:
  被成功移除的域的数量，不包括被忽略的域。

func (*Redis) HExists ¶

func (r *Redis) HExists(key, field string) (bool, error)

HExists key field

查看哈希表 key 中，给定域 field 是否存在。

可用版本： >= 2.0.0
时间复杂度： O(1)
返回值：
  如果哈希表含有给定域，返回 1 。
  如果哈希表不含有给定域，或 key 不存在，返回 0 。

func (*Redis) HGet ¶

func (r *Redis) HGet(key, field string) (NullString, error)

HGet key field

可用版本： >= 2.0.0
时间复杂度：O(1)

返回哈希表 key 中给定域 field 的值。

返回值：
  给定域的值。
  当给定域不存在或是给定 key 不存在时，返回 nil 。

func (*Redis) HGetALL ¶

func (r *Redis) HGetALL(key string) (map[string]string, error)

HGetALL key

可用版本： >= 2.0.0
时间复杂度： O(N)， N 为哈希表的大小。

返回哈希表 key 中，所有的域和值。

在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

返回值：
  以列表形式返回哈希表的域和域的值。
  若 key 不存在，返回空列表。

func (*Redis) HIncrBy ¶

func (r *Redis) HIncrBy(key, field string, increment int) (int, error)

HIncrBy key field increment

可用版本： >= 2.0.0
时间复杂度： O(1)

为哈希表 key 中的域 field 的值加上增量 increment 。

增量也可以为负数，相当于对给定域进行减法操作。

如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。

如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。

对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。

本操作的值被限制在 64 位(bit)有符号数字表示之内。

返回值：
  执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。

func (*Redis) HIncrByFloat ¶

func (r *Redis) HIncrByFloat(key, field string, increment float64) (float64, error)

HIncrByFloat key field increment

可用版本： >= 2.6.0
时间复杂度： O(1)

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

如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。

如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。

当以下任意一个条件发生时，返回一个错误：

  域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
  域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number)

HINCRBYFLOAT 命令的详细功能和 INCRBYFLOAT 命令类似，请查看 INCRBYFLOAT 命令获取更多相关信息。

返回值：
  执行加法操作之后 field 域的值。

func (*Redis) HKeys ¶

func (r *Redis) HKeys(key string) ([]string, error)

HKeys key

可用版本： >= 2.0.0
时间复杂度： O(N)， N 为哈希表的大小。

返回哈希表 key 中的所有域。

返回值：
  一个包含哈希表中所有域的表。
  当 key 不存在时，返回一个空表。

func (*Redis) HLen ¶

func (r *Redis) HLen(key string) (int, error)

HLen key

时间复杂度： O(1)

返回哈希表 key 中域的数量。

返回值：
  哈希表中域的数量。
  当 key 不存在时，返回 0 。

func (*Redis) HMGet ¶

func (r *Redis) HMGet(key, field string, fields ...string) ([]NullString, error)

HMGet key field [field ...]

可用版本： >= 2.0.0
时间复杂度： O(N)， N 为给定域的数量。

返回哈希表 key 中，一个或多个给定域的值。

如果给定的域不存在于哈希表，那么返回一个 nil 值。

因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

返回值：
  一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

func (*Redis) HMSet ¶

func (r *Redis) HMSet(key, field, value string, kvs ...string) error

HMSet key field value [field value ...]

可用版本： >= 2.0.0
时间复杂度： O(N)， N 为 field-value 对的数量。

同时将多个 field-value (域-值)对设置到哈希表 key 中。

此命令会覆盖哈希表中已存在的域。

如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

返回值：
  如果命令执行成功，返回 OK 。
  当 key 不是哈希表(hash)类型时，返回一个错误。

func (*Redis) HScan ¶

func (r *Redis) HScan(key string, options ...ScanOption) *HScan

HScan ...

参见Scan的文档

func (*Redis) HSet ¶

func (r *Redis) HSet(key, field, value string) (bool, error)

HSet key field value

可用版本： >= 2.0.0
时间复杂度： O(1)

将哈希表 key 中的域 field 的值设为 value 。

如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。

如果域 field 已经存在于哈希表中，旧值将被覆盖。

返回值：
  如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
  如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。

func (*Redis) HSetNX ¶

func (r *Redis) HSetNX(key, field, value string) (bool, error)

HSetNX key field value

可用版本： >= 2.0.0
时间复杂度： O(1)

将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。

若域 field 已经存在，该操作无效。

如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。

返回值：
  设置成功，返回 1 。
  如果给定域已经存在且没有操作被执行，返回 0 。

func (*Redis) HStrLen ¶

func (r *Redis) HStrLen(key, field string) (int, error)

HStrLen key field

可用版本： >= 3.2.0
时间复杂度： O(1)

返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）。

如果给定的键或者域不存在， 那么命令返回 0 。

返回值：
  一个整数。

func (*Redis) HVals ¶

func (r *Redis) HVals(key string) ([]string, error)

HVals key

返回哈希表 key 中所有域的值。

可用版本： >= 2.0.0
时间复杂度： O(N)， N 为哈希表的大小。
返回值：
  一个包含哈希表中所有值的表。
  当 key 不存在时，返回一个空表。

func (*Redis) Incr ¶

func (r *Redis) Incr(key string) (int, error)

Incr key

可用版本： >= 1.0.0
时间复杂度： O(1)

将 key 中储存的数字值增一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。
这是一个针对字符串的操作，因为 Redis 没有专用的整数类型，所以 key 内储存的字符串被解释为十进制 64 位有符号整数来执行 INCR 操作。

返回值：
  执行 INCR 命令之后 key 的值。

func (*Redis) IncrBy ¶

func (r *Redis) IncrBy(key string, increment int) (int, error)

IncrBy key

可用版本： >= 1.0.0
时间复杂度： O(1)

将 key 所储存的值加上增量 increment 。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。
关于递增(increment) / 递减(decrement)操作的更多信息，参见 INCR 命令。

返回值：
  加上 increment 之后， key 的值。

func (*Redis) IncrByFloat ¶

func (r *Redis) IncrByFloat(key string, increment float64) (float64, error)

IncrByFloat key increment

可用版本： >= 2.6.0
时间复杂度： O(1)

为 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）

返回值：
  执行命令之后 key 的值。

func (*Redis) Keys ¶

func (r *Redis) Keys(pattern string) ([]string, error)

Keys pattern

可用版本： >= 1.0.0
时间复杂度： O(N)， N 为数据库中 key 的数量。

查找所有符合给定模式 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 (*Redis) LIndex ¶

func (r *Redis) LIndex(key string, index int) (NullString, error)

LIndex key index

可用版本： >= 1.0.0
时间复杂度： O(N)， N 为到达下标 index 过程中经过的元素数量。

返回列表 key 中，下标为 index 的元素。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

如果 key 不是列表类型，返回一个错误。

因此，对列表的头元素和尾元素执行 LINDEX 命令，复杂度为O(1)。
返回值:
  列表中下标为 index 的元素。
  如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

func (*Redis) LInsert ¶

func (r *Redis) LInsert(key string, before bool, pivot, value string) (int, error)

LInsert key BEFORE|AFTER pivot value

可用版本： >= 2.2.0
时间复杂度: O(N)， N 为寻找 pivot 过程中经过的元素数量。

将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

当 pivot 不存在于列表 key 时，不执行任何操作。

当 key 不存在时， key 被视为空列表，不执行任何操作。

如果 key 不是列表类型，返回一个错误。

返回值:
  如果命令执行成功，返回插入操作完成之后，列表的长度。
  如果没有找到 pivot ，返回 -1 。
  如果 key 不存在或为空列表，返回 0 。

func (*Redis) LLen ¶

func (r *Redis) LLen(key string) (int, error)

LLen key

可用版本： >= 1.0.0
时间复杂度： O(1)

返回列表 key 的长度。

如果 key 不存在，则 key 被解释为一个空列表，返回 0 .

如果 key 不是列表类型，返回一个错误。

返回值：
  列表 key 的长度。

func (*Redis) LPop ¶

func (r *Redis) LPop(key string) (NullString, error)

LPop key

可用版本： >= 1.0.0
时间复杂度： O(1)

移除并返回列表 key 的头元素。

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

func (*Redis) LPush ¶

func (r *Redis) LPush(key, value string, values ...string) (int, error)

LPush key value [value ...]

可用版本： >= 1.0.0
时间复杂度： O(1)

将一个或多个值 value 插入到列表 key 的表头

如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPush mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPush mylist a 、 LPush mylist b 和 LPush mylist c 三个命令。

如果 key 不存在，一个空列表会被创建并执行 LPush 操作。

当 key 存在但不是列表类型时，返回一个错误。

在Redis 2.4版本以前的 LPush 命令，都只接受单个 value 值。

返回值：
  执行 LPush 命令后，列表的长度。

func (*Redis) LPushX ¶

func (r *Redis) LPushX(key, value string) (int, error)

LPushX key value

可用版本： >= 2.2.0
时间复杂度： O(1)

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

和 LPUSH 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。

返回值：
  LPUSHX 命令执行之后，表的长度。

func (*Redis) LRange ¶

func (r *Redis) LRange(key string, start, stop int) ([]string, error)

LRange key start stop

可用版本： >= 1.0.0
时间复杂度: O(S+N)， S 为偏移量 start ， N 为指定区间内元素的数量。

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

注意LRANGE命令和编程语言区间函数的区别

假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。

超出范围的下标

  超出范围的下标值不会引起错误。
  如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
  如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

返回值:
  一个列表，包含指定区间内的元素。

func (*Redis) LRem ¶

func (r *Redis) LRem(key string, count int, value string) (int, error)

LRem key count value

可用版本：>= 1.0.0
时间复杂度： O(N)， N 为列表的长度。

根据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值可以是以下几种：

  count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
  count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
  count = 0 : 移除表中所有与 value 相等的值。

返回值：
  被移除元素的数量。
  因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

func (*Redis) LSet ¶

func (r *Redis) LSet(key string, index int, value string) error

LSet key index value

可用版本： >= 1.0.0
时间复杂度： 对头元素或尾元素进行 LSET 操作，复杂度为 O(1)。
其他情况下，为 O(N)， N 为列表的长度。

将列表 key 下标为 index 的元素的值设置为 value 。

当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

关于列表下标的更多信息，请参考 LINDEX 命令。

返回值：
  操作成功返回 ok ，否则返回错误信息。

func (*Redis) LTRIM ¶

func (r *Redis) LTRIM(key string, start, stop int) (int, error)

LTRIM key start stop

可用版本： >= 1.0.0
时间复杂度: O(N)， N 为被移除的元素的数量。

对一个列表进行修剪(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 。

返回值:
  命令执行成功时，返回 ok 。

func (*Redis) MGet ¶

func (r *Redis) MGet(key string, keys ...string) ([]NullString, error)

MGet ...

可用版本： >= 1.0.0
时间复杂度: O(N) , N 为给定 key 的数量。

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

返回值：
  一个包含所有给定 key 的值的列表。

func (*Redis) MSet ¶

func (r *Redis) MSet(key, value string, kvs ...string) error

MSet ...

可用版本： >= 1.0.1
时间复杂度： O(N)， N 为要设置的 key 数量。

同时设置一个或多个 key-value 对。
如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。

返回值：
  总是返回 OK (因为 MSET 不可能失败)

func (*Redis) MSetNX ¶

func (r *Redis) MSetNX(key, value string, kvs ...string) (bool, error)

MSetNX key value [key value ...]

同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
即使只有一个给定 key 已存在， MSETNX 也会拒绝执行所有给定 key 的设置操作。
MSETNX 是原子性的，因此它可以用作设置多个不同 key 表示不同字段(field)的唯一性逻辑对象(unique logic object)，所有字段要么全被设置，要么全不被设置。

可用版本：>= 1.0.1
时间复杂度：O(N)， N 为要设置的 key 的数量。

返回值：
  当所有 key 都成功设置，返回 1 。
  如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。

func (*Redis) Migrate ¶

func (r *Redis) Migrate(host string, port int, key string, destinationDB int, timeout time.Duration, options ...MigrateOption) error

Migrate host port key destination-db timeout [COPY] [REPLACE]

可用版本： >= 2.6.0
时间复杂度：
  这个命令在源实例上实际执行 DUMP 命令和 DEL 命令，在目标实例执行 RESTORE 命令，查看以上命令的文档可以看到详细的复杂度说明。
  key 数据在两个实例之间传输的复杂度为 O(N) 。

将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。

这个命令是一个原子操作，它在执行的时候会阻塞进行迁移的两个实例，直到以下任意结果发生：迁移成功，迁移失败，等待超时。

命令的内部实现是这样的：它在当前实例对给定 key 执行 DUMP 命令 ，将它序列化，然后传送到目标实例，目标实例再使用 RESTORE 对数据进行反序列化，并将反序列化所得的数据添加到数据库中；当前实例就像目标实例的客户端那样，只要看到 RESTORE 命令返回 OK ，它就会调用 DEL 删除自己数据库上的 key 。

timeout 参数以毫秒为格式，指定当前实例和目标实例进行沟通的最大间隔时间。这说明操作并不一定要在 timeout 毫秒内完成，只是说数据传送的时间不能超过这个 timeout 数。

MIGRATE 命令需要在给定的时间规定内完成 IO 操作。如果在传送数据时发生 IO 错误，或者达到了超时时间，那么命令会停止执行，并返回一个特殊的错误： IOERR 。

当 IOERR 出现时，有以下两种可能：

  key 可能存在于两个实例
  key 可能只存在于当前实例
  唯一不可能发生的情况就是丢失 key ，因此，如果一个客户端执行 MIGRATE 命令，并且不幸遇上 IOERR 错误，那么这个客户端唯一要做的就是检查自己数据库上的 key 是否已经被正确地删除。

如果有其他错误发生，那么 MIGRATE 保证 key 只会出现在当前实例中。（当然，目标实例的给定数据库上可能有和 key 同名的键，不过这和 MIGRATE 命令没有关系）。

可选项：

  COPY ：不移除源实例上的 key 。
  REPLACE ：替换目标实例上已存在的 key 。

返回值：
  迁移成功时返回 OK ，否则返回相应的错误。

func (*Redis) Move ¶

func (r *Redis) Move(key string, db int) (bool, error)

Move key db

可用版本：>= 1.0.0
时间复杂度：O(1)

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

如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。

因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。

返回值：
  移动成功返回 1 ，失败则返回 0 。

func (*Redis) Multi ¶

func (r *Redis) Multi() error

Multi ...

标记一个事务块的开始。

事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行。

可用版本：>= 1.2.0
时间复杂度：O(1)。

返回值：
  总是返回 OK 。

func (*Redis) Object ¶

func (r *Redis) Object(key string) *Object

Object subcommand [arguments [arguments]]

可用版本： >= 2.2.3
时间复杂度： O(1)

OBJECT 命令允许从内部察看给定 key 的 Redis 对象。

它通常用在除错(debugging)或者了解为了节省空间而对 key 使用特殊编码的情况。
当将Redis用作缓存程序时，你也可以通过 OBJECT 命令中的信息，决定 key 的驱逐策略(eviction policies)。
OBJECT 命令有多个子命令：

  * OBJECT REFCOUNT <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。
  *  OBJECT ENCODING <key> 返回给定 key 锁储存的值所使用的内部表示(representation)。
  * OBJECT IDLETIME <key> 返回给定 key 自储存以来的空闲时间(idle， 没有被读取也没有被写入)，以秒为单位。

对象可以以多种方式编码：

  * 字符串可以被编码为 raw (一般字符串)或 int (为了节约内存，Redis 会将字符串表示的 64 位有符号整数编码为整数来进行储存）。
 *   列表可以被编码为 ziplist 或 linkedlist 。 ziplist 是为节约大小较小的列表空间而作的特殊表示。
 *   集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。
 *   哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。
 *  有序集合可以被编码为 ziplist 或者 skiplist 格式。 ziplist 用于表示小的有序集合，而 skiplist 则用于表示任何大小的有序集合。

假如你做了什么让 Redis 没办法再使用节省空间的编码时(比如将一个只有 1 个元素的集合扩展为一个有 100 万个元素的集合)，特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。

返回值：
  REFCOUNT 和 IDLETIME 返回数字。
  ENCODING 返回相应的编码类型。

func (*Redis) PFAdd ¶

func (r *Redis) PFAdd(key string, elements ...string) (bool, error)

PFAdd key element [element ...]

将任意数量的元素添加到指定的 HyperLogLog 里面。

作为这个命令的副作用， HyperLogLog 内部可能会被更新， 以便反映一个不同的唯一元素估计数量（也即是集合的基数）。

如果 HyperLogLog 估计的近似基数（approximated cardinality）在命令执行之后出现了变化， 那么命令返回 1 ， 否则返回 0 。 如果命令执行时给定的键不存在， 那么程序将先创建一个空的 HyperLogLog 结构， 然后再执行命令。

调用 PFADD 命令时可以只给定键名而不给定元素：

  如果给定键已经是一个 HyperLogLog ， 那么这种调用不会产生任何效果；
  但如果给定的键不存在， 那么命令会创建一个空的 HyperLogLog ， 并向客户端返回 1 。

要了解更多关于 HyperLogLog 数据结构的介绍知识， 请查阅 PFCOUNT 命令的文档。

可用版本：>= 2.8.9
时间复杂度：每添加一个元素的复杂度为 O(1) 。

返回值：
  整数回复： 如果 HyperLogLog 的内部储存被修改了， 那么返回 1 ， 否则返回 0 。

func (*Redis) PFCount ¶

func (r *Redis) PFCount(key string, keys ...string) (int, error)

PFCount key [key ...]

当 PFCOUNT 命令作用于单个键时， 返回储存在给定键的 HyperLogLog 的近似基数， 如果键不存在， 那么返回 0 。

当 PFCOUNT 命令作用于多个键时， 返回所有给定 HyperLogLog 的并集的近似基数， 这个近似基数是通过将所有给定 HyperLogLog 合并至一个临时 HyperLogLog 来计算得出的。

通过 HyperLogLog 数据结构， 用户可以使用少量固定大小的内存， 来储存集合中的唯一元素 （每个 HyperLogLog 只需使用 12k 字节内存，以及几个字节的内存来储存键本身）。

命令返回的可见集合（observed set）基数并不是精确值， 而是一个带有 0.81% 标准错误（standard error）的近似值。

举个例子， 为了记录一天会执行多少次各不相同的搜索查询， 一个程序可以在每次执行搜索查询时调用一次 PFADD ， 并通过调用 PFCOUNT 命令来获取这个记录的近似结果。

可用版本：>= 2.8.9
时间复杂度：当命令作用于单个 HyperLogLog 时， 复杂度为 O(1) ， 并且具有非常低的平均常数时间。 当命令作用于 N 个 HyperLogLog 时， 复杂度为 O(N) ， 常数时间也比处理单个 HyperLogLog 时要大得多。

返回值：
  整数回复： 给定 HyperLogLog 包含的唯一元素的近似数量。

func (*Redis) PFMerge ¶

func (r *Redis) PFMerge(destkey, sourcekey string, sourcekeys ...string) error

PFMerge destkey sourcekey [sourcekey ...]

将多个 HyperLogLog 合并（merge）为一个 HyperLogLog ， 合并后的 HyperLogLog 的基数接近于所有输入 HyperLogLog 的可见集合（observed set）的并集。

合并得出的 HyperLogLog 会被储存在 destkey 键里面， 如果该键并不存在， 那么命令在执行之前， 会先为该键创建一个空的 HyperLogLog 。

可用版本：>= 2.8.9
时间复杂度：O(N) ， 其中 N 为被合并的 HyperLogLog 数量， 不过这个命令的常数复杂度比较高。

返回值：
  字符串回复：返回 OK 。

func (*Redis) PSubscribe ¶

func (r *Redis) PSubscribe(pattern string, patterns ...string) (chan PSubscribe, error)

PSubscribe pattern [pattern ...]

订阅一个或多个符合给定模式的频道。

每个模式以 * 作为匹配符，比如 it* 匹配所有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类。

可用版本：>= 2.0.0
时间复杂度：O(N)， N 是订阅的模式的数量。

返回值：
  接收到的信息(请参见下面的代码说明)。

func (*Redis) PUnSubscribe ¶

func (r *Redis) PUnSubscribe(patterns ...string)

PUnSubscribe [pattern [pattern ...]]

指示客户端退订所有给定模式。

如果没有模式被指定，也即是，一个无参数的 PUNSUBSCRIBE 调用被执行，那么客户端使用 PSUBSCRIBE 命令订阅的所有模式都会被退订。在这种情况下，命令会返回一个信息，告知客户端所有被退订的模式。

可用版本：>= 2.0.0
时间复杂度：O(N+M) ，其中 N 是客户端已订阅的模式的数量， M 则是系统中所有客户端订阅的模式的数量。

返回值：
  这个命令在不同的客户端中有不同的表现。

func (*Redis) Persist ¶

func (r *Redis) Persist(key string) (bool, error)

Persist key

可用版本： >= 2.2.0
时间复杂度： O(1)

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

返回值：
  当生存时间移除成功时，返回 1 .
  如果 key 不存在或 key 没有设置生存时间，返回 0 。

func (*Redis) Ping ¶

func (r *Redis) Ping() (NullString, error)

Ping ...

可用版本：>= 1.0.0
时间复杂度：O(1)

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

通常用于测试与服务器的连接是否仍然生效，或者用于测量延迟值。

返回值：
  如果连接正常就返回一个 PONG ，否则返回一个连接错误。

func (*Redis) Publish ¶

func (r *Redis) Publish(channel, message string) (int, error)

Publish channel message

将信息 message 发送到指定的频道 channel 。

可用版本：>= 2.0.0
时间复杂度：O(N+M)，其中 N 是频道 channel 的订阅者数量，而 M 则是使用模式订阅(subscribed patterns)的客户端的数量。

返回值：
  接收到信息 message 的订阅者数量。

func (*Redis) Pubsub ¶

func (r *Redis) Pubsub() *PubSub

Pubsub <subcommand> [argument [argument ...]]

func (*Redis) Quit ¶

func (r *Redis) Quit() error

Quit ...

可用版本： >= 1.0.0
时间复杂度： O(1)

请求服务器关闭与当前客户端的连接。

一旦所有等待中的回复(如果有的话)顺利写入到客户端，连接就会被关闭。

返回值：
  总是返回 OK (但是不会被打印显示，因为当时 Redis-cli 已经退出)。

func (*Redis) RPop ¶

func (r *Redis) RPop(key string) (NullString, error)

RPop key

可用版本： >= 1.0.0
时间复杂度： O(1)

移除并返回列表 key 的尾元素。

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

func (*Redis) RPopLPush ¶

func (r *Redis) RPopLPush(source, destination string) (NullString, error)

RPopLPush source destination

可用版本： >= 1.2.0
时间复杂度： O(1)

命令 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)操作。

返回值：
  被弹出的元素。

func (*Redis) RPush ¶

func (r *Redis) RPush(key, value string, values ...string) (int, error)

RPush key value [value ...]

可用版本： >= 1.0.0
时间复杂度： O(1)

将一个或多个值 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 存在但不是列表类型时，返回一个错误。

在 Redis 2.4 版本以前的 RPUSH 命令，都只接受单个 value 值。
返回值：
  执行 RPUSH 操作后，表的长度。

func (*Redis) RPushX ¶

func (r *Redis) RPushX(key, value string) (int, error)

RPushX key value

可用版本： >= 2.2.0
时间复杂度： O(1)

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

和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

返回值：
  RPUSHX 命令执行之后，表的长度。

func (*Redis) RandomKey ¶

func (r *Redis) RandomKey() (NullString, error)

RandomKey ...

可用版本：>= 1.0.0
时间复杂度： O(1)

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

返回值：
  当数据库不为空时，返回一个 key 。
  当数据库为空时，返回 nil 。

func (*Redis) Rename ¶

func (r *Redis) Rename(key, newkey string) error

Rename key newkey

可用版本： >= 1.0.0
时间复杂度： O(1)

将 key 改名为 newkey 。

当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。

当 newkey 已经存在时， RENAME 命令将覆盖旧值。

返回值：
  改名成功时提示 OK ，失败时候返回一个错误。

func (*Redis) RenameNX ¶

func (r *Redis) RenameNX(key, newkey string) (bool, error)

RenameNX key newkey

可用版本： >= 1.0.0
时间复杂度： O(1)

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

当 key 不存在时，返回一个错误。

返回值：
  修改成功时，返回 1 。
  如果 newkey 已经存在，返回 0 。

func (*Redis) Restore ¶

func (r *Redis) Restore(key string, ttl time.Duration, serializedValue string, Replace bool) error

Restore key ttl serialized-value [REPLACE]

可用版本： >= 2.6.0
时间复杂度：
  查找给定键的复杂度为 O(1) ，对键进行反序列化的复杂度为 O(N*M) ，其中 N 是构成 key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。
  有序集合(sorted set)的反序列化复杂度为 O(N*M*log(N)) ，因为有序集合每次插入的复杂度为 O(log(N)) 。
  如果反序列化的对象是比较小的字符串，那么复杂度为 O(1) 。

反序列化给定的序列化值，并将它和给定的 key 关联。

参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。

RESTORE 在执行反序列化之前会先对序列化值的 RDB 版本和数据校验和进行检查，如果 RDB 版本不相同或者数据不完整的话，那么 RESTORE 会拒绝进行反序列化，并返回一个错误。

如果键 key 已经存在， 并且给定了 REPLACE 选项， 那么使用反序列化得出的值来代替键 key 原有的值； 相反地， 如果键 key 已经存在， 但是没有给定 REPLACE 选项， 那么命令返回一个错误。

返回值：
  如果反序列化成功那么返回 OK ，否则返回一个错误。

func (*Redis) SAdd ¶

func (r *Redis) SAdd(key, member string, members ...string) (int, error)

SAdd key member [member ...]

可用版本： >= 1.0.0
时间复杂度: O(N)， N 是被添加的元素的数量。

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。

假如 key 不存在，则创建一个只包含 member 元素作成员的集合。

当 key 不是集合类型时，返回一个错误。

在Redis2.4版本以前， SADD 只接受单个 member 值。
返回值:
  被添加到集合中的新元素的数量，不包括被忽略的元素。

func (*Redis) SCard ¶

func (r *Redis) SCard(key string) (int, error)

SCard key

返回集合 key 的基数(集合中元素的数量)。

可用版本： >= 1.0.0
时间复杂度: O(1)

返回值：
  集合的基数。
  当 key 不存在时，返回 0 。

func (*Redis) SDiff ¶

func (r *Redis) SDiff(key string, keys ...string) ([]string, error)

SDiff key [key ...]

返回一个集合的全部成员，该集合是所有给定集合之间的差集。

不存在的 key 被视为空集。

可用版本：>= 1.0.0
时间复杂度:O(N)， N 是所有给定集合的成员数量之和。

返回值:
  一个包含差集成员的列表。

func (*Redis) SDiffStore ¶

func (r *Redis) SDiffStore(destination, key string, keys ...string) (int, error)

SDiffStore destination key [key ...]

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

如果 destination 集合已经存在，则将其覆盖。

destination 可以是 key 本身。

可用版本：>= 1.0.0
时间复杂度:O(N)， N 是所有给定集合的成员数量之和。

返回值:
  结果集中的元素数量。

func (*Redis) SInter ¶

func (r *Redis) SInter(key string, keys ...string) ([]string, error)

SInter key [key ...]

返回一个集合的全部成员，该集合是所有给定集合的交集。

不存在的 key 被视为空集。

当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

可用版本：>= 1.0.0
时间复杂度:O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。
返回值:
  交集成员的列表。

func (*Redis) SInterStore ¶

func (r *Redis) SInterStore(destination, key string, keys ...string) (int, error)

SInterStore destination key [key ...]

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

如果 destination 集合已经存在，则将其覆盖。

destination 可以是 key 本身。

可用版本：>= 1.0.0
时间复杂度:O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。

返回值:
  结果集中的成员数量。

func (*Redis) SIsMember ¶

func (r *Redis) SIsMember(key, member string) (bool, error)

SIsMember key member

判断 member 元素是否集合 key 的成员。

可用版本：>= 1.0.0
时间复杂度:O(1)

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

func (*Redis) SMembers ¶

func (r *Redis) SMembers(key string) ([]string, error)

SMembers key

可用版本： >= 1.0.0
时间复杂度: O(N)， N 为集合的基数。

返回集合 key 中的所有成员。

不存在的 key 被视为空集合。

返回值:
  集合中的所有成员。

func (*Redis) SMove ¶

func (r *Redis) SMove(source, destination, member string) (bool, error)

SMove source destination member

将 member 元素从 source 集合移动到 destination 集合。

SMOVE 是原子性操作。

如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。

当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

当 source 或 destination 不是集合类型时，返回一个错误。

可用版本：>= 1.0.0
时间复杂度:O(1)

返回值:
如果 member 元素被成功移除，返回 1 。
如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

func (*Redis) SPop ¶

func (r *Redis) SPop(key string) (NullString, error)

SPop key

移除并返回集合中的一个随机元素。

如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。

可用版本：>= 1.0.0
时间复杂度:O(1)

返回值:
  被移除的随机元素。
  当 key 不存在或 key 是空集时，返回 nil 。

func (*Redis) SRandMember ¶

func (r *Redis) SRandMember(key string, count ...int) ([]string, error)

SRandMember key [count]

如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。

从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数：

  如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
  如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

可用版本：>= 1.0.0
时间复杂度:
  只提供 key 参数时为 O(1) 。
  如果提供了 count 参数，那么为 O(N) ，N 为返回数组的元素个数。

返回值:
  只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。
  如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组。

func (*Redis) SRem ¶

func (r *Redis) SRem(key, member string, members ...string) (int, error)

SRem key member [member ...]

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。

当 key 不是集合类型，返回一个错误。

在 Redis 2.4 版本以前， SREM 只接受单个 member 值。

可用版本：>= 1.0.0
时间复杂度:O(N)， N 为给定 member 元素的数量。

返回值:
  被成功移除的元素的数量，不包括被忽略的元素。

func (*Redis) SScan ¶

func (r *Redis) SScan(key string, options ...ScanOption) *SScan

SScan key cursor [MATCH pattern] [COUNT count]

详细信息请参考 SCAN 命令。

func (*Redis) SUnion ¶

func (r *Redis) SUnion(key string, keys ...string) ([]string, error)

SUnion key [key ...]

返回一个集合的全部成员，该集合是所有给定集合的并集。

不存在的 key 被视为空集。

可用版本：>= 1.0.0
时间复杂度:O(N)， N 是所有给定集合的成员数量之和。

返回值:
  并集成员的列表。

func (*Redis) SUnionStore ¶

func (r *Redis) SUnionStore(destination, key string, keys ...string) (int, error)

SUnionStore destination key [key ...]

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

如果 destination 已经存在，则将其覆盖。

destination 可以是 key 本身。

可用版本：>= 1.0.0
时间复杂度:O(N)， N 是所有给定集合的成员数量之和。

返回值:
  结果集中的元素数量。

func (*Redis) Scan ¶

func (r *Redis) Scan(options ...ScanOption) *Scan

Scan cursor [MATCH pattern] [COUNT count]

SCAN 命令及其相关的 SSCAN 命令、 HSCAN 命令和 ZSCAN 命令都用于增量地迭代（incrementally iterate）一集元素（a collection of elements）：

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

以上列出的四个命令都支持增量式迭代， 它们每次执行都只会返回少量元素， 所以这些命令可以用于生产环境， 而不会出现像 KEYS 命令、 SMEMBERS 命令带来的问题 —— 当 KEYS 命令被用于处理一个大的数据库时， 又或者 SMEMBERS 命令被用于处理一个大的集合键时， 它们可能会阻塞服务器达数秒之久。

不过， 增量式迭代命令也不是没有缺点的： 举个例子， 使用 SMEMBERS 命令可以返回集合键当前包含的所有元素， 但是对于 SCAN 这类增量式迭代命令来说， 因为在对键进行增量式迭代的过程中， 键可能会被修改， 所以增量式迭代命令只能对被返回的元素提供有限的保证 （offer limited guarantees about the returned elements）。

因为 SCAN 、 SSCAN 、 HSCAN 和 ZSCAN 四个命令的工作方式都非常相似， 所以这个文档会一并介绍这四个命令， 但是要记住：

  SSCAN 命令、 HSCAN 命令和 ZSCAN 命令的第一个参数总是一个数据库键。
  而 SCAN 命令则不需要在第一个参数提供任何数据库键 —— 因为它迭代的是当前数据库中的所有数据库键。

func (*Redis) Select ¶

func (r *Redis) Select(index int) error

Select index

可用版本： >= 1.0.0
时间复杂度： O(1)

切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。

默认使用 0 号数据库。

返回值：
  OK

func (*Redis) Set ¶

func (r *Redis) Set(key, value string, options ...SetOption) (bool, error)

Set key value [expiration EX seconds|PX milliseconds] [NX|XX]

可用版本： >= 1.0.0
时间复杂度： O(1)

将字符串值 value 关联到 key 。
如果 key 已经持有其他值， SET 就覆写旧值，无视类型。

对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。

可选参数

  从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改：

  EX second ：设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value 。
  PX millisecond ：设置键的过期时间为 millisecond 毫秒。 SET key value PX millisecond 效果等同于 PSETEX key millisecond value 。
  NX ：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。
  XX ：只在键已经存在时，才对键进行设置操作。

返回值：

  在 Redis 2.6.12 版本以前， SET 命令总是返回 OK 。
  从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，才返回 OK 。
  如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）。

func (*Redis) SetBit ¶

func (r *Redis) SetBit(key string, offset int, SetOrRemove bool) (int, error)

SetBit key offset value

可用版本： >= 2.2.0
时间复杂度: O(1)

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

对使用大的 offset 的 SETBIT 操作来说，内存分配可能造成 Redis 服务器被阻塞。具体参考 SETRANGE 命令，warning(警告)部分。

返回值：
  指定偏移量原来储存的位。

func (*Redis) SetRange ¶

func (r *Redis) SetRange(key string, offset int, value string) (int, error)

SetRange key offset value

可用版本： >= 2.2.0
时间复杂度： 对小(small)的字符串，平摊复杂度O(1)。(关于什么字符串是”小”的，请参考 APPEND 命令)

用 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 操作，无须再重新内存。
否则为O(M)， M 为 value 参数的长度。

返回值：
  被 SETRANGE 修改之后，字符串的长度。

func (*Redis) Sort ¶

func (r *Redis) Sort() error

Sort key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

返回或保存给定列表、集合、有序集合 key 中经过排序的元素。

排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。

func (*Redis) StrLen ¶

func (r *Redis) StrLen(key string) (int, error)

StrLen key

可用版本： >= 2.2.0
复杂度： O(1)

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

返回值：
  字符串值的长度。
  当 key 不存在时，返回 0 。

func (*Redis) Subscribe ¶

func (r *Redis) Subscribe(channel string, channels ...string) (chan Subscribe, error)

Subscribe channel [channel ...]

订阅给定的一个或多个频道的信息。

可用版本：>= 2.0.0
时间复杂度：O(N)，其中 N 是订阅的频道的数量。

返回值：
  接收到的信息(请参见下面的代码说明)。

func (*Redis) TTL ¶

func (r *Redis) TTL(key string) (*time.Duration, error)

TTL key

可用版本：>= 1.0.0
时间复杂度：O(1)

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

返回值：
  当 key 不存在时，返回 -2 。
  当 key 存在但没有设置剩余生存时间时，返回 -1 。
  否则，以秒为单位，返回 key 的剩余生存时间。

注意：这里没有实现TTL命令

func (*Redis) Type ¶

func (r *Redis) Type(key string) (KeyType, error)

Type key

可用版本： >= 1.0.0
时间复杂度： O(1)

返回 key 所储存的值的类型。

返回值：
  none (key不存在)
  string (字符串)
  list (列表)
  set (集合)
  zset (有序集)
  hash (哈希表)

func (*Redis) UnSubscribe ¶

func (r *Redis) UnSubscribe(channels ...string) (int, error)

UnSubscribe [channel [channel ...]]

指示客户端退订给定的频道。

如果没有频道被指定，也即是，一个无参数的 UNSUBSCRIBE 调用被执行，那么客户端使用 SUBSCRIBE 命令订阅的所有频道都会被退订。在这种情况下，命令会返回一个信息，告知客户端所有被退订的频道。

可用版本：>= 2.0.0
时间复杂度：O(N) ， N 是客户端已订阅的频道的数量。

返回值：
  这个命令在不同的客户端中有不同的表现。

func (*Redis) UnWatch ¶

func (r *Redis) UnWatch() error

UnWatch ...

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

如果在执行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行 UNWATCH 了。

因为 EXEC 命令会执行事务，因此 WATCH 命令的效果已经产生了；而 DISCARD 命令在取消事务的同时也会取消所有对 key 的监视，因此这两个命令执行之后，就没有必要执行 UNWATCH 了。

可用版本：>= 2.2.0
时间复杂度：O(1)

返回值：
  总是 OK 。

func (*Redis) Watch ¶

func (r *Redis) Watch(key string, keys ...string) error

Watch key [key ...]

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

可用版本：>= 2.2.0
时间复杂度：O(1)。

返回值：
  总是返回 OK 。

func (*Redis) ZAdd ¶

func (r *Redis) ZAdd(key string, score float64, member string, sm ...interface{}) (int, error)

ZAdd key score member [[score member] [score member] ...]

可用版本：>= 1.2.0
时间复杂度:O(M*log(N))， N 是有序集的基数， M 为成功添加的新成员的数量。

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。

score 值可以是整数值或双精度浮点数。

如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。

当 key 存在但不是有序集类型时，返回一个错误。

对有序集的更多介绍请参见 sorted set 。

在 Redis 2.4 版本以前， ZADD 每次只能添加一个元素。

返回值:
  被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

func (*Redis) ZCard ¶

func (r *Redis) ZCard(key string) (int, error)

ZCard key

返回有序集 key 的基数。

可用版本：>= 1.2.0
时间复杂度:O(1)

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

func (*Redis) ZCount ¶

func (r *Redis) ZCount(key string, min, max int) (int, error)

ZCount key min max

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

关于参数 min 和 max 的详细使用方法，请参考 ZRANGEBYSCORE 命令。

可用版本：>= 2.0.0
时间复杂度:O(log(N))， N 为有序集的基数。

返回值:
  score 值在 min 和 max 之间的成员的数量。

func (*Redis) ZIncrBy ¶

func (r *Redis) ZIncrBy(key string, increment float64, member string) (float64, 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 值可以是整数值或双精度浮点数。

可用版本：>= 1.2.0
时间复杂度:O(log(N))

返回值:
  member 成员的新 score 值，以字符串形式表示。

func (*Redis) ZInterStore ¶

func (r *Redis) ZInterStore()

ZInterStore ...

func (*Redis) ZLexCount ¶

func (r *Redis) ZLexCount(key, min, max string) (int, error)

ZLexCount key min max

对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX 命令的 min 参数和 max 参数的意义一样。

可用版本：>= 2.8.9
时间复杂度：O(log(N))，其中 N 为有序集合包含的元素数量。

返回值：
  整数回复：指定范围内的元素数量。

func (*Redis) ZRange ¶

func (r *Redis) ZRange(key string, start, stop int, WithScore bool) ([]*SortedSet, 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 的格式表示。
客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

可用版本：>= 1.2.0
时间复杂度:O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

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

func (*Redis) ZRangeByLex ¶

func (r *Redis) ZRangeByLex(key, min, max string, options ...LimitOption) ([]string, error)

ZRangeByLex key min max [LIMIT offset count]

当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。

如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。

命令会使用 C 语言的 memcmp() 函数， 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。

可选的 LIMIT offset count 参数用于获取指定范围内的匹配元素 （就像 SQL 中的 SELECT LIMIT offset count 语句）。 需要注意的一点是， 如果 offset 参数的值非常大的话， 那么命令在返回结果之前， 需要先遍历至 offset 所指定的位置， 这个操作会为命令加上最多 O(N) 复杂度。

如何指定范围区间
  合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。

  特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素。

可用版本：>= 2.8.9
时间复杂度：O(log(N)+M)， 其中 N 为有序集合的元素数量， 而 M 则是命令返回的元素数量。 如果 M 是一个常数（比如说，用户总是使用 LIMIT 参数来返回最先的 10 个元素）， 那么命令的复杂度也可以看作是 O(log(N)) 。

返回值：
  数组回复：一个列表，列表里面包含了有序集合在指定范围内的成员。

lexicographical ordering

func (*Redis) ZRangeByScore ¶

func (r *Redis) ZRangeByScore(key, min, max string, WithScore bool, options ...LimitOption) ([]*SortedSet, error)

ZRangeByScore key min max [WITHSCORES] [LIMIT offset count]

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。

可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。

可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。
该选项自 Redis 2.0 版本起可用。
区间及无限

min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。

默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

举个例子：

ZRANGEBYSCORE zset (1 5
返回所有符合条件 1 < score <= 5 的成员，而

ZRANGEBYSCORE zset (5 (10
则返回所有符合条件 5 < score < 10 的成员。

可用版本：>= 1.0.5
时间复杂度:O(log(N)+M)， N 为有序集的基数， M 为被结果集的基数。

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

func (*Redis) ZRank ¶

func (r *Redis) ZRank(key, member string) (int, error)

ZRank key member

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

排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

使用 ZREVRANK 命令可以获得成员按 score 值递减(从大到小)排列的排名。

可用版本：>= 2.0.0
时间复杂度:O(log(N))

返回值:
  如果 member 是有序集 key 的成员，返回 member 的排名。
  如果 member 不是有序集 key 的成员，返回 nil 。

func (*Redis) ZRem ¶

func (r *Redis) ZRem(key, member string, members ...string) (int, error)

ZRem key member [member ...]

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。

当 key 存在但不是有序集类型时，返回一个错误。

在 Redis 2.4 版本以前， ZREM 每次只能删除一个元素。
可用版本：>= 1.2.0
时间复杂度:O(M*log(N))， N 为有序集的基数， M 为被成功移除的成员的数量。

返回值:
  被成功移除的成员的数量，不包括被忽略的成员。

func (*Redis) ZRemRangeByLex ¶

func (r *Redis) ZRemRangeByLex(key, min, max string) (int, error)

ZRemRangeByLex key min max

对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX 命令的 min 参数和 max 参数的意义一样。

可用版本：>= 2.8.9
时间复杂度：O(log(N)+M)， 其中 N 为有序集合的元素数量， 而 M 则为被移除的元素数量。

返回值：
  整数回复：被移除的元素数量。

func (*Redis) ZRemRangeByRank ¶

func (r *Redis) 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 表示倒数第二个成员，以此类推。

可用版本：>= 2.0.0
时间复杂度:O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

返回值:
  被移除成员的数量。

func (*Redis) ZRemRangeByScore ¶

func (r *Redis) ZRemRangeByScore(key, min, max string) (int, error)

ZRemRangeByScore key min max

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。

自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE 命令。

可用版本：>= 1.2.0
时间复杂度:O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

返回值:
  被移除成员的数量。

func (*Redis) ZRevRange ¶

func (r *Redis) ZRevRange(key string, start, stop int, WithScore bool) ([]*SortedSet, error)

ZRevRange key start stop [WITHSCORES]

可用版本：>= 1.2.0
时间复杂度:O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

返回有序集 key 中，指定区间内的成员。

其中成员的位置按 score 值递减(从大到小)来排列。
具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

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

func (*Redis) ZRevRangeByScore ¶

func (r *Redis) ZRevRangeByScore(key, max, min string, WithScore bool, options ...LimitOption) ([]*SortedSet, error)

ZRevRangeByScore key max min [WITHSCORES] [LIMIT offset count]

返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。

具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。

除了成员按 score 值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

可用版本：>= 2.2.0
时间复杂度:O(log(N)+M)， N 为有序集的基数， M 为结果集的基数。

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

func (*Redis) ZRevRank ¶

func (r *Redis) ZRevRank(key, member string) (int, error)

ZRevRank key member

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

排名以 0 为底，也就是说， score 值最大的成员排名为 0 。

使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。

可用版本：>= 2.0.0
时间复杂度:O(log(N))

返回值:
  如果 member 是有序集 key 的成员，返回 member 的排名。
  如果 member 不是有序集 key 的成员，返回 nil 。

func (*Redis) ZScan ¶

func (r *Redis) ZScan(key string, options ...ScanOption) *ZScan

ZScan ...

func (*Redis) ZScore ¶

func (r *Redis) ZScore(key, member string) (float64, error)

ZScore key member

返回有序集 key 中，成员 member 的 score 值。

如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

可用版本：>= 1.2.0
时间复杂度:O(1)

返回值:
  member 成员的 score 值，以字符串形式表示。

func (*Redis) ZUnionStore ¶

func (r *Redis) ZUnionStore()

ZUnionStore destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

WEIGHTS

使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。

如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。

AGGREGATE

使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。

默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。

可用版本：>= 2.0.0
时间复杂度:O(N)+O(M log(M))， N 为给定有序集基数的总和， M 为结果集的基数。

返回值:
  保存到 destination 的结果集的基数。

func (*Reply) String ¶

func (p *Reply) String() string

String just for test

func (*SScan) ALL ¶

func (r *SScan) ALL() ([]string, error)

ALL ...

func (*SScan) Each ¶

func (r *SScan) Each(f func(k int, v string) error) error

Each ...

func (*SScan) Next ¶

func (r *SScan) Next() ([]string, error)

Next ...

func (*Scan) ALL ¶

func (r *Scan) ALL() ([]string, error)

ALL ...

func (*Scan) Each ¶

func (r *Scan) Each(f func(k int, v string) error) error

Each ...

func (*Scan) Next ¶

func (r *Scan) Next() ([]string, error)

Next ...

func (*ZScan) ALL ¶

func (r *ZScan) ALL() ([]*SortedSet, error)

ALL ...

func (*ZScan) Each ¶

func (r *ZScan) Each(f func(k int, v *SortedSet) error) error

Each ...

func (*ZScan) Next ¶

func (r *ZScan) Next() ([]*SortedSet, error)

Next ...