关于前端:设计模式之享元模式

享元模式是一种结构型设计模式，大家对数据库和缓冲池有理解的同学应该很明确这些都是对享元模式比拟好的利用，所以说享元模式是池技术的重要实现形式。

比方咱们每次创立字符串对象时，都须要创立一个新的字符串对象的话，内存开销就会很大，内存开销也会绝对的变大，所以如果第一次创立了一个对象，下次再应用到雷同构造的对象的时候，只须要把它的援用指向到这个对象上，这样就实现了这个对象在内存中的共享。

比方咱们们要做一个五子棋的有系，如果用户每下一个棋子都要创立一个对象，那么一盘棋下来可能会创立上百个对象，这种应用享元模式再适合不过了，将棋子对象缩小到几个实例。

什么是享元模式

享元模式：是一种软件设计模式。它应用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的类似物件；它适宜用于只是因反复而导致应用无奈令人承受的大量内存的大量物件。通常物件中的局部状态是能够分享。常见做法是把它们放在内部数据结构，当须要应用时再将它们传递给享元。—— 节选自百度百科

享元模式在编辑器软件中大量应用，如在一个文档中屡次呈现雷同的图片，则只须要创立一个图片的对象，通过在利用中设置该图片呈现的地位，能够实现该图片在不同中央多次重复呈现。

享元模式是一个思考零碎性能的设计模式，通过应用享元模式能够节约内存空间，进步零碎的性能。享元模式的外围在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户须要对象时，首先从享元池中获取，如果享元池中不存在，则创立一个新的享元对象返回给用户，并在享元池中保留该新增对象。

因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时咱们就将这些对象的信息分为两个局部：外部状态和内部状态。外部状态指对象共享进去的信息，存储在享元对象外部并且不会随环境的扭转而扭转；内部状态指对象得以依赖的一个标记，是随环境扭转而扭转的、不可共享的状态。

享元模式优缺点

享元模式倡议不在对象中存储外在状态，而是将其传递给依赖于它的一个非凡办法。程序只在对象中保留外在状态，以不便在不同情景下重用。这些对象的区别仅在于其内在状态（与外在状态相比，外在状态的变体要少很多），因而你所需的对象数量会大大削减。

长处

1. 享元模式大大减少了对象的创立，升高了程序内存的占用，提高效率
2. 享元模式的内部状态绝对独立，而且不会影响其外部状态，从而使得享元对象能够在不同的环境中被共享

毛病

1. 进步了零碎复杂性，须要拆散出外部状态和内部填充，并且内部状态具备固化个性，不应该随外部状态扭转，否则会导致系统的逻辑凌乱
2. 执行速度来换取内存，因为别人每次调用享元办法时都须要从新计算局部情景数据，为了使对象能够共享，享元模式须要将享元对象的状态内部化，而读取内部状态使得运行工夫变长

示例

享元模式只是一种优化。在利用该模式之前，你要确定程序中存在与大量相似对象同时占用内存相干的内存耗费问题，并且确保该问题无奈应用其余更好的形式来解决。

享元模式的次要角色如下：

1. 享元：类蕴含原始对象中局部能在多个对象中共享的状态。同一享元对象可在许多不同情景中应用。享元中存储的状态被称为 外在状态 。传递给享元办法的状态被称为 外在状态。
2. 情景：类蕴含原始对象中各不相同的外在状态。情景与享元对象组合在一起就能示意原始对象的全副状态。
3. 客户端：负责计算或存储享元的外在状态。在客户端看来，享元是一种可在运行时进行配置的模板对象，具体的配置形式为向其办法中传入一些情景数据参数。
4. 享元工厂：会对已有享元的缓存池进行治理。有了工厂后，客户端就无需间接创立享元，它们只需调用工厂并向其传递指标享元的一些外在状态即可。工厂会依据参数在之前已创立的享元中进行查找，如果找到满足条件的享元就将其返回；如果没有找到就依据参数新建享元。

通常状况下，原始对象的行为会保留在享元类中。因而调用享元办法必须提供局部外在状态作为参数。但你也可将行为挪动到情景类中，而后将连入的享元作为单纯的数据对象。

类图如下所示：

代码示例：

abstract class Flyweight {public abstract doOperation(extrinsicState : string) : void;
}

class ConcreteFlyweight extends Flyweight {
    private intrinsicState : string;
    constructor(intrinsicState : string) {super();
        this.intrinsicState = intrinsicState;
    }

    public doOperation(extrinsicState : string) : void {console.log(` 这是具体享元角色，外部状态为 ${this.intrinsicState}, 内部状态为 ${extrinsicState}`);
    }
}

interface flyweightObject {[key : string] : Flyweight
}

class FlyweightFactory {
    private flyweights : flyweightObject;
    constructor() {this.flyweights = {};
    }

    public getFlyweight(intrinsicState : string) : Flyweight {if (!this.flyweights[intrinsicState]) {const flyweight : Flyweight = new ConcreteFlyweight(intrinsicState);
            this.flyweights[intrinsicState] = flyweight;
        }
        return this.flyweights[intrinsicState];
    }
}

function main() {const factory : FlyweightFactory = new FlyweightFactory();
    const flyweight1 : Flyweight = factory.getFlyweight("aa");
    const flyweight2 : Flyweight = factory.getFlyweight("aa");
    flyweight1.doOperation('x');
    flyweight2.doOperation('y');
}

main();

总结

如果程序里应用大量雷同或者相似对象，造成内存的耗费过大，且大多都是内部状态，这时候应该思考应用享元模式了。如果你能将对象的所有共享状态简化为一个享元对象，那么享元就和单例模式相似了。但这两个模式有两个根本性的不同。只会有一个单例实体，然而享元类能够有多个实体，各实体的外在状态也能够不同。单例对象能够是可变的。享元对象是不可变的。