一、响应式编程(Reactive Programming)
1. 什么是响应式编程
响应式编程是一种面向数据变化和传播过程的编程范式。
其核心思想是:将数据变化视为可观察的信号,当数据发生变化时,依赖该数据的计算和处理逻辑能够自动响应。
传统命令式编程通常由开发者显式控制更新过程:
let price = 100;
let quantity = 2;
let total = price * quantity;
price = 120;
// 必须手动重新计算
total = price * quantity;
console.log(total); // 240
响应式编程则强调建立数据之间的依赖关系,使派生数据能够随着源数据变化而更新。
概念上:
price ─────┐
├──> total
quantity ──┘
这里的关系表示 total 依赖 price 和 quantity。当任一依赖发生变化时,系统可以触发重新计算。
2. 响应式系统的核心组成
一个典型的响应式系统通常包含以下组成部分:
| 组成 | 作用 |
|---|---|
| 数据源(Source) | 提供初始值或持续变化的数据 |
| 可观察对象(Observable) | 表示可以被订阅的数据流 |
| 订阅者(Subscriber) | 接收数据变化并执行处理 |
| 操作符(Operator) | 转换、过滤、组合数据流 |
| 调度器(Scheduler) | 控制任务执行时机和调度策略 |
| 依赖追踪(Dependency Tracking) | 记录数据与计算逻辑之间的依赖关系 |
并非所有响应式框架都采用完全相同的实现结构。例如,基于信号(Signal)的系统通常直接追踪状态依赖,而 RxJS 一类的流式系统则以 Observable 和订阅机制为核心。
3. 响应式数据传播机制
响应式系统通常需要完成依赖建立、变化检测、依赖通知和派生计算。
flowchart TD
A["创建数据源"] --> B["建立依赖关系"]
B --> C["订阅或追踪依赖"]
C --> D["源数据发生变化"]
D --> E["检测变化"]
E --> F["通知依赖节点"]
F --> G["重新计算或执行回调"]
G --> H["更新下游状态或视图"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意,响应式不意味着每次数据变化都会立即同步执行所有依赖逻辑。具体执行时机取决于框架的调度策略,可能涉及批处理、微任务、宏任务或延迟计算。
4. 响应式数据与依赖追踪
响应式系统的重要能力是自动建立数据依赖。
例如:
const state = {
price: 100,
quantity: 2
};
function getTotal() {
return state.price * state.quantity;
}
如果使用响应式系统,执行 getTotal() 时可以记录它读取了哪些响应式属性。
当 price 或 quantity 更新时,系统便知道需要重新执行相关计算。
依赖关系可以抽象为:
flowchart TD
A["price"] --> C["getTotal"]
B["quantity"] --> C
C --> D["total"]
D --> E["视图更新"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
在 JavaScript 中,可以通过 Proxy 实现简单的属性访问追踪:
const dependencies = new Map();
let activeEffect = null;
function reactive(target) {
return new Proxy(target, {
get(obj, key) {
if (activeEffect) {
let effects = dependencies.get(key);
if (!effects) {
effects = new Set();
dependencies.set(key, effects);
}
effects.add(activeEffect);
}
return obj[key];
},
set(obj, key, value) {
obj[key] = value;
const effects = dependencies.get(key);
if (effects) {
effects.forEach(effect => effect());
}
return true;
}
});
}
function effect(fn) {
activeEffect = fn;
fn();
activeEffect = null;
}
const state = reactive({
price: 100,
quantity: 2
});
effect(() => {
console.log(state.price * state.quantity);
});
state.price = 120;
这个简化示例演示了依赖收集和触发更新的基本思想。
生产级响应式系统还需要处理:
- 多个对象具有相同属性名时的依赖隔离。
- 嵌套对象和数组的依赖追踪。
- 条件分支导致的动态依赖变化。
- 删除属性和新增属性。
- 嵌套 effect 的上下文恢复。
- 循环更新与重复触发。
- 批量调度和更新顺序。
例如,上面的示例仅使用属性名作为依赖键,不同对象中相同名称的属性会产生错误的依赖关联,因此不能直接用于生产环境。
5. 响应式数据流
响应式编程不仅可以处理单个变量的变化,还可以将连续发生的数据变化组织成数据流(Data Stream)。
数据流可以表示:
- 用户输入。
- 鼠标移动。
- 网络请求结果。
- 定时器信号。
- 消息队列数据。
- 传感器数据。
- 实时业务事件。
例如,使用 RxJS:
import { fromEvent } from "rxjs";
import { map, filter } from "rxjs/operators";
const clicks = fromEvent(
document,
"click"
);
const positions = clicks.pipe(
map(event => ({
x: event.clientX,
y: event.clientY
})),
filter(position => position.x > 100)
);
const subscription = positions.subscribe(position => {
console.log(position);
});
这里:
fromEvent将 DOM 事件转换为 Observable。map将原始事件转换为坐标数据。filter过滤不满足条件的数据。subscribe注册数据流消费者。
数据流处理的优势是可以通过操作符逐步构建复杂的异步处理逻辑。
6. 响应式编程的主要特点
声明式数据关系
开发者描述数据依赖和转换规则,而不必在每个数据修改位置手动更新所有关联状态。
自动依赖传播
数据发生变化时,系统根据依赖关系通知相关计算或订阅者。
异步数据处理
可以统一处理定时器、网络请求、用户输入和消息事件等异步数据源。
数据流组合
通过映射、过滤、合并、节流等操作符构建复杂的数据处理流程。
执行调度
系统可以控制更新时机,支持批处理、延迟执行和并发调度。
二、事件驱动编程(Event-Driven Programming)
1. 什么是事件驱动编程
事件驱动编程是一种以事件发生作为程序执行触发条件的编程模型。
事件(Event)表示系统中发生的某种事实或状态变化,例如:
- 用户点击按钮。
- HTTP 请求到达。
- 定时器触发。
- 文件读取完成。
- 数据库连接断开。
- 消息队列收到消息。
- 订单状态发生变化。
程序不必按照固定顺序主动轮询所有可能发生的情况,而是注册事件处理逻辑,在事件到达时执行对应操作。
例如:
const button = document.querySelector("#submit");
button.addEventListener("click", () => {
console.log("按钮被点击");
});
这里:
click是事件类型。addEventListener注册事件监听器。- 回调函数是事件处理器。
- 用户点击按钮时,浏览器触发事件处理流程。
2. 事件驱动系统的核心组成
| 组成 | 作用 |
|---|---|
| 事件源(Event Source) | 产生事件的实体 |
| 事件(Event) | 描述发生的事实 |
| 事件监听器(Listener) | 监听指定类型的事件 |
| 事件处理器(Handler) | 接收事件并执行业务逻辑 |
| 事件分发器(Dispatcher) | 将事件分发给相应处理器 |
| 事件队列(Event Queue) | 暂存等待处理的事件 |
| 事件循环(Event Loop) | 协调事件与任务的执行 |
不同系统不一定包含所有组件。
例如,浏览器 DOM 事件具有事件传播机制,而消息队列驱动的后端系统可能由 Broker、Consumer 和消息确认机制组成。
3. 事件驱动的基本执行流程
flowchart TD
A["事件源产生事件"] --> B["事件进入分发机制"]
B --> C["匹配监听器"]
C --> D["调用事件处理器"]
D --> E{"处理成功?"}
E -->|"是"| F["完成事件处理"]
E -->|"否"| G["执行异常处理"]
G --> H["记录错误或重试"]
H --> I["结束或重新投递"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
事件驱动模型的关键是事件与处理逻辑之间的关联关系,而不是必须存在一个独立的事件队列。
4. 事件监听与处理
在 JavaScript 中,可以使用 EventTarget 实现事件监听。
const eventTarget = new EventTarget();
function handleOrderCreated(event) {
console.log("订单创建成功:", event.detail);
}
eventTarget.addEventListener(
"orderCreated",
handleOrderCreated
);
const event = new CustomEvent("orderCreated", {
detail: {
orderId: 1001,
amount: 299
}
});
eventTarget.dispatchEvent(event);
这里通过自定义事件将事件产生者与处理逻辑分离。
事件生产者只负责发布事件,不需要直接知道具体由谁处理。
5. 发布订阅模式(Publish-Subscribe)
发布订阅模式是事件驱动编程中常见的设计模式。
它通过事件主题或消息通道建立发布者和订阅者之间的间接关系。
- 发布者(Publisher):发布事件。
- 订阅者(Subscriber):订阅感兴趣的事件。
- 事件中心(Event Bus):负责接收和分发事件。
例如:
class EventBus {
constructor() {
this.events = new Map();
}
on(type, handler) {
if (!this.events.has(type)) {
this.events.set(type, new Set());
}
this.events.get(type).add(handler);
}
emit(type, data) {
const handlers = this.events.get(type);
if (!handlers) {
return;
}
handlers.forEach(handler => handler(data));
}
off(type, handler) {
this.events.get(type)?.delete(handler);
}
}
const bus = new EventBus();
bus.on("orderCreated", data => {
console.log("通知库存服务", data);
});
bus.on("orderCreated", data => {
console.log("通知消息服务", data);
});
bus.emit("orderCreated", {
orderId: 1001
});
一个事件可以被多个订阅者接收,实现一对多的消息分发。
需要注意,以上实现是同步的内存事件总线,不具备持久化、跨进程传输、消息确认和失败重试等能力。
6. 事件驱动与事件循环
在 JavaScript 浏览器环境和 Node.js 中,事件循环(Event Loop)是异步任务调度的重要机制。
以浏览器环境为例,主要涉及:
- 调用栈(Call Stack)。
- 浏览器提供的 Web APIs。
- 任务队列(Task Queue)。
- 微任务队列(Microtask Queue)。
- 事件循环调度。
典型执行关系:
flowchart TD
A["执行同步代码"] --> B["调用栈执行完成"]
B --> C["执行微任务队列"]
C --> D{"是否还有微任务?"}
D -->|"是"| C
D -->|"否"| E["浏览器执行渲染机会"]
E --> F["执行下一个宏任务"]
F --> G["检查微任务队列"]
G --> C
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这里需要特别注意:
- 同步代码在当前调用栈中执行。
- 当前任务结束后,浏览器会执行微任务检查点。
- 微任务通常包括 Promise 回调和
queueMicrotask注册的任务。 - 浏览器在适当时机执行渲染。
- 随后继续处理后续任务。
这个流程是浏览器事件循环的简化模型。Node.js 的事件循环阶段、调度规则和渲染机制与浏览器不同,不能直接套用浏览器的完整执行顺序。
三、响应式编程与事件驱动编程的区别
两者经常结合使用,但关注点并不相同。
1. 核心区别
| 对比维度 | 响应式编程 | 事件驱动编程 |
|---|---|---|
| 核心关注 | 数据变化与传播 | 事件发生与处理 |
| 基本抽象 | 数据流、状态、依赖 | 事件、监听器、处理器 |
| 触发依据 | 数据源变化 | 事件被触发 |
| 处理方式 | 转换、过滤、组合、传播 | 分发、监听、执行处理器 |
| 典型场景 | 状态管理、实时数据流 | 用户交互、消息处理 |
| 常见技术 | RxJS、Reactor、Signals | DOM Events、EventEmitter、消息队列 |
| 设计目标 | 管理数据变化关系 | 解耦事件产生与事件处理 |
2. 两者的关系
响应式编程可以使用事件作为数据源,事件驱动系统也可以使用响应式数据流处理事件。
例如:
flowchart TD
A["用户点击按钮"] --> B["产生 Click 事件"]
B --> C["转换为响应式数据流"]
C --> D["过滤无效事件"]
D --> E["执行数据转换"]
E --> F["更新应用状态"]
F --> G["触发视图更新"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
两者的结合可以同时获得:
- 事件生产与业务处理之间的解耦。
- 数据变化的自动传播。
- 数据流的转换与组合能力。
- 对异步处理过程的统一管理。
四、响应式编程的典型实现机制
不同响应式框架采用的实现方式并不完全相同,但常见机制包括依赖追踪、订阅通知、数据流操作和调度执行。
1. 观察者模式(Observer Pattern)
观察者模式通过维护观察者列表,使一个对象的状态变化能够通知多个观察者。
基本结构:
- Subject:被观察对象。
- Observer:观察者。
- Notify:通知机制。
- Update:观察者的更新行为。
class Subject {
constructor() {
this.observers = new Set();
}
subscribe(observer) {
this.observers.add(observer);
}
unsubscribe(observer) {
this.observers.delete(observer);
}
notify(data) {
this.observers.forEach(observer => {
observer.update(data);
});
}
}
class Observer {
update(data) {
console.log("收到更新:", data);
}
}
const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();
subject.subscribe(observer1);
subject.subscribe(observer2);
subject.notify({
value: 100
});
观察者模式适合实现一对多的通知关系。