罗罗编程学习记录
本页内容 展开查看

01.3.2.12 迭代器与其余行为型

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 迭代器模式的四个角色与遍历协议的本质
  • Java 的 Iterable/Iterator 关系与增强 for 语法糖
  • Java fail-fast 机制与 ConcurrentModificationException
  • Go 手写 Next() 闭包与 range 的适配方式
  • Python 的 __iter__/__next__ 协议与生成器
  • TypeScript 的 Symbol.iterator 与生成器函数
  • Rust 的 Iterator trait 与惰性求值适配器链
  • C# 的 IEnumerable<T> 与 yield return 状态机
  • PHP 的 Iterator 接口与 Generator 协程
  • 边遍历边修改导致迭代器失效的安全删除方式
  • 中介者、备忘录、访问者三个模式的语言级落地与取舍

面试题索引

编号 题目 难度 状态 备注
01.3.2.12-001 迭代器模式解决什么问题?四个角色是什么? 基础 已完成 意图与协议
01.3.2.12-002 Java 的 Iterator 与 Iterable 是什么关系?增强 for 底层是什么? 基础 已完成 语法糖与协议
01.3.2.12-003 Java 的 fail-fast 机制是怎么工作的?什么情况抛异常? 进阶 已完成 modCount 与并发修改
01.3.2.12-004 Go 怎么手写迭代器?range-over-func 是什么? 进阶 已完成 闭包迭代与新特性
01.3.2.12-005 Python 的 iter/next 协议与生成器是什么关系? 基础 已完成 生成器即迭代器
01.3.2.12-006 TypeScript 的 Symbol.iterator 协议与生成器函数怎么写? 基础 已完成 可迭代协议
01.3.2.12-007 Rust 的 Iterator trait 为什么是惰性求值? 进阶 已完成 适配器链与零成本
01.3.2.12-008 C# 的 IEnumerable<T> 与 yield return 是怎么工作的? 进阶 已完成 编译器状态机
01.3.2.12-009 PHP 的 Iterator 接口与 Generator 怎么写? 进阶 已完成 foreach 协议
01.3.2.12-010 边遍历边修改集合会发生什么?各语言怎么安全删除? 进阶 已完成 失效与安全删除
01.3.2.12-011 中介者模式解决什么问题?它和观察者、外观的区别? 进阶 已完成 中央协调与网状解耦
01.3.2.12-012 备忘录模式怎么实现撤销?和命令模式的 Undo 栈有什么区别? 进阶 已完成 快照 vs 反向操作
01.3.2.12-013 访问者模式的双重分派是怎么工作的?开闭取舍在哪里? 高级 已完成 双重分派与开闭倒置
01.3.2.12-014 访问者在现代语言里还必要吗?哪些 GoF 模式已退化为语言特性? 高级 已完成 模式退化与语言特性

01.3.2.12-001 迭代器模式解决什么问题?四个角色是什么?

一句话结论

迭代器把「集合怎么存」和「怎么遍历」分开,调用方通过统一接口逐个取元素,不需要知道底层是数组、链表还是树;一个集合可以同时存在多个游标互不干扰。

概念解释

  • 四个角色:集合(Aggregate,创建迭代器)、迭代器接口(hasNext/next/remove)、具体迭代器(维护游标)、客户端(只依赖迭代器接口)。
  • 本质:把遍历算法从集合类里抽出来,集合只负责存数据,迭代器负责「下一个是谁」。
  • 收益:新增遍历方式(前序、后序、过滤)不改集合;集合内部结构调整不影响调用方。

原理流程

  1. 集合暴露 iterator() 方法,返回一个新的迭代器实例。
  2. 迭代器内部持有当前游标与对集合的引用。
  3. 客户端循环调用 hasNext() 与 next(),游标前移。
  4. 多个迭代器实例各自维护游标,互相独立。

代码或图示

Aggregate ──iterator()──> Iterator
                              │ hasNext() 是否还有元素
                              │ next()    返回当前元素并前移
                              │ remove()  删除刚返回的元素(可选)
public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() { throw new UnsupportedOperationException(); }
}

常见误区

  • 认为迭代器只是 for 循环的包装:它的价值在于把遍历策略抽象成对象,支持多种遍历与并发游标。
  • 把迭代器和枚举(Enumeration)混为一谈:迭代器是现代统一协议,支持删除语义与泛型。
  • 一个集合只允许一个迭代器:每个 iterator() 调用返回新实例,多个游标可同时存在。

追问

  • 迭代器和游标(Cursor)数据库的概念关系?答:思想同源,都是「位置 + 取下一个」,数据库游标在服务端维护位置,集合迭代器在内存中维护。
  • 为什么要有 remove() 而不是直接在集合上删?答:直接删会破坏迭代器内部游标,remove() 让迭代器知道如何同步调整位置。

01.3.2.12-002 Java 的 Iterator 与 Iterable 是什么关系?增强 for 底层是什么?

一句话结论

Iterable 是「可被迭代」的标记接口,声明 iterator() 方法返回一个 Iterator;增强 for 语法糖只要求对象实现 Iterable,编译后展开成 iterator().hasNext()/next() 循环。

概念解释

  • Iterable<T>:有 iterator() 方法,是 for-each 的前提。
  • Iterator<T>:真正的游标,有 hasNext()/next()。
  • 数组没有实现 Iterable,但编译器对数组做了特殊处理,也能 for-each。

原理流程

  1. 编译器看到 for (E e : collection)。
  2. 如果 collection 是数组,展开成索引循环。
  3. 如果是 Iterable,调用 iterator() 并展开成 while 循环。
  4. var 与泛型擦除不影响这个展开。

代码或图示

// 可迭代集合只需实现 Iterable
public class CardDeck implements Iterable<Card> {
    private final List<Card> cards = new ArrayList<>();

    @Override
    public Iterator<Card> iterator() {
        return cards.iterator();
    }
}

// for-each
for (Card c : deck) {
    System.out.println(c);
}
// 编译后等价于:
// Iterator<Card> it = deck.iterator();
// while (it.hasNext()) { Card c = it.next(); ... }

常见误区

  • 以为实现 Iterator 就能 for-each:必须实现 Iterable,Iterator 本身不是 for-each 的前提。
  • 在 for-each 里调用 list.remove():会抛 ConcurrentModificationException,应改用 it.remove()。
  • 以为 List 有 iterator() 是它自己发明的:它来自 Collection 接口继承自 Iterable。

追问

  • ListIterator 和普通 Iterator 的区别?答:ListIterator 支持双向遍历、set() 替换当前元素、nextIndex(),只能由 List 生成。
  • 为什么 Iterable 要返回新的 Iterator 而不是单例?答:多个游标独立遍历是迭代器的核心价值,单例会让两个循环互相干扰。

01.3.2.12-003 Java 的 fail-fast 机制是怎么工作的?什么情况抛异常?

一句话结论

Java 集合在迭代器内部维护一个期望的 modCount(集合结构修改次数),每次 next() 检查实际 modCount 是否等于期望值;不等就抛 ConcurrentModificationException,用于快速暴露多线程或单线程下的并发修改 bug。

概念解释

  • modCount:集合每次 add/remove 都会自增。
  • 迭代器创建时记录 expectedModCount。
  • next() 开头做 checkForComodification(),不一致即抛异常。
  • 这不是保证安全,而是「尽量早暴露」,不能作为同步手段。

原理流程

  1. 迭代器创建,记录 expectedModCount = modCount。
  2. 调用 it.next() 前检查 modCount == expectedModCount。
  3. 不一致立即抛异常,不继续遍历。
  4. 通过 it.remove() 删除时,迭代器会同步更新 expectedModCount,所以不抛异常。

代码或图示

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if (s.equals("b")) {
        list.remove(s);   // 直接调用集合删除 → modCount 变了
    }
}
// 下一次 it.next() 抛 ConcurrentModificationException

// 正确写法:用迭代器自己的 remove
it.remove();

常见误区

  • 以为 fail-fast 是为了多线程安全:它是诊断机制,多线程下仍可能漏检,不能替代同步。
  • 以为 it.remove() 也会触发:它会同步更新 expectedModCount,这是设计好的安全路径。
  • 用 CopyOnWriteArrayList 就万事大吉:它的迭代器是「快照」,不抛异常,但遍历的是旧数据,写操作对遍历不可见。

追问

  • 为什么叫 fail-fast 而不是 fail-safe?答:它的目标是第一时间崩溃暴露 bug,而不是容忍错误继续跑。
  • ConcurrentHashMap 的迭代器为什么不抛异常?答:它是弱一致(weakly consistent)迭代器,遍历反映的是迭代器创建时的状态,允许并发修改而不抛异常。

01.3.2.12-004 Go 怎么手写迭代器?range-over-func 是什么?

一句话结论

Go 没有内建的迭代器接口,惯用做法是返回一个「Next() 闭包」:调用方反复调用闭包,返回 (value, ok),ok=false 表示结束;标准 range 只能遍历切片、map、通道,不能直接作用于自定义集合。

概念解释

  • 闭包迭代器:func() (T, bool),每次调用取下一个。
  • 这种模式需要调用方手写循环,不能直接 for v := range collection。
  • range-over-func(迭代器函数作为 range 表达式)是 Go 较新引入的特性,允许 for v := range iterFn 直接遍历自定义迭代器。

原理流程

  1. 集合暴露 Iter() 方法,返回一个闭包。
  2. 闭包内部维护游标,每次调用返回下一个元素与是否结束。
  3. 调用方用 for 配合 Next() 取值。
  4. 若使用 range-over-func,迭代器函数签名需满足语言规定的迭代器协议(具体签名与可用性以官方文档为准)。

代码或图示

package deck

type Card struct {
    Suit string
    Rank int
}

type Deck struct {
    cards []Card
}

// Next 返回闭包迭代器:每次调用返回下一张牌和是否结束
func (d *Deck) Iter() func() (Card, bool) {
    i := 0
    return func() (Card, bool) {
        if i >= len(d.cards) {
            return Card{}, false
        }
        c := d.cards[i]
        i++
        return c, true
    }
}
// 调用方
next := deck.Iter()
for {
    c, ok := next()
    if !ok {
        break
    }
    _ = c
}
// range-over-func(待确认)
// 验证点:
// 1) 该特性在当前 Go 版本是否已稳定启用;
// 2) 迭代器函数签名(func(yield func(T) bool) 或等价形式);
// 3) 是否支持自定义集合直接 for v := range deck.Iter()。
// 用法示意:
// for c := range deck.Iter() { ... }

常见误区

  • 以为 Go 有类似 Java Iterator 的内建接口:Go 的理念是「小接口 + 惯用写法」,不强制统一迭代协议。
  • 闭包里忘记捕获游标:i 必须在闭包外定义,否则每次调用都从 0 开始。
  • 把 range-over-func 当成已稳定特性直接写进项目:版本相关特性需确认当前工具链支持。

追问

  • Go 的 range 通道关闭后会怎样?答:通道关闭后 range 自动退出循环,这是通道作为迭代源的内置语义。
  • 闭包迭代器为什么用 (T, bool) 而不是抛异常?答:Go 错误处理惯例是多返回值,迭代结束是正常流程不是异常。

01.3.2.12-005 Python 的 iter/next 协议与生成器是什么关系?

一句话结论

Python 的迭代协议由 __iter__ 返回迭代器、__next__ 返回下一个元素(耗尽抛 StopIteration)构成;生成器函数(带 yield)就是语言语法自动生成的迭代器,两者协议完全兼容。

概念解释

  • 可迭代对象:实现 __iter__,返回一个迭代器。
  • 迭代器:实现 __next__,耗尽时抛 StopIteration。
  • 生成器:调用带 yield 的函数时返回一个生成器对象,它自动实现了 __iter__ 与 __next__。
  • 惰性:生成器只在请求时产出值,不一次性占内存。

原理流程

  1. for x in obj 调用 iter(obj),即 obj.__iter__()。
  2. 每次循环调用 next(obj),即 obj.__next__()。
  3. 抛 StopIteration 时循环结束。
  4. 生成器函数在每个 yield 处暂停,下次调用 next() 时从暂停处继续。

代码或图示

class Countdown:
    def __init__(self, start: int) -> None:
        self.current = start

    def __iter__(self):
        return self  # 迭代器就是自己

    def __next__(self) -> int:
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1


# 生成器:同样的语义,语法更短
def countdown(n: int):
    while n > 0:
        yield n
        n -= 1


for c in countdown(5):
    print(c)  # 5 4 3 2 1

常见误区

  • 以为 __iter__ 必须返回 self:可以返回一个独立的迭代器对象,支持多游标。
  • 把生成器当列表用:生成器只能遍历一次,遍历完就耗尽;需要重复遍历要重新调用或转成 list。
  • 在生成器里 return 一个值:return 后生成器结束,返回值不会被 for 捕获(要靠 StopIteration.value 或 yield from)。

追问

  • iter(obj, sentinel) 双参数形式是做什么的?答:把一个无参函数包成迭代器,直到返回值等于 sentinel,常用于读文件块。
  • 生成器和列表推导式的取舍?答:只遍历一次且数据量大用生成器((x for x in ...)),需要多次随机访问用列表。

01.3.2.12-006 TypeScript 的 Symbol.iterator 协议与生成器函数怎么写?

一句话结论

JS/TS 的可迭代协议由 Symbol.iterator 定义:对象有一个返回迭代器的方法,迭代器有 next() 返回 {value, done};生成器函数(function*)自动实现这个协议,是最简洁的迭代器写法。

概念解释

  • 可迭代协议:[Symbol.iterator]() 返回迭代器。
  • 迭代器协议:next() 返回 {value, done}。
  • 生成器函数:function* 声明,内部用 yield,返回的生成器对象同时是可迭代对象和迭代器。
  • for...of 只作用于可迭代对象,不作用于普通对象。

原理流程

  1. for (const x of obj) 调用 obj[Symbol.iterator]()。
  2. 每次循环调用返回的迭代器的 next()。
  3. done === true 时循环结束。
  4. 生成器函数在 yield 处暂停,下次 next() 时恢复。

代码或图示

class Range implements Iterable<number> {
  constructor(private start: number, private end: number) {}

  *[Symbol.iterator](): Generator<number> {
    for (let i = this.start; i < this.end; i++) {
      yield i;
    }
  }
}

// 直接 for...of
for (const n of new Range(1, 5)) {
  console.log(n); // 1 2 3 4
}

// 生成器函数也能单独用
function* fib(limit: number) {
  let [a, b] = [0, 1];
  while (a < limit) {
    yield a;
    [a, b] = [b, a + b];
  }
}

常见误区

  • 以为 for...of 能遍历普通对象:普通对象不可迭代,要用 Object.keys()/Object.entries() 或显式实现 Symbol.iterator。
  • 把生成器当数组用:生成器只能走一次,[...gen] 会把它展开成数组并耗尽它。
  • 混淆 for...in 和 for...of:for...in 遍历键名(含原型链),for...of 遍历可迭代值。

追问

  • 生成器的 yield* 是做什么的?答:委托给另一个可迭代对象,逐个 yield 它的值,类似 yield from。
  • 迭代器和 observables 的区别?答:迭代器是「拉模式」(调用方要一个给一个),observable 是「推模式」(数据源主动推送)。

01.3.2.12-007 Rust 的 Iterator trait 为什么是惰性求值?

一句话结论

Rust 的 Iterator trait 只定义 next() 一个核心方法,map/filter/take 等适配器都返回新的迭代器类型、不立即执行;只有调用 collect()/for 循环时才真正拉取元素,这是零成本抽象——迭代器最终编译成手写循环。

概念解释

  • Iterator trait:核心方法 fn next(&mut self) -> Option<Self::Item>。
  • 适配器:map、filter、take、enumerate、zip 等,返回新迭代器。
  • 惰性:适配器不消费元素,只是「装饰」迭代器,形成链式表达式。
  • 消费者:collect()、sum()、any()、for 循环才真正驱动 next()。

原理流程

  1. 从集合获得一个迭代器(iter()/iter_mut()/into_iter())。
  2. 链式调用适配器,每个适配器包装前一个迭代器。
  3. 遇到消费者时,消费者反复调用 next(),沿链向上请求元素。
  4. 编译器把整个链优化成等价的手写循环,无运行时虚表开销。

代码或图示

fn main() {
    let nums = vec![1, 2, 3, 4, 5];

    let sum: i32 = nums
        .iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * 10)
        .sum(); // 消费者:到此才真正执行

    println!("{}", sum); // 60(20 + 40)
}
// 手写一个迭代器
struct Counter {
    current: i32,
}

impl Iterator for Counter {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        if self.current < 5 {
            self.current += 1;
            Some(self.current)
        } else {
            None
        }
    }
}

常见误区

  • 以为 map 会立即执行:它只是构建迭代器链,不调用消费者就什么都不会发生。
  • 忘记 iter() vs into_iter():iter() 产生借用,into_iter() 取得所有权,类型不同。
  • 在迭代器里写有副作用的闭包:惰性求值意味着副作用只在消费者驱动时发生,调用次数取决于消费者。

追问

  • Iterator 为什么能零成本?答:每个适配器是一个具体类型,编译器 monomorphization 后内联展开,没有 trait 对象的虚表开销。
  • Rust 的迭代器和 C++ 的 STL 算法思路像吗?答:思路同源,都是「惰性/泛型算法 + 适配器」,Rust 把它做成了语言内建的 trait。

01.3.2.12-008 C# 的 IEnumerable<T> 与 yield return 是怎么工作的?

一句话结论

IEnumerable<T> 是「可被枚举」的接口,yield return 让编译器把方法改写成一个状态机:每次 MoveNext() 恢复到上次暂停处,产出一个元素,无需手写迭代器类。

概念解释

  • IEnumerable<T>:有 GetEnumerator() 返回 IEnumerator<T>。
  • IEnumerator<T>:有 Current 属性与 MoveNext() 方法。
  • yield return:编译器自动生成状态机类,记录当前位置、局部变量、暂停点。
  • 延迟执行:yield 方法被调用时不执行,只有 foreach 或 MoveNext() 才驱动。

原理流程

  1. 调用 yield 方法,返回一个枚举器对象,方法体尚未执行。
  2. foreach 开始时调用 MoveNext(),执行到第一个 yield return 暂停。
  3. Current 返回该元素。
  4. 下次 MoveNext() 从暂停处继续,直到方法结束返回 false。

代码或图示

IEnumerable<int> EvenNumbers(int start, int count)
{
    int produced = 0;
    int current = start % 2 == 0 ? start : start + 1;
    while (produced < count)
    {
        yield return current;
        current += 2;
        produced++;
    }
}

// 调用:此时才真正执行
foreach (int n in EvenNumbers(1, 5))
{
    Console.WriteLine(n); // 2 4 6 8 10
}
// 手写等价的迭代器(编译器自动生成的就是这种)
public interface IIterator<out T>
{
    bool MoveNext();
    T Current { get; }
}

常见误区

  • 以为 yield 方法调用时就执行:它只是构建状态机,延迟到 foreach。
  • 把 yield 结果缓存成 List 后又抱怨失去惰性:ToList() 会立即消费并耗尽。
  • 在 yield 方法里用 try/finally:finally 只在枚举器被完全耗尽或显式 Dispose() 时执行,提前 break 也会触发。

追问

  • yield break 是什么?答:提前结束迭代,相当于 MoveNext() 返回 false。
  • C# 的 IAsyncEnumerable<T> 是什么?答:异步版本,配合 await foreach,用于流式异步数据源,状态机由编译器生成。

01.3.2.12-009 PHP 的 Iterator 接口与 Generator 怎么写?

一句话结论

PHP 的 Iterator 接口要求实现 current()/key()/next()/rewind()/valid() 五个方法,foreach 原生支持;Generator 通过 yield 语法自动实现这个接口,是 PHP 里惰性迭代与协程的基础。

概念解释

  • Iterator 接口:PHP 内建的迭代器协议,foreach 检测到对象实现它就会按协议遍历。
  • Generator:yield 函数返回的对象,实现了 Iterator 与 Countable 等接口。
  • 惰性:生成器不一次性占内存,适合读大文件、分页查询。

原理流程

  1. foreach 遇到对象时先调 rewind()。
  2. 每次循环调 valid() 判断是否有效。
  3. 有效则取 current() 与 key(),然后调 next()。
  4. yield 函数在每个 yield 处暂停,下次 next() 时恢复。

代码或图示

<?php
// 1. 手动实现 Iterator
class NumberRange implements Iterator
{
    private int $position = 0;
    public function __construct(private int $start, private int $end) {}

    public function rewind(): void { $this->position = $this->start; }
    public function current(): int { return $this->position; }
    public function key(): int { return $this->position; }
    public function next(): void { $this->position++; }
    public function valid(): bool { return $this->position <= $this->end; }
}

foreach (new NumberRange(1, 5) as $n) {
    echo $n; // 12345
}
<?php
// 2. Generator:同样的语义,语法更短
function readLines(string $file): Generator
{
    $handle = fopen($file, 'r');
    while (($line = fgets($handle)) !== false) {
        yield $line;
    }
    fclose($handle);
}

foreach (readLines('/var/log/app.log') as $line) {
    // 逐行处理,不一次性加载整个文件
}

常见误区

  • 以为 foreach 能遍历任意对象:只有实现 Iterator 或 IteratorAggregate 的对象才能被 foreach。
  • 把 Generator 当数组:Generator 只能走一次,且不支持随机访问与 count()(除非额外实现)。
  • 在 Generator 里 return 值:return 会结束生成器,返回值通过 getReturn() 获取,不被 yield 产出。

追问

  • yield from 是做什么的?答:委托遍历另一个可迭代对象或生成器,逐个产出它的值。
  • Generator 在 PHP 里怎么当协程用?答:结合 send() 与 yield 接收外部值,实现协作式调度,Swoole/衍生库常用这种模式。

01.3.2.12-010 边遍历边修改集合会发生什么?各语言怎么安全删除?

一句话结论

边遍历边直接修改集合结构会让迭代器内部游标与集合状态不一致:Java 抛 ConcurrentModificationException,C++ 迭代器失效,Python/JS 表现为跳过元素或提前结束;安全做法是用迭代器自带的删除方法、或先收集待删除项再统一删。

概念解释

  • Java:fail-fast 抛异常,安全路径是 it.remove()。
  • Python:列表遍历中 remove 会跳过元素,推荐倒序遍历或推导式重建。
  • TypeScript/JS:for...of 中 splice 会跳过元素。
  • C#:foreach 中修改集合直接抛 InvalidOperationException。
  • Rust:迭代器借用规则在编译期禁止遍历时修改集合。

原理流程

  1. 遍历开始,迭代器记录当前状态。
  2. 外部直接 add/remove,集合结构变化。
  3. 迭代器再 next() 时发现状态不一致,要么抛异常,要么游标错位。
  4. 安全路径:先标记待删除项,遍历结束后统一过滤重建;或用迭代器提供的删除方法。

代码或图示

// Java:安全删除
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().startsWith("tmp")) {
        it.remove();  // 安全:迭代器同步更新 modCount
    }
}
# Python:不安全,会跳过元素
for x in items:
    if x.startswith("tmp"):
        items.remove(x)  # 下一个元素被跳过

# 安全做法:列表推导式重建
items = [x for x in items if not x.startswith("tmp")]
// TypeScript:先收集再过滤
const toRemove = new Set<string>();
for (const id of ids) {
    if (id.startsWith("tmp")) toRemove.add(id);
}
const filtered = ids.filter((x) => !toRemove.has(x));
// Rust:编译期就禁止
// let mut v = vec![1, 2, 3];
// for x in v.iter() {
//     v.push(*x); // 编译错误:v 已被不可变借用
// }

常见误区

  • 以为用 for 循环就安全:Java 的 for-each 底层还是迭代器,一样会 fail-fast。
  • 在 C# foreach 里 RemoveAt:直接抛 InvalidOperationException,应转成 for 倒序索引。
  • 用并发集合就忽略修改语义:CopyOnWriteArrayList 的遍历是快照,删除操作不会反映到正在进行的遍历上。

追问

  • 为什么倒序遍历能安全删除?答:从后往前删,前面的索引不受影响,不会错位。
  • Rust 怎么实现「遍历时收集待删除项」?答:先 iter().filter().collect() 收集,再赋值回去,借用规则天然分开了读与写。

01.3.2.12-011 中介者模式解决什么问题?它和观察者、外观的区别?

一句话结论

中介者把多个同事对象之间的网状引用收敛到一个中央协调对象,同事之间只认识中介者;它和观察者的区别是「方向」不同(中介者主动转发,观察者被动订阅),和外观的区别是「对内对外」不同(中介者解耦内部同事互调,外观简化对外入口)。

概念解释

  • 角色:中介者接口、具体中介者、同事对象。
  • 网状引用:A 知道 B、C、D,B 知道 A、C、D……维护成本高。
  • 中介者:A 只认识中介者,由中介者决定通知谁。
  • 适用:聊天室、航班调度、GUI 控件联动、多表单组件联动。

原理流程

  1. 梳理同事对象之间的调用关系,画出网状图。
  2. 抽取公共交互为中介者接口。
  3. 同事对象持有中介者引用,事件发生时 mediator.notify(event)。
  4. 中介者根据事件决定转发给哪些同事。

代码或图示

// 聊天室:成员不直接互发消息,都交给聊天室
abstract class User {
    public abstract void send(String msg);
    public abstract void receive(String msg);
}

class ChatRoom {
    public void showMessage(User user, String msg) {
        System.out.println(user.name + ": " + msg);
    }
}
无中介者: A ↔ B ↔ C ↔ D(网状,N 个对象 N*(N-1) 条引用)
有中介者: A ──> Mediator <── B
           C ──> Mediator <── D(每个对象只认识中介者)

常见误区

  • 把中介者写成上帝类:中介者只协调交互,不承担同事自身的业务逻辑。
  • 同事仍保留对其他同事的直接引用:解耦不彻底,等于穿了中介者的外衣。
  • 把所有联动都塞进一个中介者:联动规则多了应拆成多个职责单一的中介者。

追问

  • 中介者和事件总线(观察者)怎么区分?答:事件总线是「发布者不知道订阅者是谁」,中介者是「同事知道中介者、中介者知道同事」;前者更解耦,后者更可控。
  • 前端状态管理(如 Redux)是中介者吗?答:是,Store 就是中央协调者,组件 dispatch action,Store 决定如何更新状态并通知订阅组件。

01.3.2.12-012 备忘录模式怎么实现撤销?和命令模式的 Undo 栈有什么区别?

一句话结论

备忘录在不暴露对象内部结构的前提下保存状态快照,回滚时直接恢复整个快照;命令模式的 Undo 栈记录操作序列,回滚时执行反向操作。前者是「存状态」,后者是「存操作」,内存开销与复杂度特征不同。

概念解释

  • 三个角色:发起人(Originator,创建/恢复备忘录)、备忘录(Memento,不可变快照)、负责人(Caretaker,保存快照栈)。
  • 命令 Undo:每个命令对象自带 undo(),栈里存的是命令而不是状态。
  • 备忘录适合「状态恢复代价小、操作历史复杂」的场景;命令 Undo 适合「操作可逆、状态大」的场景。

原理流程

  1. 操作前,发起人 createMemento() 保存当前状态。
  2. 负责人把备忘录压入栈。
  3. 撤销时,负责人弹出备忘录,交回发起人 restore(memento)。
  4. 命令模式则是把每个变更命令压栈,撤销时调用 command.undo()。

代码或图示

// 备忘录:保存编辑器状态
class Editor {
    private String text = "";
    public Memento save() { return new Memento(text); }
    public void restore(Memento m) { this.text = m.text; }
}

class Memento {
    public final String text;
    public Memento(String text) { this.text = text; }
}

class History {
    private final Deque<Memento> stack = new ArrayDeque<>();
    public void push(Memento m) { stack.push(m); }
    public Memento pop() { return stack.pop(); }
}
备忘录:栈里存 [状态快照1, 状态快照2, 状态快照3]
        撤销 = 弹出快照,整体覆盖
命令:  栈里存 [命令1(undo), 命令2(undo), 命令3(undo)]
        撤销 = 弹出命令,执行它的 undo()

常见误区

  • 备忘录里共享可变引用:快照保存了引用,后续原对象变了快照也跟着变,必须深拷贝或只存不可变数据。
  • 无限制保存快照:大对象快照会让内存爆炸,需要设置历史上限或用基线 + 增量。
  • 以为备忘录和命令二选一:实际编辑器常两者结合——命令栈记录操作,关键节点用备忘录做基线检查点。

追问

  • 大对象怎么做高效快照?答:只存差异(diff),定期全量基线 + 增量,恢复时回放增量。
  • Git 的 commit 是备忘录还是命令?答:是备忘录——每次 commit 保存整个文件树的快照,checkout 是恢复快照。

01.3.2.12-013 访问者模式的双重分派是怎么工作的?开闭取舍在哪里?

一句话结论

访问者通过两次方法调用完成分派:元素 accept(visitor) 先把自身类型传给 visitor,visitor 再调用对应 visit(元素类型) 方法;它对「新增操作」开放(加 visitor 类即可),但对「新增元素类型」封闭(必须改所有 visitor 接口),是开闭原则的「有方向取舍」。

概念解释

  • 双重分派:第一次分派按元素类型(this 的类型),第二次按 visitor 的 visit 重载。
  • 元素结构稳定:元素类型集合不常变,操作频繁新增。
  • 开闭倒置:经典开闭是「对扩展开放、对修改封闭」,访问者选择了「操作可扩展、元素不可扩展」。

原理流程

  1. 元素实现 accept(Visitor v),内部调 v.visit(this)。
  2. this 的编译期类型决定调用哪个 visit 重载。
  3. 新增操作:实现一个新 Visitor 类,所有元素类型都不用改。
  4. 新增元素类型:必须在 Visitor 接口加一个 visit(新元素),所有现有 Visitor 都要改。

代码或图示

interface Shape {
    void accept(Visitor v);
}

class Circle implements Shape {
    public void accept(Visitor v) { v.visit(this); } // this 是 Circle
}

class Square implements Shape {
    public void accept(Visitor v) { v.visit(this); } // this 是 Square
}

interface Visitor {
    void visit(Circle c);
    void visit(Square s);
}

class XmlExportVisitor implements Visitor {
    public void visit(Circle c) { /* 导出圆的 XML */ }
    public void visit(Square s) { /* 导出方的 XML */ }
}

常见误区

  • 元素类型频繁变化还用访问者:加一个元素要改所有 visitor 接口和实现,代价远大于直接 if/else。
  • 访问者突破元素封装:visit 应通过元素暴露的只读接口操作,不直接拿私有字段。
  • 以为访问者是「万能解耦」:它的解耦是有方向的,选错方向反而更难维护。

追问

  • 双重分派和普通单分派的区别?答:普通 OOP 只按接收者类型分派(一次),访问者结合元素类型与 visitor 类型两次分派。
  • 编译器 AST 为什么常用访问者?答:AST 节点类型(类、方法、表达式)相对稳定,而操作(类型检查、代码生成、格式化)频繁新增,正好匹配访问者的方向。

01.3.2.12-014 访问者在现代语言里还必要吗?哪些 GoF 模式已退化为语言特性?

一句话结论

在有模式匹配(pattern matching)的语言里,访问者的大量场景已被语言特性吸收:Rust 的 match、TypeScript 的类型守卫、C# 的 switch 类型模式、Scala 的模式匹配都能更简洁地完成「按类型分发操作」;GoF 23 个模式中,迭代器、单例、命令、状态、装饰器等都已被语言特性大幅替代。

概念解释

  • 模式匹配:语言级的「按类型/形状分发」,不需要写 visitor 类层次。
  • 退化模式:迭代器(for-each/generator)、单例(模块/枚举/object)、命令(一等函数/lambda)、状态(enum + 状态机库)、装饰器(注解/闭包/@decorator)。
  • 仍有价值的模式:策略、观察者、中介者、备忘录、工厂、代理——这些是「架构决策」,不是语法糖能替代的。

原理流程

  1. 先判断问题是「语法层面」还是「架构层面」。
  2. 语法层面的遍历、单例、简单包装,优先用语言特性。
  3. 架构层面的职责拆分、解耦、扩展点,仍需要显式模式。
  4. 访问者在「元素类型也频繁变化」的项目里基本被模式匹配替代。

代码或图示

// Rust:模式匹配替代访问者
enum Shape {
    Circle(f64),
    Square(f64),
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Square(s) => s * s,
    }
}
// TypeScript:类型守卫 + switch 替代 visitor
type Shape = { kind: "circle"; r: number } | { kind: "square"; s: number };

function area(shape: Shape): number {
    switch (shape.kind) {
        case "circle": return Math.PI * shape.r * shape.r;
        case "square": return shape.s * shape.s;
    }
}
退化清单:
迭代器   → for-each / generator / Iterator trait
单例     → 模块 / enum / object / OnceLock
命令     → 一等函数 / lambda / delegate
状态     → enum + 状态机 / match
装饰器   → 注解 / 闭包 / @decorator
访问者   → 模式匹配 / sum type

常见误区

  • 以为「语言特性替代了模式」等于「模式没用了」:替代的是机械实现,模式的「意图」仍然是设计词汇。
  • 在没有模式匹配的语言(Java 8/Go)里硬上访问者:Java 17+ 的 sealed class + pattern matching 已大幅简化,Go 则用接口 + type switch。
  • 用模式匹配就忽视了「开闭方向」:match 对「新增元素」封闭(要加分支),对「新增操作」开放(新写一个 match 函数)——和访问者方向相同,只是语法更轻。

追问

  • Go 没有模式匹配,访问者还有价值吗?答:Go 用接口 + type switch 达到类似效果,但新增类型要改所有 switch;如果元素类型稳定,type switch 比 visitor 类层次更轻。
  • 为什么面试还在考这些「已退化」的模式?答:考察的是「什么时候该用、什么时候语言特性就够了」,而不是手写类层次。

跨语言差异对照

语言 惯用实现 差异要点
Java Iterable/Iterator + fail-fast for-each 语法糖;modCount 并发修改检测;ListIterator 双向
Go 手写 Next() 闭包;range 原生只支持切片/map/通道 无内建迭代器接口;range-over-func 为较新特性(待确认)
Python __iter__/__next__ 协议;生成器函数 生成器是语言级迭代器;惰性;只能走一次
TypeScript/JS Symbol.iterator 协议;function* 生成器 协议由 symbol 定义;可迭代对象无处不在;for...of
Rust Iterator trait;适配器链 + 消费者 惰性求值;零成本抽象;借用规则禁止遍历时修改
C#/.NET IEnumerable&lt;T&gt;;yield return 编译器生成状态机;延迟执行;IAsyncEnumerable 异步版
PHP Iterator 接口;Generator + yield foreach 原生支持;Generator 是协程雏形;只能走一次

跨语言差异

  • Java 是唯一把「并发修改检测」做成迭代器内建行为的语言(fail-fast),其他语言要么靠借用规则(Rust),要么靠约定(Python/JS)。
  • Go 没有内建迭代器协议,惯用闭包 Next(),这是「接口最小化」哲学的体现;range-over-func 若稳定将改变这一格局,需以实际工具链版本验证。
  • Rust 把迭代器做成 trait + 适配器链,编译期优化成手写循环,是「零成本抽象」的代表。
  • Python、TypeScript、PHP 都把生成器(yield)作为迭代器的语法糖,惰性求值是共同特征。
  • C# 的 yield 是编译器状态机,与 IAsyncEnumerable 一脉相承,是 .NET 异步流式处理的基础。
  • 访问者在现代语言里普遍被模式匹配、sealed class、sum type 替代,手写 visitor 类层次越来越少。

待整理清单

  • [ ] 验证 Go range-over-func 在当前工具链的稳定状态与签名
  • [ ] 补充 C++ STL 迭代器失效规则与 Rust 借用规则的对照
  • [ ] 补充各语言迭代器在大数据量下的性能基准(本机实测后填入)
  • [ ] 补充 RxJS / Observables 与迭代器的拉推模式对比