JS如何实现享元模式？享元的共享-js教程-PHP中文网

享元模式通过分离内部状态（可共享）与外部状态（不可共享），由享元工厂缓存并复用具有相同内部状态的对象，减少内存开销。如字符对象中字符值、字体、颜色为内部状态，位置、加粗等为外部状态，在文档编辑器、地图标记、粒子系统等大量相似对象场景下有效降低内存占用与渲染开销，避免重复创建对象，提升性能。

js如何实现享元模式？享元的共享

JS实现享元模式，核心在于识别并共享那些重复的、可复用的对象内部状态，从而显著减少内存消耗，尤其是在需要创建大量相似对象时。它通过将对象的状态分为“内部状态”（intrinsic state，可共享）和“外部状态”（extrinsic state，不可共享，由客户端传入或外部存储）来实现这一目标。

解决方案

在JavaScript中实现享元模式，通常会围绕一个“享元工厂”来构建。这个工厂负责管理和提供享元对象实例。当客户端请求一个享元对象时，工厂会检查是否已经存在一个具有相同内部状态的对象。如果存在，就直接返回现有对象；如果不存在，则创建一个新的享元对象并将其缓存起来，然后返回。

以下是一个简化的代码示例，假设我们正在为一个在线文档编辑器管理字符对象。每个字符（如'A', 'B', 'c'等）都有其固定的字形、颜色等内部属性，而其在文档中的位置、是否加粗等是外部属性。

// 享元对象：字符
class CharacterFlyweight {
    constructor(charValue, font, color) {
        this.charValue = charValue; // 内部状态：字符本身
        this.font = font;           // 内部状态：字体
        this.color = color;         // 内部状态：颜色
        // 理论上，这些内部状态在创建后不应改变
    }

    // 显示方法，需要外部状态（如位置、大小、是否加粗）
    display(x, y, isBold) {
        console.log(`显示字符：'${this.charValue}'，字体：${this.font}，颜色：${this.color}，位置：(${x}, ${y})，加粗：${isBold}`);
        // 实际渲染逻辑
    }
}

// 享元工厂
class CharacterFactory {
    constructor() {
        this.characters = {}; // 缓存享元对象
    }

    getCharacter(charValue, font, color) {
        const key = `${charValue}-${font}-${color}`; // 使用内部状态作为缓存键

        if (!this.characters[key]) {
            console.log(`创建新的享元对象：${key}`);
            this.characters[key] = new CharacterFlyweight(charValue, font, color);
        } else {
            console.log(`复用现有享元对象：${key}`);
        }
        return this.characters[key];
    }

    getCharacterCount() {
        return Object.keys(this.characters).length;
    }
}

// 客户端使用
const factory = new CharacterFactory();

// 模拟文档内容
const documentContent = [
    { char: 'H', x: 10, y: 10, isBold: true },
    { char: 'e', x: 20, y: 10, isBold: true },
    { char: 'l', x: 30, y: 10, isBold: true },
    { char: 'l', x: 40, y: 10, isBold: true },
    { char: 'o', x: 50, y: 10, isBold: true },
    { char: ' ', x: 60, y: 10, isBold: false },
    { char: 'W', x: 70, y: 10, isBold: false },
    { char: 'o', x: 80, y: 10, isBold: false },
    { char: 'r', x: 90, y: 10, isBold: false },
    { char: 'l', x: 100, y: 10, isBold: false },
    { char: 'd', x: 110, y: 10, isBold: false },
    { char: '!', x: 120, y: 10, isBold: false },
    { char: 'H', x: 10, y: 20, isBold: false }, // 另一个 'H'，但字体和颜色可能不同
    { char: 'e', x: 20, y: 20, isBold: false },
];

const defaultFont = 'Arial';
const defaultColor = 'black';

documentContent.forEach(item => {
    // 假设所有字符默认使用相同字体和颜色，除非有特殊指定
    const charObj = factory.getCharacter(item.char, defaultFont, defaultColor);
    charObj.display(item.x, item.y, item.isBold);
});

console.log(`实际创建的享元对象数量：${factory.getCharacterCount()}`);
// 理论上，这里创建的对象数量会远小于文档字符总数，因为 'l', 'o', 'H', 'e' 等字符被复用了。

登录后复制

享元模式在前端开发中有哪些应用场景？它能解决哪些性能痛点？

坦白说，享元模式在前端领域，尤其是当你的应用需要渲染大量相似但又不完全相同的UI元素时，简直是性能优化的“救星”。我第一次真正感受到它的威力，是在处理一个包含成千上万个地图标记点（markers）的项目时。每个标记点都有自己的位置，但它们的图标、基础行为却是一样的。如果为每个标记点都创建一个完整的DOM元素或JavaScript对象，那内存占用和渲染性能简直是灾难。

它主要解决了以下几个痛点：

内存消耗过大： 这是最直接的。想象一下，如果你有10000个按钮，它们都长得一样，只是位置和上面的文本不同。如果没有享元，你可能会创建10000个独立的按钮对象，每个对象都带着一套完整的样式、事件处理函数等。享元模式允许你只创建少数几种“按钮原型”（享元），然后通过外部数据来区分它们，大大减少了内存占用。
渲染性能瓶颈： 大量对象的创建和销毁本身就是耗时操作。DOM操作更是如此。通过复用对象，减少了垃圾回收的压力，也降低了浏览器需要处理的独立元素数量，从而提升了渲染效率。
重复代码和冗余逻辑： 享元模式促使你将对象的内部状态和外部状态分离，这本身就是一种代码组织的优化。那些可以共享的逻辑和数据被集中管理，避免了在每个独立对象中重复定义。

常见的应用场景包括：

大型表格或列表渲染： 比如虚拟滚动列表，虽然视图中只显示几十条，但背后可能有成千上万条数据。每一行或每一个单元格的DOM元素都可以是享元，只有内容是外部状态。
游戏开发中的粒子系统或大量实体： 比如雨滴、雪花、子弹等，它们可能数量庞大，但很多属性是相同的。
文本编辑器或代码编辑器： 字符、单词、行等，很多基础属性（字体、大小、颜色）是共享的，只有位置、内容是独立的。
地图应用中的标记点/图标： 大量的POI（兴趣点）图标，虽然位置不同，但图标图片、点击行为等是相同的。
UI组件库： 比如一个按钮组件，它的基本样式和行为是固定的，只有文本、是否禁用等是变化的。

享元模式中的“内部状态”与“外部状态”如何区分与管理？有哪些常见的错误理解？

区分内部状态和外部状态是实现享元模式的关键，也是很多人初次接触时容易混淆的地方。我的经验是，思考“什么是不变的？”和“什么是每次使用都会变的？”

内部状态（Intrinsic State）：

Picsart AI Image Generator
Picsart推出的AI图片生成器

37

查看详情
- 定义： 那些在享元对象创建后，其值保持不变，并且可以在多个享元对象实例之间共享的状态。它独立于享元对象的上下文。
- 特点： 它是享元对象固有的、不变的属性，是构成享元对象“类型”的关键。
- 管理： 内部状态通常作为享元对象的构造函数参数传入，并在享元工厂中作为缓存的键。一旦创建，就不应该被外部修改。如果内部状态需要修改，那意味着你需要一个新的享元对象，或者你可能错误地将外部状态视为内部状态。
外部状态（Extrinsic State）：
- 定义： 那些在享元对象每次被使用时，其值可能发生变化，并且不能在多个享元对象实例之间共享的状态。它依赖于享元对象的上下文。
- 特点： 它不是享元对象本身的属性，而是在享元对象被操作或显示时，由客户端代码传入的参数。
- 管理： 外部状态不存储在享元对象内部。它通常作为享元对象方法（如
```
display
```
  登录后复制
  、
```
operate
```
  登录后复制
  ）的参数传入。客户端代码负责管理这些外部状态。

常见的错误理解：

将外部状态误认为是内部状态： 这是最常见的错误。比如在上面的字符例子中，如果你把
```
x
```
登录后复制
、
```
y
```
登录后复制
（位置）也作为
```
CharacterFlyweight
```
登录后复制
的属性，那么每次字符位置不同，你就需要创建一个新的
```
CharacterFlyweight
```
登录后复制
实例，这完全违背了享元模式的初衷，因为你无法共享了。正确做法是
```
x
```
登录后复制
、
```
y
```
登录后复制
作为
```
display
```
登录后复制
方法的参数。
修改享元对象的内部状态： 如果你创建了一个享元对象，然后允许外部代码直接修改它的内部状态（比如
```
charObj.font = 'NewFont'
```
登录后复制
），那么这个享元对象就不再是“共享”的了，因为它被“污染”了。其他复用这个享元对象的客户端就会受到影响，导致不可预测的行为。内部状态应该是只读的。
过度优化或误用： 享元模式并非适用于所有场景。如果你的对象数量不多，或者对象之间的重复性不高，引入享元模式反而会增加代码的复杂性，而带来的性能提升微乎其微。我见过一些项目，为了“设计模式而设计模式”，在不必要的地方强行引入享元，结果增加了调试难度。

在JavaScript中实现享元模式时有哪些常见陷阱和最佳实践？

虽然享元模式很强大，但在JS环境中实现它，确实有一些需要注意的地方，特别是和JS的动态特性结合时。

常见陷阱：

缓存键的复杂性： 享元工厂需要一个唯一的键来识别和检索享元对象。如果内部状态组合复杂，生成一个稳定、唯一的键会变得棘手。比如，如果你的内部状态包含对象或数组，直接用它们作为键会出问题（因为对象比较的是引用）。你需要一套可靠的序列化机制来生成键，比如JSON.stringify，但这又可能带来性能开销。
垃圾回收问题： 享元工厂通常会一直持有享元对象的引用。这意味着，即使某个享元对象在业务上已经不再需要，它也可能因为被工厂缓存而无法被垃圾回收，导致内存泄漏。对于那些生命周期有限的享元（比如临时性的UI元素），这会是个问题。在一些高级场景，你可能需要考虑使用
```
WeakMap
```
登录后复制
来作为缓存，但
```
WeakMap
```
登录后复制
的键只能是对象，并且不能直接遍历，这又增加了管理复杂性。
状态隔离的挑战： 虽然我们强调内部状态不可变，但JS的灵活性有时会诱惑你打破这个规则。不小心修改了共享的内部状态，会导致所有使用该享元对象的客户端都受到影响，这绝对是灾难性的bug，而且很难追溯。
调试难度增加： 由于对象是共享的，当一个bug出现时，你可能需要花更多时间去判断是外部状态导致的问题，还是共享的内部状态被意外修改了。

最佳实践：

明确内部状态和外部状态的边界： 在设计之初，花时间仔细分析哪些属性是固定的、可共享的，哪些是变化的、上下文相关的。这是享元模式成功的基础。
享元对象内部状态不可变： 一旦享元对象被创建，其内部状态就不应被修改。这可以通过在构造函数中设置属性后，不提供setter方法，或者使用
```
Object.freeze()
```
登录后复制
（在某些情况下）来强制实现。
使用工厂模式管理享元对象： 将享元对象的创建和管理逻辑封装在享元工厂中，对外只暴露一个获取享元对象的接口。这不仅实现了职责分离，也保证了享元对象的唯一性。
缓存键的设计： 确保缓存键能够唯一且稳定地代表一组内部状态。对于复杂类型，考虑使用确定性的序列化方法。
性能考量： 享元模式是为了优化性能而生，但在引入之前，最好先进行性能分析，确认内存或渲染确实是瓶颈。不要盲目应用，因为引入它会增加一定的代码复杂性。
文档和注释： 由于享元模式涉及状态分离和共享，代码可能会变得不那么直观。清晰的文档和注释对于解释内部状态和外部状态的职责至关重要。