设计模式学习篇-迭代器模式

迭代器模式 (Iterator Pattern)

概念： 迭代器模式是一种行为型设计模式，它允许顺序访问集合对象中的元素，而无需暴露集合对象的内部结构。通过迭代器模式，客户端可以通过统一的接口依次访问集合中的元素，不必关心集合的具体实现（如数组、链表等）。这一模式常用于需要遍历某些数据结构（例如数组、列表等）并执行相应操作的场景。

为什么使用迭代器模式：

1. 统一接口： 提供一个一致的访问方式，使得不同集合的数据能够通过相同的接口进行遍历。
2. 解耦： 迭代器模式将集合的实现与遍历集合的逻辑解耦，使得遍历操作不依赖于集合的具体实现。
3. 简化代码： 对集合的遍历可以统一处理，避免不同的数据结构遍历方式重复编写代码。
4. 可扩展性： 通过实现不同的迭代器，可以使得集合结构的变化不会影响客户端代码的编写。

游戏开发示例：使用迭代器模式

在游戏中，我们可能有多个“游戏对象”集合，比如敌人集合、道具集合等。为了方便统一处理这些集合的遍历，我们可以使用迭代器模式。

示例：通过迭代器模式遍历游戏中的敌人和道具

1. 定义迭代器接口

首先，定义一个迭代器接口，要求实现next()方法和hasNext()方法。

// 迭代器接口
class Iterator {
    next() {}
    hasNext() {}
}

2. 定义集合接口

然后定义一个集合接口，它会返回一个迭代器对象，用于遍历集合。

// 集合接口
class IterableCollection {
    createIterator() {}
}

3. 定义具体的集合类（敌人、道具）

不同类型的游戏对象集合会实现IterableCollection接口，每个集合内部的数据结构可以是不同的，比如数组或链表。

// 游戏中的敌人集合
class EnemyCollection extends IterableCollection {
    constructor() {
        super();
        this.enemies = [];
    }

    addEnemy(enemy) {
        this.enemies.push(enemy);
    }

    createIterator() {
        return new EnemyIterator(this.enemies);
    }
}

// 游戏中的道具集合
class ItemCollection extends IterableCollection {
    constructor() {
        super();
        this.items = [];
    }

    addItem(item) {
        this.items.push(item);
    }

    createIterator() {
        return new ItemIterator(this.items);
    }
}

4. 定义具体的迭代器类

针对每种集合类型，定义具体的迭代器类，实现Iterator接口。

// 敌人迭代器
class EnemyIterator extends Iterator {
    constructor(enemies) {
        super();
        this.enemies = enemies;
        this.index = 0;
    }

    next() {
        return this.enemies[this.index++];
    }

    hasNext() {
        return this.index < this.enemies.length;
    }
}

// 道具迭代器
class ItemIterator extends Iterator {
    constructor(items) {
        super();
        this.items = items;
        this.index = 0;
    }

    next() {
        return this.items[this.index++];
    }

    hasNext() {
        return this.index < this.items.length;
    }
}

5. 客户端代码：统一遍历敌人和道具

最后，在游戏中，我们可以通过统一的迭代器接口遍历敌人和道具，而不需要关心它们的具体数据结构。

// 创建敌人和道具集合
const enemyCollection = new EnemyCollection();
enemyCollection.addEnemy("Goblin");
enemyCollection.addEnemy("Orc");
enemyCollection.addEnemy("Dragon");

const itemCollection = new ItemCollection();
itemCollection.addItem("Sword");
itemCollection.addItem("Shield");
itemCollection.addItem("Potion");

// 获取并使用敌人集合的迭代器
const enemyIterator = enemyCollection.createIterator();
while (enemyIterator.hasNext()) {
    const enemy = enemyIterator.next();
    console.log(`Enemy: ${enemy}`);
}

// 获取并使用道具集合的迭代器
const itemIterator = itemCollection.createIterator();
while (itemIterator.hasNext()) {
    const item = itemIterator.next();
    console.log(`Item: ${item}`);
}

运行结果：

Enemy: Goblin
Enemy: Orc
Enemy: Dragon
Item: Sword
Item: Shield
Item: Potion

总结：

迭代器模式通过为不同的数据结构提供统一的遍历接口，简化了客户端代码的编写，使得客户端能够更专注于业务逻辑的实现，而不需要处理不同集合的具体遍历细节。在游戏开发中，尤其是在需要遍历多个游戏对象集合的场景下，迭代器模式非常适用。