实现具备三特性的Observable/Subject：继承BehaviorSubject是否有隐患？

嘿，你的需求抓得很准——想要一个同时具备BehaviorSubject记忆最后值、只发射变化值，还能让消费者明确知道getValue()可用的Subject对吧？先聊聊直接继承BehaviorSubject的思路可能踩的坑，再给你几个更稳妥的实现方案。

直接继承看起来省事，但其实容易埋下几个隐患：

• 违反里氏替换原则：BehaviorSubject本身允许调用next()发射重复值，但你继承后肯定要重写next()来过滤重复值。如果其他代码把你的实例当成普通BehaviorSubject用，预期能发射重复值，就会出现不符合预期的行为。
• 内部状态不可控：BehaviorSubject的内部状态（比如当前存储的值）是私有的，你只能通过它暴露的API操作。万一RxJS版本更新改变了它的内部实现，你的子类可能会莫名其妙地崩溃。
• 类型歧义：虽然你加了明确的getter，但用户如果把你的实例赋值给BehaviorSubject类型的变量，就会忽略掉它的去重逻辑，容易造成误解和bug。

推荐用组合而非继承的方式来实现，这样既能完全控制行为，又能保持类型的清晰性。

方案1：封装BehaviorSubject的自定义类（最推荐） #

创建一个全新的类，内部封装BehaviorSubject，对外只暴露你需要的API，完全掌控所有行为：

import { BehaviorSubject, Observable, distinctUntilChanged } from 'rxjs';

export class DistinctUntilChangedBehaviorSubject<T> {
  private readonly innerSubject: BehaviorSubject<T>;
  // 对外暴露的可观察流，已经做了去重处理
  public readonly observable: Observable<T>;

  constructor(initialValue: T) {
    this.innerSubject = new BehaviorSubject<T>(initialValue);
    // 对输出流应用distinctUntilChanged，确保只发射变化的值
    this.observable = this.innerSubject.asObservable().pipe(distinctUntilChanged());
  }

  // 自定义next方法，先判断值是否变化再发射
  next(value: T): void {
    // 这里可以根据需求替换成深比较，比如用lodash的isEqual
    if (value !== this.innerSubject.getValue()) {
      this.innerSubject.next(value);
    }
  }

  // 明确暴露的getValue方法，类型提示清晰
  getValue(): T {
    return this.innerSubject.getValue();
  }

  // 代理订阅方法，方便直接订阅
  subscribe(...args: Parameters<Observable<T>['subscribe']>) {
    return this.observable.subscribe(...args);
  }

  // 按需代理其他必要方法，比如complete、error
  complete(): void {
    this.innerSubject.complete();
  }

  error(err: unknown): void {
    this.innerSubject.error(err);
  }
}

这个方案的好处：

• 完全隔离内部实现，外部无法绕过你的去重逻辑调用原始的next()
• 类型明确，IDE会自动提示getValue()等方法，消费者一眼就能知道它的特性
• 不受RxJS内部更新的影响，扩展性更强

方案2：用操作符快速包装（简单快捷） #

如果不想写完整的类，也可以用函数包装BehaviorSubject，同时暴露去重后的流和getter：

import { BehaviorSubject, Observable, distinctUntilChanged } from 'rxjs';

function createDistinctBehaviorSubject<T>(initialValue: T): {
  observable: Observable<T>;
  next: (value: T) => void;
  getValue: () => T;
  complete: () => void;
  error: (err: unknown) => void;
} {
  const subject = new BehaviorSubject<T>(initialValue);
  const observable = subject.asObservable().pipe(distinctUntilChanged());

  return {
    observable,
    next: (value) => {
      if (value !== subject.getValue()) {
        subject.next(value);
      }
    },
    getValue: () => subject.getValue(),
    complete: () => subject.complete(),
    error: (err) => subject.error(err)
  };
}

// 使用示例
const counter = createDistinctBehaviorSubject(0);
counter.observable.subscribe(val => console.log(val));
counter.next(0); // 不会触发订阅输出
counter.next(1); // 输出1
console.log(counter.getValue()); // 1

这个方案更轻量，但要注意如果用户拿到原始subject（如果你把它暴露出去），还是能发射重复值，所以适合不需要严格控制内部状态的场景。

不管用哪种方案，TypeScript都会帮你确保类型安全：

• 自定义类的getValue()方法是明确声明的，消费者使用时IDE会自动提示，不会有歧义
• 函数包装的返回值也明确标注了所有可用方法，类型提示清晰

总结一下：直接继承BehaviorSubject不是最优解，用组合的方式封装既能满足你的三个核心需求，又能避免继承带来的潜在问题，还能保持强类型的清晰性。

内容的提问来源于stack exchange，提问作者bingles