俊瑶先森

背景

最近在做一套RBAC的权限管理系统，当在设计部门及查询的时候，需要维护一个部门结构。结构包含 部门id,上级部门pid,当查询一个部门的所有子级部门时候，需要根据pid进行递归查询，层级越多，查询次数越多。那么怎么通过一个简单的数据库设计，满足查询某个部门的所有子级部门。

技巧

对于上图的部门层级结构，给出对应的数据库设计

原理：
添加一个辅助的varchar字段pids,字段的逻辑是多个部门的id使用,来连接，假设首层使用0表示，每一个层级使用上一层的pids拼接上,再拼接上级部门id来表示，我们也可以通俗的理解为这个是部门层级pids为该部门的所有上级路径

举例：
技术部(id:1)的上级部门是长沙分公司(id:2),
长沙分公司的上级是集团(id:5)，
所以技术部的pids为:0,5,2,
长沙分公司的pids为:0,5

因此要查询长沙分公司的子部门，只需要用 0,5,2%去查询即可，即找到当前部门记录的pids(0,5), 拼上,再拼上当前部门ID(2)，再拼个%做后缀模糊匹配

1

pids like {pids},{id}%

命令创建项目结构

module、controller、service创建

--no-spec不创建测试用例

1
2
3

nest g mo user
nest g controller user
nest g service user --no-spec

typeorm-model-generator

数据库表自动生成实体类

在package.json的scripts配置数据库生成实体类命令：

1

"db": "rm -rf src/entities & npx typeorm-model-generator -h localhost -d race -p 3306 -u root -x hong -e mysql -o src/entities --noConfig --relationIds --lazy --ce none --cp none"

npx typeorm-model-generator –help 查看帮助

1
2
3
4
5
6
7
8
9
10
11
12
13
14

-h dbhost
-d dbname
-p port
-u username
-x password
-e dbtype

-a 生成实体类 extends BaseEntity 可使用基础的CURD
-o 默认输出项目根目录下 output 文件夹下 可以自定义输出目标目录，例：-o ./src/demo/entities
--cf，将文件名转换为指定的大小写 [可选值："pascal"，"camel"，"none"] [默认值 none"] 
--ce pascal 生成实体类名采用人名式格式 [可选值："pascal"，"camel"，"none"] [默认值 none"] 
--cp camel 生成实体类属性采用驼峰 [可选值："pascal"，"camel"，"none"] [默认值 none”] 
--noConfig 不产生相关配置文件

使用方法：
1、将数据库所有表转成实体类

1

npm run db

2.单独将数据库的sys_user表生成实体类

1

npm run db -- --tables sys_user,sys_role

装饰器

Modules

请求生命周期

顺序：

• 中间件
• 卫兵
• 拦截器（在操纵流之前）
• 管道
• 服务端路由函数
• 拦截器（在操纵流之后）
• 异常过滤器（如果捕获到任何异常）

中间件

请求生命周期的第一个流程是经过中间件，我们来实现一个日志中间件

如何实现

中间件必须实现NestMiddleware

./common/middleware/logger.middleware.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    const logFormat = `  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      Request original url: ${req.originalUrl}
      Method: ${req.method}
      IP: ${req.ip}
      Status code: ${res.statusCode}
      Parmas: ${JSON.stringify(req.params)}
      Query: ${JSON.stringify(req.query)}
      Body: ${JSON.stringify(req.body)} \n  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
    `
    console.log(logFormat);
    next();
  }
}

如何注册中间件

• 全局中间件
  在main.ts中进行全局注册

1
2

import { LoggerMiddleware } from './common/middleware/logger.middleware'
app.use(new LoggerMiddleware().use)

• 应用中间件、中间件消费者等
  可针对controller、routes进行单独注册

消费模式

独占订阅(流)：

顾名思义，在任何给定时间内，订阅（消费者组）中只有一个消费者消费主题分区。 下面的图1说明了独占订阅的示例。 有一个有订阅A的活动消费者A-0消息m0到m4按顺序传送并由A-0消费。 如果另一个消费者A-1想要附加到订阅A，则不允许这样做。

独占订阅

故障转移订阅(Failover sub streaming):使用故障转移订阅，多个使用者可以附加到同一订阅。 但是，对于给定的主题分区，将选择一个使用者作为该主题分区的主使用者，其他消费者将被指定为故障转移消费者，当主消费者断开连接时，分区将被重新分配给其中一个故障转移消费者，而新分配的消费者将成为新的主消费者。 发生这种情况时，所有未确认的消息都将传递给新的主消费者，这类似于Apache Kafka中的使用者分区重新平衡。 图2显示了故障转移订阅，消费者B-0和B-1通过订阅B订阅消费消息.B-0是主消费者并接收所有消息，B-1是故障转移消费者，如果消费者B-0出现故障，将接管消费。

故障转移订阅

共享订阅(队列)：使用共享订阅，可以将所需数量的消费者附加到同一订阅。消息以多个消费者的循环尝试分发形式传递，并且任何给定的消息仅传递给一个消费者。当消费者断开连接时，所有传递给它并且未被确认的消息将被重新安排，以便发送给该订阅上剩余的剩余消费者。图3说明了共享订阅。消费者C-1，C-2和C-3都在同一主题分区上消费消息。每个消费者接收大约1/3的消息。如果您想提高消费率，您可以在不增加分区数量的情况下为更多的消费者提供相同的订阅（尽可能多的消费者）。

共享订阅

独占和故障转移订阅仅允许每个订阅每个主题分区仅有一个消费者。它们按分区顺序使用消息。它们最适用于需要严格排序的流用例。另一方面，共享订阅允许每个主题分区有多个消费者，同一订阅中的每个消费者仅接收发布到主题分区的一部分消息。共享订阅最适用于不需要排序的并且可以扩展超出分区数量的使用者数量的队列用例。

Pulsar中的subscription(订阅)实际上与Apache Kafka中的消费者群体相同。创建订阅具有高度可扩展性且非常低廉的。可以根据需要创建任意数量的订阅，对同一主题的不同订阅不必具有相同的订阅类型。这意味着可以在同一主题上有10个消费者的故障转移订阅或有20个消费者的共享订阅。如果共享订阅处理事件的速度很慢，则可以在不更改分区数的情况下向共享订阅添加更多消费者。图4描绘了一个包含3个订阅A，B和C的主题，并说明了消息如何从生产者流向消费者。

除了统一消息传递API之外，由于Pulsar主题分区实际上是存储在Apache BookKeeper中的分布式日志，它还提供了一个读取器(reader) API（类似于消费者(consumer) API但没有游标管理），以便用户完全控制如何使用消息本身。

消息确认(Message Ackmowledgment)

当使用跨机器分布的消息传递系统时，可能会发生故障。在消费者从消息传递系统中的主题消费消息的情况下，消费消息的消费者和服务于主题分区的消息代理都可能失败。当发生这样的故障时，能够从消费者停止的地方恢复消费，这样既不会错过消息，也不必处理已经确认的消息。在Apache Kafka中，恢复点通常称为偏移，更新恢复点的过程称为消息确认或提交偏移。在Apache Pulsar中，游标(cursors)用于跟踪每个订阅(subscription)的消息确认(message acknowledgment)。每当消费者在主题分区上确认消息时，游标都会更新，更新游标可确保消费者不会再次收到消息，但是游标并不像Apache Kafka那样简单。Apache Pulsar有两种方法可以确认消息，个体确认ack或累积确认消息。通过累积确认，消费者只需要确认它收到的最后一条消息，主题分区中的所有消息（包括）提供消息ID将被标记为已确认，并且不会再次传递给消费者，累积确认与Apache Kafka中的偏移更新实际上相同。Apache Pulsar的区别特征是能够个体单独进行ack，也就是选择性acking。消费者可以单体确认消息。Acked消息将不会被重新传递。图5说明了ack个体和ack累积之间的差异（灰色框中的消息被确认并且不会被重新传递）。在图的顶部，它显示了ack累积的一个例子，M12之前的消息被标记为acked。在图的底部，它显示了单独进行acking的示例。仅确认消息M7和M12 - 在消费者失败的情况下，除了M7和M12之外，将重新传送所有消息。

独占(exclusive)或故障转移(failover)订阅的消费者能够单个或累积地发送消息(ack message);而共享订阅中的消费者只允许单独发送消息(ack messages)。单独确认消息的能力为处理消费者故障提供了更好的体验。对于某些应用来说，处理那些已经确认过的消息可能是非常耗时的，防止重新传送已经确认的消息是非常重要。

关于

最近，俊瑶先生一直在研究 Pulsar.

俊瑶先生是一名 忠实的Kafka 的用户，为kafka填过几次文章，如：2018-12-01:kafka消息列队 ，同时也将kafka运用于多个项目实践中，上一个项目为一个招投标的订阅消息推送。俊瑶先生于今年1月份透过涂鸦iot平台关注到了Pulsar，当时很疑惑为什么涂鸦选择了Pulsar，于是开展了长达3个月断断续续调研。期间不乏将外网所有Pulsar的文章都看了一遍，许多pulsar文章都与kafka进行了深入的对比

为什么Pulsar

与Kafka对比

模型概念

• Kafka： Producer - topic - consumer group - consumer
• Pulsar： Producer - topic - subscription - consumer

消费模式

• Kafka： 主要集中在流（Stream）模式，对单个 partition 是独占消费，没有共享（Queue）的消费模式；
• Pulsar：提供了统一的消息模型和 API。流（Stream）模式——独占和故障切换订阅方式；队列（Queue）模式——共享订阅的方式。

消息确认（Ack）

• Kafka： 使用偏移 Offset；
• Pulsar：使用专门的 Cursor 管理。累积确认和 Kafka 效果一样；提供单条或选择性确认。

消息保留

• Kafka：根据设置的保留期来删除消息。有可能消息没被消费，过期后被删除。 不支持 TTL。
• Pulsar：消息只有被所有订阅消费后才会删除，不会丢失数据。也允许设置保留期，保留被消费的数据。支持 TTL。

详细的消费模式和消息确认请参考：pulsar的消费模式

Pulsar的系统架构和设计理念

Pulsar 的分层架构

Broker层（或无状态服务层）架构

架构上 Pulsar 和 Kafka 的对比

Apache Kafka 是以分区为存储中心，而 Apache Pulsar 是以 Segment 为存储中心。如下图：

• 在 Apache Kafka 中，分区只能存储在单个节点上并复制到其他节点，其容量受最小节点容量的限制。这意味着容量扩展需要对分区重新平衡，这反过来又需要重新复制整个分区，以平衡新添加的代理的数据和流量。重新传输数据非常昂贵且容易出错，并且会消耗网络带宽和 I/O。维护人员在执行此操作时必须非常小心，以避免破坏生产系统。
• Kafka 中分区数据的重新拷贝不仅发生在以分区为中心的系统中的群集扩展上。许多其他事情也会触发数据重新拷贝，例如副本故障，磁盘故障或计算机的故障。在数据重新复制期间，分区通常不可用，直到数据重新复制完成。例如，如果您将分区配置为存储为 3 个副本，这时，如果丢失了一个副本，则必须重新复制完整个分区后，分区才可以再次可用。

Pulsar的无缝Broker故障恢复

下图说明了 Pulsar 如何处理 Broker 失败的示例。 在例子中 Broker 2 因某种原因（例如停电）而断开。 Pulsar 检测到 Broker 2 已关闭，并立即将 Topic1-Part2 的所有权从 Broker 2 转移到 Broker 3。在 Pulsar 中数据存储和数据服务分离，所以当代理 3 接管 Topic1-Part2 的所有权时，它不需要复制 Partiton 的数据。 如果有新数据到来，它立即附加并存储为 Topic1-Part2 中的 Segment x + 1。 Segment x + 1 被分发并存储在 Bookie1, 2 和 4 上。因为它不需要重新复制数据，所以所有权转移立即发生而不会牺牲主题分区的可用性。

Pulsar的无缝存储（Bookie）故障恢复

下图说明了 Pulsar（通过 Apache BookKeeper）如何处理 bookie 的磁盘故障。 这里有一个磁盘故障导致存储在 bookie 2 上的 Segment 4 被破坏。Apache BookKeeper 后台会检测到这个错误并进行复制修复。

Apache BookKeeper 中的副本修复是 Segment（甚至是 Entry）级别的多对多快速修复，这比重新复制整个主题分区要精细，只会复制必须的数据。 这意味着 Apache BookKeeper 可以从 bookie 3 和 bookie 4 读取 Segment 4 中的消息，并在 bookie 1 处修复 Segment 4。所有的副本修复都在后台进行，对 Broker 和应用透明。
即使有 Bookie 节点出错的情况发生时，通过添加新的可用的 Bookie 来替换失败的 Bookie，所有 Broker 都可以继续接受写入，而不会牺牲主题分区的可用性。

经过调研及等待时机：终于来了一个场景是非常适合使用pulsar

本篇将记录下pulsar使用过程遇到的问题及过程。

安装篇

首先我需要有一个mac本地环境进行pulsar进行调试，以及一个线上的linux正式环境进行部署上线.同时俊瑶先生本次使用的nodejs的pulsar版本。
根据官方文档 pulsar安装文档,要使用pulsar的nodejs版本，需要安装Pulsar C++库.

安装 C++库请阅读文档 Pulsar C++ client

mac安装

mac安装的时候，务必安装xcode,如果是beta版本的，务必指定选择xcode的beta，从而达到装mac C++的要求,也即gcc
然后通过brew安装libpulsar
brew install libpulsar
全局安装 pulsar-client
npm install pulsar-client -g

linux安装

linux服务器采用ubuntu,下载Debian package
并通过 apt install ./apache-pulsar-client*.deb进行安装

client

client-devel

实践使用

TODO:

经常操作数组，统一做一次整理吧

entries、keys、values

示例

ES6 提供三个新的方法——entries()，keys()和values()——用于遍历数组。

keys

1
2
3
4
5

for (let index of ['a', 'b'].keys()) {
  console.log(index);
}
// 0
// 1

values

1
2
3
4
5

for (let item of ['a', 'b'].values()) {
  console.log(item);
}
// 'a'
// 'b'

entries

1
2
3
4

for (let [index, value] of ['a', 'b'].entries()) {
  console.log(index, value);
}
// 0 "a"

fromEntries

一般结合Object.fromEntries数组转对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 对象转数组
const obj = {
    a: '1',
    b: 2
}
const arr = Object.entries(obj)
console.log(arr) // [ [ 'a', '1' ], [ 'b', 2 ] ]

// 数组转对象
const obj = Object.fromEntries([
    ['a', '1'],
    ['b', 2]
])
console.log(obj) //{ a: '1', b: 2 }

concat

合并多个数组，返回合并后的新数组，原数组没有变化。

1
2

const array = [1,2].concat(['a', 'b'], ['name']);
// [1, 2, "a", "b", "name"]

另外也可以通过

1
2
3

const arr1 = [1, 2]
const arr2 = ['a', 'b']
const array = [...arr2, arr2]

indexOf

indexOf()方法返回在该数组中第一个找到的元素位置，如果它不存在则返回-1。

语法

1

array.indexOf(item,start)

• item 必须。查找的元素。
• start 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

示例

1
2

var arr = ['apple','orange','pear'];
console.log("found:", arr.indexOf("orange") != -1);

forEach

只要是for循环能够遍历的数组，forEach都可以实现。

语法

1

array.forEach(function(currentValue, index, arr), thisValue)

• currentValue 必需。当前元素
• index 可选。当前元素的索引值。
• arr 可选。当前元素所属的数组对象。

示例

1
2
3
4
5
6
7
8

let arr1 = [1, 5, 7, 8, 9, 6]
let str = ''

arr1.forEach((item, index, array) => {
  console.log(item, index, array)
  str += `<li>${item}</li>`
})
console.log(str)

some every

• some方法 如果数组中有一个元素满足条件，返回true 否则返回false
• every方法 如果数组中所有元素都满足条件则返回true 否则返回false

语法

1
2

array.some(function(currentValue,index,arr),thisValue)
array.every(function(currentValue,index,arr), thisValue)

• currentValue 必须。当前元素的值
• index 可选。当前元素的索引值
• arr 可选。当前元素属于的数组对象

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

let arr = [5, 7, 8, 9, 6, ]
const v = arr.some(item => {
    return item < 6
})
const x = arr.every(item => {
    return item < 9
})

console.log(v) //true
console.log(x) //false

const obj = [{
        name: '小明',
        age: 9,
        sex: '男'
    },
    {
        name: '小红',
        age: 10,
        sex: '女'
    }
]
const a = obj.some(item => {
    return item.name == '小红'
})
const b = obj.every(item => {
    return item.age == 9
})
console.log(a) //true
console.log(b) //false

filter

• 将数组中符合条件的元素留下来组成一个新的数组
• filter() 不会改变原始数组。

语法

1

array.filter(function(currentValue,index,arr), thisValue)

• currentValue 必须。当前元素的值
• index 可选。当前元素的索引值
• arr 可选。当前元素属于的数组对象

示例

filter简单过滤

1
2
3
4
5

let arr = [1, 5, 6, 3, 4, 2, 8, 7];
const a = arr.filter(item => {
    return item < 5
});
console.log(a) //[1,3,4,2]

filter数组去重

1
2
3
4
5
6
7
8
9
10

var array = [1, 2, 1, 2, 4, 5, 3, 5, 6, 7, 6];
// 检测数组下标，是否等于当前项的下标，不相等则认为有重复
var result = array.filter((item, index, arr) => {
    // item : 数组每一项的值
    // index: 每一项的下标
    // arr: 原始数组
    return index === arr.indexOf(item);
})

console.log(result); //[1, 2, 4, 5,3, 6, 7]

find

• 遍历数组，当找到第一个符合条件的元素的时候，就会停止遍历，并返回这个元素，如果没找到符合条件的数组就输出undefined
  实例：

语法

1

array.find(function(currentValue, index, arr),thisValue)

• currentValue 必需。当前元素
• index 可选。当前元素的索引值
• arr 可选。当前元素所属的数组对象

示例

1
2
3
4
5
6
7
8
9

let arr = [1, 5, 6, 3, 4, 2, 8, 7];
  const b = arr.find(item => {
      return item > 9
  });
  const c = arr.find(item => {
      return item < 9
  });
  console.log(b) //undefined
  console.log(c) //1

includes

• 只要对应数组中包含这个元素，就返回true, 否则返回false

语法

1
2
3

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

• searchElement必须。需要查找的元素值。
• fromIndex可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。

示例：

1
2
3
4
5

let arr = [1, 5, 6, 3, 4, 2, 8, 7];
const d = arr.includes(7)
const x = arr.includes(9)
console.log(d) //true
console.log(x) //false

map

• 根据已知数组把已知数组作为元素生成新的的数组，新数组的长度与已知数组长度一致

语法

1

array.map(function(currentValue,index,arr), thisValue)

• currentValue 必须。当前元素的值
• index 可选。当前元素的索引值
• arr 可选。当前元素属于的数组对象

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let arr = [1, 5, 6, 3, 4, 2, 8, 7];
 const y = arr.map((item, index, array) => {
     return item, array
 })
 console.log(y)
 //   (8)[Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8)]
 //   0: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   1: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   2: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   3: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   4: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   5: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   6: (8)[1, 5, 6, 3, 4, 2, 8, 7]
 //   7: (8)[1, 5, 6, 3, 4, 2, 8, 7]

reduce

定义和用法

• reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
• reduce() 可以作为一个高阶函数，用于函数的 compose。
  注意: reduce() 对于空数组是不会执行回调函数的。

语法

1

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

• total 必需。初始值, 或者计算结束后的返回值。
• currentValue 必需。当前元素
• currentIndex 可选。当前元素的索引
• arr 可选。当前元素所属的数组对象。

示例

reduce累加求和

1
2
3
4
5
6

const arr = [3,9,4,3,6,0,9]
const sum = arr.reduce((pre, item) => {
    return pre + item
}, 0)
console.log(sum) // 34

reduce数组最大值

1
2
3
4
5

const arr = [3,9,4,3,6,0,9]
var max = arr.reduce((prev, cur) => {
    return Math.max(prev,cur)
})
console.log(max) // 9

reduce数组去重

1
2
3
4
5
6

const arr = [3,9,4,3,6,0,9]
var newArr = arr.reduce((prev, cur) => {
    prev.indexOf(cur) === -1 && prev.push(cur);
    return prev;
},[]);
console.log(newArr) // [ 3, 9, 4, 6, 0 ]

reduce数组对象去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

let person = [
     {id: 0, name: "小明"},
     {id: 1, name: "小张"},
     {id: 2, name: "小李"},
     {id: 3, name: "小孙"},
     {id: 1, name: "小周"},
     {id: 2, name: "小陈"},  
];
 
let obj = {};
 
let peon = person.reduce((cur,next) => {
    obj[next.id] ? "" : obj[next.id] = true && cur.push(next);
    return cur;
},[]) //设置cur默认类型为数组，并且初始值为空的数组
console.log(peon);

sort

语法

1

array.sort(sortfunction)

示例

1
2
3
4

var points = [40, 100, 1, 5, 25, 10]
points.sort( (a, b) => {
    return a - b
})

Set

示例

Set数组去重

1
2
3
4

const arr = [3,9,4,3,6,0,9]
let set = new Set(arr)
const newArr = Array.from(set)
console.log(newArr) // [ 3, 9, 4, 6, 0 ]

介绍

Redis是一个开源的内存中键值数据存储。Redis有几个命令，可让您即时更改Redis服务器的配置设置。本教程将介绍其中一些命令，并说明如何使这些配置更改永久生效。

如何使用本指南

本指南以备有完整示例的备忘单形式编写。我们鼓励您跳至与您要完成的任务相关的任何部分。

本指南中显示的命令已在运行Redis版本的Ubuntu 18.04服务器上进行了测试 4.0.9。要设置类似的环境，您可以按照我们的指南如何在Ubuntu 18.04上安装和保护Redis的步骤1进行操作。我们将通过使用Redis命令行界面运行它们来演示这些命令的行为。请注意，如果您使用其他Redis界面（例如Redli），则某些命令的确切输出可能会有所不同。redis-cli

请注意，托管Redis数据库通常不允许用户更改配置文件。如果您正在使用DigitalOcean的托管数据库，则本指南中概述的命令将导致错误。

更改Redis的配置

本节中概述的命令仅会在当前会话期间或直到您运行之前更改Redis服务器的行为，config rewrite以使其永久不变。您可以通过使用首选文本编辑器打开和编辑Redis配置文件来直接更改它。例如，您可以nano这样做：

  * sudo nano /etc/redis/redis.conf 

警告：该config set命令被认为是危险的。通过更改Redis配置文件，有可能导致Redis服务器以意外或不良方式运行。我们建议您仅在config set测试命令的行为时运行命令，或者绝对确定要对Redis配置进行更改。

您可能会希望将此命令重命名为偶然运行的可能性较低的名称。

config set允许您在运行时重新配置Redis，而无需重新启动服务。它使用以下语法：

  * config set parameter value 

例如，如果要更改运行save命令后Redis将产生的数据库转储文件的名称，则可以运行如下命令：

  * config set "dbfilename" "new_file.rdb" 

如果配置更改有效，则命令将返回OK。否则将返回错误。

注意：并非redis.conf文件中的每个参数都可以通过config set操作来更改。例如，您不能更改requirepass参数定义的身份验证密码。

永久进行配置更改

config set不会永久更改Redis实例的配置文件；它仅在运行时更改Redis的行为。要redis.conf在运行config-set命令后进行编辑并使当前会话的配置永久化，请运行config rewrite：

  * config rewrite 

该命令将尽最大努力保留原始redis.conf文件的注释和整体结构，而只需进行最小的更改即可匹配服务器当前使用的设置。

就像config set，如果重写成功config rewrite将返回OK。

检查Redis的配置

要读取Redis服务器的当前配置参数，请运行config get命令。config get只有一个参数，其可以是在使用的参数中的任一个完全匹配redis.conf或水珠图案。例如：

  * config get repl* 

根据您的Redis配置，此命令可能返回：

Output

 1) "repl-ping-slave-period" 2) "10" 3) "repl-timeout" 4) "60" 5) "repl-backlog-size" 6) "1048576" 7) "repl-backlog-ttl" 8) "3600" 9) "repl-diskless-sync-delay" 10) "5" 11) "repl-disable-tcp-nodelay" 12) "no" 13) "repl-diskless-sync" 14) "no" 

您还可以config set通过运行返回所有支持的配置参数config get *。

结论

本指南详细介绍了redis-cli用于动态更改Redis服务器的配置文件的命令。如果您想在本指南中概述其他相关的命令，参数或过程，请在下面的评论中提出疑问或提出建议。

介绍

Redis是一个开源的内存中键值数据存储。它带有几个命令，可以帮助您进行故障排除和调试。由于Redis作为内存中键值存储的性质，因此其中许多命令集中于内存管理，但是还有一些其他命令对于概述Redis服务器的状态很有用。本教程将提供有关如何使用其中一些命令来帮助诊断和解决使用Redis时可能遇到的问题的详细信息。

如何使用本指南

本指南以备有完整示例的备忘单形式编写。我们鼓励您跳至与您要完成的任务相关的任何部分。

本指南中显示的命令已在运行Redis版本的Ubuntu 18.04服务器上进行了测试 4.0.9。要设置类似的环境，您可以按照我们的指南如何在Ubuntu 18.04上安装和保护Redis的步骤1进行操作。我们将通过使用Redis命令行界面运行它们来演示这些命令的行为。请注意，如果您使用其他Redis界面（例如Redli），则某些命令的确切输出可能会有所不同。redis-cli

另外，您可以提供一个托管的Redis数据库实例来测试这些命令，但是请注意，根据数据库提供者所允许的控制级别，本指南中的某些命令可能无法按所述方式工作。要配置DigitalOcean托管数据库，请遵循我们的托管数据库产品文档。然后，您必须 安装Redli 或 设置TLS隧道才能通过TLS连接到托管数据库。

对内存相关问题进行故障排除

memory usage告诉您单个键当前正在使用多少内存。它以键的名称作为参数，并输出其使用的字节数：

  * memory usage key_meaningOfLife 

Output

(integer) 42 

为了更全面地了解您的Redis服务器如何使用内存，可以运行以下memory stats命令：

  * memory stats 

此命令输出与内存相关的指标及其值的数组。以下是报告的指标memory stats：

• peak.allocated：Redis消耗的最大字节数
• total.allocated：Redis分配的总字节数
• startup.allocated：Redis在启动时消耗的初始字节数
• `replication.backlog积压的大小，以字节为单位
• clients.slaves：所有副本_开销_的总大小（输出和查询缓冲区以及连接上下文）
• clients.normal：所有客户端开销的总大小
• aof.buffer：当前和重写的仅附加文件缓冲区的总大小
• db.0：服务器上正在使用的每个数据库的主要和到期字典的开销，以字节为单位报告
• overhead.total：用于管理Redis密钥空间的所有开销的总和
• keys.count：服务器上所有数据库中存储的密钥总数
• keys.bytes-per-key：服务器的净内存使用率与 keys.count
• dataset.bytes：数据集的大小，以字节为单位
• dataset.percentage：Redis占用的Redis净内存使用量的百分比 dataset.bytes
• peak.percentage：peak.allocated取出的百分比total.allocated
• fragmentation：当前正在使用的内存量除以Redis实际使用的物理内存之比

memory malloc-stats提供了jemalloc的内部统计报告，该报告是Linux系统上Redis使用的内存分配器：

  * memory malloc-stats 

如果您似乎遇到了与内存有关的问题，但是解析前面命令的输出证明是无济于事的，则可以尝试运行memory doctor：

  * memory doctor 

此功能将输出所有可以发现的内存消耗问题，并提出潜在的解决方案。

获取有关Redis实例的常规信息

与内存管理没有直接关系的调试命令是monitor。此命令使您可以查看Redis服务器处理的每个命令的恒定流：

  * monitor 

Output

OK 1566157213.896437 [0 127.0.0.1:47740] "auth" "foobared" 1566157215.870306 [0 127.0.0.1:47740] "set" "key_1" "878" 

另一个对调试有用的命令是info，它返回有关服务器的多个信息和统计信息块：

  * info 

Output

# Server redis_version:4.0.9 redis_git_sha1:00000000 redis_git_dirty:0 redis_build_id:9435c3c2879311f3 redis_mode:standalone os:Linux 4.15.0-52-generic x86_64 . . . 

此命令返回很多信息。如果您只想查看一个信息块，则可以将其指定为info：

  * info CPU 

Output

# CPU used_cpu_sys:173.16 used_cpu_user:70.89 used_cpu_sys_children:0.01 used_cpu_user_children:0.04 

请注意，该info命令返回的信息将取决于您所使用的Redis版本。

使用keys命令

keys如果您忘记了某个键的名称，或者您已经创建了一个键，但又意外误拼了它的名称，则该命令很有用。keys查找与模式匹配的键：

  * keys pattern 

支持以下glob样式的变量

• ?是通配符站在任何单个字符，这样s?mmy的比赛sammy，sommy和sqmmy
• *是一个通配符，用来代表任何数量的字符，包括没有任何字符，所以sa*y比赛sammy，say，sammmmmmy，和salmony
• 您可以通过将模式将其括在方括号中来指定模式可以包含的两个或多个字符，以便s[ai]mmy匹配sammy和simmy，但不能匹配summy
• 要设置一个忽略一个或多个字母的通配符，请将其括在方括号中，并在其前面加上一个胡萝卜（^），这样s[^oi]mmy可以匹配sammy和sxmmy，但不能匹配sommy或simmy
• 要设置一个通配符，其中包括一系列的字母，范围的开头和结尾分开连字符和括号包起来，这样s[a-o]mmy将匹配sammy，skmmy和sommy，但不srmmy

警告：本Redis的文件警告说，keys应该几乎从来没有在生产环境中使用，因为它可能会对性能产生重大的负面影响。

结论

本指南详细介绍了许多命令，这些命令可用于故障排除和解决与Redis一起使用时可能遇到的问题。如果您想在本指南中概述其他相关的命令，参数或过程，请在下面的注释中提出疑问或提出建议。

介绍

Redis是一个开源的内存中键值数据存储。默认情况下，Redis密钥是_永久性_的，这意味着Redis服务器将继续存储它们，除非手动将其删除。但是，在某些情况下，您已经设置了密钥，但是您知道要在经过一定时间后才将其删除。换句话说，您希望密钥是_可变的_。本教程介绍了如何设置密钥过期，如何检查直到密钥过期的剩余时间以及取消密钥的过期设置。

如何使用本指南

本指南以备有完整示例的备忘单形式编写。我们鼓励您跳至与您要完成的任务相关的任何部分。

本指南中显示的命令已在运行Redis版本的Ubuntu 18.04服务器上进行了测试 4.0.9。要设置类似的环境，您可以按照我们的指南如何在Ubuntu 18.04上安装和保护Redis的步骤1进行操作。我们将通过使用Redis命令行界面运行它们来演示这些命令的行为。请注意，如果您使用其他Redis界面（例如Redli），则某些命令的确切输出可能会有所不同。 redis-cli

另外，您可以提供一个托管的Redis数据库实例来测试这些命令，但是请注意，根据数据库提供者所允许的控制级别，本指南中的某些命令可能无法按所述方式工作。要配置DigitalOcean托管数据库，请遵循我们的托管数据库产品文档。然后，您必须 安装Redli 或 设置TLS隧道才能通过TLS连接到托管数据库。

设置密钥过期

您可以使用expire命令设置现有密钥的到期时间，该命令将密钥的名称和到期前的秒数作为参数。为了证明这一点，请运行以下两个命令。第一创建名为字符串键key_melon具有值"cantaloupe"，而第二组它到450秒之后超时：

  * set key_melon "cantaloupe" 
  * expire key_melon 450 

如果成功设置了超时，则expire命令将返回(integer) 1。如果设置超时失败，它将返回(integer) 0。

或者，您可以使用该expireat命令将密钥设置为在特定的时间点到期。它使用Unix时间戳作为参数，而不是到期前的秒数。Unix时间戳是自1970年1月1日_Unix纪元_或00:00:00 UTC以来的秒数。可以使用许多在线工具来查找特定日期和时间的Unix时间戳，例如EpochConverter或UnixTimestamp.com。

例如，要设置key_melon为在2025年5月1日格林尼治标准时间晚上8:30到期（由Unix timestamp表示1746131400），可以使用以下命令：

  * expireat key_melon 1746131400 

请注意，如果传递给您的时间戳expireat已经发生，它将立即删除密钥。

检查密钥过期的时间

你设置一键到期任何时候，你可以检查剩余到期为止（以秒为单位）的时候ttl，它的全称是“牛逼IME牛逼Ø升香港专业教育学院”：

  * ttl key_melon 

Output

(integer) 433 

有关更详细的信息，可以运行pttl，它将返回直到密钥过期的时间（以毫秒为单位）：

  * pttl key_melon 

Output

(integer) 431506 

如果密钥尚未设置为过期且密钥不存在，则两者ttl和pttl都将返回。(integer) -1``(integer) -2

持久键

如果密钥已设置为过期，则任何覆盖密钥内容的命令（例如set或getset）都会清除密钥的超时值。要手动清除键的超时，请使用以下persist命令：

  * persist key_melon 

如果成功完成，该persist命令将返回(integer) 1，表明密钥将不再过期。

结论

本指南详细介绍了用于在Redis中操作和检查键持久性的许多命令。如果您想在本指南中概述其他相关的命令，参数或过程，请在下面的注释中提出疑问或提出建议。

介绍

Redis是一个开源的内存中键值数据存储。Redis允许您计划一系列命令，然后一个接一个地运行它们，这一过程称为_transaction_。每个事务都被视为不间断且隔离的操作，以确保数据完整性。在执行事务块时，客户端无法运行命令

本教程介绍了如何执行和取消交易，还包括一些与交易通常相关的陷阱的信息。

如何使用本指南

本指南以备有完整示例的备忘单形式编写。我们鼓励您跳至与您要完成的任务相关的任何部分。

本指南中显示的命令已在运行Redis版本的Ubuntu 18.04服务器上进行了测试 4.0.9。要设置类似的环境，您可以按照我们的指南如何在Ubuntu 18.04上安装和保护Redis的步骤1进行操作。我们将通过使用Redis命令行界面运行它们来演示这些命令的行为。请注意，如果您使用其他Redis界面（例如Redli），则某些命令的确切输出可能会有所不同。redis-cli

另外，您可以提供一个托管的Redis数据库实例来测试这些命令，但是请注意，根据数据库提供者所允许的控制级别，本指南中的某些命令可能无法按所述方式工作。要配置DigitalOcean托管数据库，请遵循我们的托管数据库产品文档。然后，您必须 安装Redli 或 设置TLS隧道才能通过TLS连接到托管数据库。

进行交易

该multi命令告诉Redis开始事务块。在运行exec命令之前，所有后续命令都将排队等待执行。

以下命令形成一个事务块。第一个命令启动事务，第二个命令设置一个包含值的字符串的键1，第三个命令将值增加1，第四个命令将其值增加40，第五个命令返回字符串的当前值，最后一个返回执行事务块：

  * multi 
  * set key_MeaningOfLife 1 
  * incr key_MeaningOfLife 
  * incrby key_MeaningOfLife 40 
  * get key_MeaningOfLife 
  * exec 

运行后multi，redis-cli将使用响应以下每个命令QUEUED。运行exec命令后，它将分别显示每个命令的输出：

Output

1) OK 2) (integer) 2 3) (integer) 42 4) "42" 

事务块中包含的命令按排队顺序依次运行。Redis事务是_原子的_，这意味着要么处理事务块中的每个命令（意味着它被视为有效并排队等待执行），要么不执行。但是，即使命令成功排队，执行时它仍然可能产生错误。在这种情况下，事务中的其他命令仍然可以运行，但是Redis将跳过导致错误的命令。有关更多详细信息，请参见了解事务错误的部分。

取消交易

要取消交易，请运行discard命令。这样可以防止任何先前排队的命令运行：

  * multi 
  * set key_A 146 
  * incrby key_A 10 
  * discard 


Output

OK 

该discard命令将连接返回到正常状态，该状态告诉Redis像往常一样运行单个命令。您需要multi再次运行以告知服务器您正在开始另一笔交易。

了解交易错误

某些命令可能无法排队，例如语法错误的命令。如果尝试对语法错误的命令进行排队，则Redis将返回错误。

以下事务创建了一个名为的键key_A，然后尝试将其增加10。但是，该incrby命令中的拼写错误会导致并出错并关闭该事务：

  * multi 
  * set key_A 146 
  * incrbuy key_A 10 


Output

(error) ERR unknown command 'incrbuy' 

如果exec在尝试将命令与类似语法错误的命令放入队列后尝试运行命令，则会收到另一条错误消息，告知您事务已被丢弃：

  * exec 


Output

(error) EXECABORT Transaction discarded because of previous errors. 

在这种情况下，您需要重新启动事务块并确保正确输入每个命令。

一些不可能命令_是_可能的队列，例如运行incr在仅包含字符串的密钥。由于该命令在语法上是正确的，因此，如果您尝试将其包含在事务中，则Redis不会返回错误，也不会阻止您运行exec。在这种情况下，将执行队列中的所有其他命令，但不可能的命令将返回错误：

  * multi 
  * set key_A 146 
  * incrby key_A "ten" 
  * exec 


Output

1) OK 2) (error) ERR value is not an integer or out of range 

有关Redis如何处理事务中的错误的更多信息，请参阅关于此主题的官方文档。

结论

本指南详细介绍了许多用于在Redis中创建，运行和取消事务的命令。如果您想在本指南中概述其他相关的命令，参数或过程，请在下面的注释中提出疑问或提出建议。

介绍

Redis是一个开源的内存中键值数据存储。在Redis的，排序集合类似于一个数据类型集在这两者都是串的非重复的组。不同之处在于，已排序集中的每个成员都与一个分数相关联，从而可以从最小分数到最大分数进行排序。与集合一样，已排序集合中的每个成员都必须是唯一的，尽管多个成员可以共享同一分数。

本教程说明了如何创建排序集，检索和删除其成员以及如何从现有集合中创建新的排序集。

如何使用本指南

本指南以备有完整示例的备忘单形式编写。我们鼓励您跳至与您要完成的任务相关的任何部分。

本指南中显示的命令已在运行Redis版本的Ubuntu 18.04服务器上进行了测试 4.0.9。要设置类似的环境，您可以按照我们的指南如何在Ubuntu 18.04上安装和保护Redis的步骤1进行操作。我们将通过使用Redis命令行界面运行它们来演示这些命令的行为。请注意，如果您使用其他Redis界面（例如Redli），则某些命令的确切输出可能会有所不同。redis-cli

另外，您可以提供一个托管的Redis数据库实例来测试这些命令，但是请注意，根据数据库提供者所允许的控制级别，本指南中的某些命令可能无法按所述方式工作。要配置DigitalOcean托管数据库，请遵循我们的托管数据库产品文档。然后，您必须 安装Redli 或 设置TLS隧道才能通过TLS连接到托管数据库。

创建排序集并添加成员

要创建排序集，请使用zadd命令。zadd接受将保留排序后的键集的键的名称作为参数，后跟要添加的成员的分数和成员本身的值。以下命令将创建一个排序的集合密钥，该集合密钥的faveGuitarists一个成员名为，"Joe Pass"得分为1：

  * zadd faveGuitarists 1 "Joe Pass" 

zadd 将返回一个整数，该整数指示如果已成功创建排序集，则将多少个成员添加到排序集中。

Output

(integer) 1 

您可以使用将多个成员添加到排序集中zadd。请注意，他们的分数不必是连续的，分数之间可以有间隔，并且相同排序集中的多个成员可以共享相同的分数：

  * zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser" 

Output

(integer) 8 

zadd 可以接受以下选项，您必须在密钥名称之后和第一个成员评分之前输入以下选项：

• NX或XX：这些选项具有相反的效果，因此您在任何zadd操作中都只能包括其中之一：
  • NX：告诉zadd 不更新现有成员。使用此选项，zadd将仅添加新元素。
  • XX：告诉zadd给只更新现有的元素。使用此选项，zadd将永远不会添加新成员。
• CH：通常，zadd仅返回添加到排序集中的新元素的数量。但是，使用此选项时，zadd将返回_更改后的_元素个数。这包括新添加的成员和分数已更改的成员。
• INCR：这会使命令增加成员的得分值。如果该成员还不存在，则该命令会将其添加到已排序的集合中，并将其增量作为分数，就像其原始分数是一样0。有了INCR，zadd将成功返回成员的新分数。请注意，使用此选项时，一次只能包含一个分数/成员对。

无需将INCR选项传递给zadd，您可以使用zincrby行为完全相同的命令。而不是给排序后的集合成员一个分数值所表示的值，例如zadd，它使该成员的分数增加该值。例如，以下命令将"Stephen Malkmus"原来是该成员的得分4提高5到9。

  * zincrby faveGuitarists 5 "Stephen Malkmus" 

Output

"9" 

与zadd命令INCR选项的情况一样，如果指定的成员不存在，则将zincrby使用增量值作为其得分来创建它。

从排序集中检索成员

检索排序集中的成员的最基本方法是使用zrange命令。此命令接受要检索其成员的键的名称以及其中包含的成员范围作为参数。该范围由两个数字定义，这些数字表示从零开始的索引，0表示代表排序集中的第一个成员（或得分最低的成员），1代表下一个，依此类推。

下面的示例将返回faveGuitarists上一部分中创建的排序集中的前四个成员：

  * zrange faveGuitarists 0 3 

Output

1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch" 

请注意，如果传递给的排序集zrange具有两个或多个共享相同分数的元素，它将按照_字典顺序_或字母顺序对这些元素进行排序。

开始索引和停止索引也可以是负数，-1代表最后一个成员，-2代表倒数第二个，依此类推：

  * zrange faveGuitarists -5 -2 

Output

1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser" 

zrange可以接受WITHSCORES参数，当包含该参数时，该参数还将返回成员的分数：

  * zrange faveGuitarists 5 6 WITHSCORES 

Output

1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9" 

zrange只能以数字升序返回一系列成员。要反转它并以降序返回范围，必须使用zrevrange命令。可以将此命令视为暂时反转给定排序集的顺序，然后返回属于指定范围内的成员。因此，使用zrevrange，0将代表密钥中持有的最后一个成员，1将代表倒数第二个，等等：

  * zrevrange faveGuitarists 0 5 

Output

1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch" 

zrevrange也可以接受该WITHSCORES选项。

您可以使用zrangebyscore命令根据其分数返回一系列成员。在下面的示例中，该命令将返回faveGuitarists键中分数为2、3或4的任何成员：

  * zrangebyscore faveGuitarists 2 4 

Output

1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie" 

在此示例中，范围是包含端值的，这意味着它将返回得分为2或4的成员。您可以在范围的任一端都加上开放括号（(），以排除范围的任何一端。以下示例将返回分数大于或等于2，但小于的每个成员4：

  * zrangebyscore faveGuitarists 2 (4 

Output

1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 

与一样zrange，zrangebyscore可以接受WITHSCORES参数。它还接受该LIMIT选项，您可以使用该选项仅从zrangebyscore输出中检索元素的选择。该选项接受一个offset（偏移量）和一个count（计数），该偏移量标记该命令将返回的范围内的第一个成员，该计数总共定义该命令将返回的成员数。例如，以下命令将查看已faveGuitarists排序集合的前六个成员，但仅从该集合中返回3个成员，从该范围内的第二个成员开始，由表示1：

  * zrangebyscore faveGuitarists 0 5 LIMIT 1 3 

Output

1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 

该zrevrangebyscore命令根据成员的得分返回相反的范围。以下命令将返回分数在10到6之间的集合中的每个成员：

  * zrevrangebyscore faveGuitarists 10 6 

Output

1) "Stephen Malkmus" 2) "Elizabeth Cotten" 

与一样zrangebyscore，zrevrangebyscore可以接受WITHSCORES和LIMIT选项。此外，您可以在范围的任一末端加上一个开放的括号，以排除该末端。

有时，排序集中的所有成员都具有相同的分数。在这种情况下，您可以使用命令强制redis返回按_字典顺序_或字母顺序排序的元素范围zrangebylex。要尝试此命令，请运行以下zadd命令以创建一个排序集，其中每个成员的得分均相同：

  * zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly 

zrangebylex后面必须跟一个键的名称，一个开始间隔和一个停止间隔。开始和停止时间间隔必须以圆括号（(）或方括号（）开头[，如下所示：

  * zrangebylex SomervilleSquares [a [z 

Output

1) "assembly" 2) "ball" 3) "magoun" 4) "porter" 

请注意，即使该命令查找的范围是从a到，该示例也仅返回集合中八个成员中的四个z。这是因为Redis值区分大小写，因此以大写字母开头的成员将从其输出中排除。要返回这些值，可以运行以下命令：

  * zrangebylex SomervilleSquares [A [z 

Output

1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter" 

zrangebylex也接受特殊字符-，它们代表负无穷大，而+代表正无穷大。因此，以下命令语法还将返回排序集中的每个成员：

  * zrangebylex SomervilleSquares - + 

请注意，zrangebylex不能以相反的字典顺序（字母升序）返回排序的集合成员。为此，请使用zrevrangebylex：

  * zrevrangebylex SomervilleSquares + - 

Output

1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis" 

因为它适用于每个成员都具有相同分数的排序集，zrangebylex所以不接受该WITHSCORES选项。但是，它确实接受该LIMIT选项。

检索有关排序集的信息

要查找给定排序集中有多少个成员（或者换句话说，确定其基数），请使用zcard命令。以下示例显示了faveGuitarists本指南第一部分中密钥中拥有多少成员：

  * zcard faveGuitarists 

Output

(integer) 9 

zcount可以告诉您在给定的排序集中包含多少个分数范围内的元素。键后的第一个数字是范围的开始，第二个数字是范围的结束：

  * zcount faveGuitarists 3 8 

Output

(integer) 4 

zscore 输出排序集中指定成员的分数：

  * zscore faveGuitarists "Bola Sete" 

Output

"3" 

如果指定的成员或密钥都不存在，zscore将返回(nil)。

zrank与相似zscore，但不返回给定成员的分数，而是返回其排名。在Redis中，_等级_是排序集中成员的从零开始的索引，按其得分排序。例如，"Joe Pass"得分为1，但由于这是键中所有成员的最低得分，因此其等级为0：

  * zrank faveGuitarists "Joe Pass" 

Output

(integer) 0 

调用了另一个Redis命令zrevrank，该命令执行与相同的功能zrank，但取而代之的是反转集合中成员的等级。在以下示例中，该成员"Joe Pass"的得分最低，因此其反向排名最高：

  * zrevrank faveGuitarists "Joe Pass" 

Output

(integer) 8 

成员的分数与其等级之间的唯一关系是其分数相对于其他成员的分数所在的位置。如果两个连续成员之间存在得分差距，则该得分差距不会反映在他们的排名中。请注意，如果两个成员的分数相同，则按字母顺序排在第一位的成员将具有较低的排名。

类似于zscore，如果键或成员不存在zrank，zrevrank将返回(nil)。

zlexcount可以告诉您在词典范围之间的排序集中有多少个成员。下面的示例使用SomervilleSquares上一节中的排序集：

  * zlexcount SomervilleSquares [M [t 

Output

(integer) 5 

该命令的语法与zrangebylex命令的语法相同，因此有关如何定义字符串范围的详细信息，请参考上一节。

从排序集中删除成员

该zrem命令可以从排序集中删除一个或多个成员：

  * zrem faveGuitarists "Doug Martsch" "Bola Sete" 

zrem 将返回一个整数，指示从排序集中删除了多少个成员：

Output

(integer) 2 

有三个Redis命令，可让您根据范围删除排序集的成员。例如，如果排序集中的每个成员都具有相同的分数，则可以使用来根据词典范围删除成员zremrangebylex。该命令使用与相同的语法zrangebylex。以下示例将从SomervilleSquares上一部分中创建的键中删除所有以大写字母开头的成员：

  * zremrangebylex SomervilleSquares [A [Z 

zremrangebylex 将输出一个整数，指示已删除的成员数：

Output

(integer) 3 

您还可以zremrangebyscore使用命令使用与命令相同的语法，根据分数范围删除成员zrangebyscore。以下示例将删除每个faveGuitarists得分为4、5或6的成员：

  * zremrangebyscore faveGuitarists 4 6 

Output

(integer) 1 

您可以从基于一系列与队伍的一组删除成员zremrangebyrank的命令，它使用相同的语法zrangebyrank。以下命令将删除排名最低的排序集中的三个成员，这些成员由一系列从零开始的索引定义：

  * zremrangebyrank faveGuitarists 0 2 

Output

(integer) 3 

请注意，传递给的数字remrangebyrank也可以为负，-1代表最高排名，次高排名，-2依此类推。

从现有集合创建新的排序集合

Redis包括两个命令，它们允许您比较多个排序集的成员并基于这些比较创建新的：zinterstore和zunionstore。要试验这些命令，请运行以下zadd命令以创建一些示例排序集。

  * zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny" 
  * zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC" 

zinterstore查找两个或多个排序集（它们的交集）共享的成员，并生成仅包含那些成员的新排序集。此命令必须依次包含相交成员将作为排序集存储的目标键的名称，要传递给的键的数量以及zinterstore要分析的键的名称：

  * zinterstore BoyBands 2 NewKids Nsync 

zinterstore将返回一个整数，该整数显示存储到目标排序集中的元素数。因为NewKids且Nsync仅共享一个成员"Joey"，所以该命令将返回1：

Output

(integer) 1 

请注意，如果目标键已经存在，zinterstore将覆盖其内容。

zunionstore将创建一个新的排序集，其中包含传递给它的每个键成员。此命令使用与相同的语法zinterstore，并且需要目标键的名称，传递给该命令的键的数量以及键的名称：

  * zunionstore SuperGroup 2 NewKids Nsync 

像一样zinterstore，zunionstore将返回一个整数，显示存储在目标键中的元素数。即使两个原始排序集都包含五个成员，但由于排序集不能具有重复成员，并且每个键都有一个名为"Joey"的成员，因此所得的整数将为9：

Output

(integer) 9 

与一样zinterstore，zunionstore如果目标键已经存在，它将覆盖目标键的内容。

为了在使用zinterstore和创建新的排序集时更好地控制成员分数zunionstore，这两个命令都接受WEIGHTS和AGGREGATE选项。

对于WEIGHTS该命令中包含的每个排序集，该选项后均带有一个数字，该数字_加权_或乘以每个成员的分数。WEIGHTS选项之后的第一个数字对传递给命令的第一个键的分数加权，第二个数字对第二个键的加权加权，依此类推。

以下示例创建一个新的排序集，其中包含来自NewKids和Nsync排序集的相交键。它将NewKids密钥中的分数加权三倍，并将密钥中的分数加权Nsync七倍：

  * zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7 

如果WEIGHTS选项未包括在内，权重默认为1两个zinterstore和zunionstore。

AGGREGATE接受三个子选项。其中的第一个通过添加组合集中匹配成员的得分来SUM实现zinterstore和zunionstore的默认行为。

如果在共享一个成员的两个排序集合上运行zinterstore或zunionstore运算，但是该成员在每个集合中具有不同的分数，则可以使用MIN子选项强制操作为新集合中的两个分数中的较低者赋值。

  * zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN 

由于两个排序的集合只有一个具有相同分数（3）的匹配成员，因此此命令将创建一个新集合，其成员具有两个加权分数中的较低者：

  * zscore BoyBandsWeightedMin "Joey" 

Output

"9" 

同样，AGGREGATE可以使用以下选项强制zinterstore或zunionstore分配两个分数中的较高者MAX：

  * zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX 

此命令创建一个新集合，其中有一个成员，"Joey"具有两个加权得分中的较高者：

  * zscore BoyBandsWeightedMax "Joey" 

Output

"21" 

将其WEIGHTS视为在分析成员之前临时操纵其分数的一种方式可能会有所帮助。同样，将AGGREGATE选项视为在将成员添加到新集中之前决定如何控制其分数的一种方式也很有帮助。

结论

本指南详细介绍了用于在Redis中创建和管理排序集的许多命令。如果您想在本指南中概述其他相关的命令，参数或过程，请在下面的注释中提出疑问或提出建议。