JS 结构型模式

时间:2022-09-28 天行无忌人气:0

前言

本文将对 20 多种 JavaScript 设计模式进行简单概述，然后结合 ES6 类的方式来编写实例代码展示其使用方式。

JavaScript 在现代前端中扮演重要的角色，相比过去能够做的事情已经不在一个级别上了。JavaScript 最大的特征是其灵活性，一般只要敢想敢写，可以把程序写得很简单，有可以写得很复杂。其灵活性导致编写 JavaScript 的时候能够不断的优化，能够不断质疑写的质量。而设计模式，是不分编程语言的，是软件工程的内容，JavaScript 强大的表现力赋予了开发者运用设计模式编写代码时创造性。

设计模式系列文章：

ES6 类聊 JavaScript 设计模式之创建型模式

什么是设计模式？

设计模式是软件设计中常见问题的解决方案，这些模式很容易重复使用并且富有表现力。

在软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。它并不直接用来完成代码的编写，而是描述在各种不同情况下，要怎么解决问题的一种方案。面向对象设计模式通常以类别或对象来描述其中的关系和相互作用，但不涉及用来完成应用程序的特定类别或对象。—— 维基百科

在 JavaScript 中使用设计模式主要有以下原因：

可维护性：设计模式有助于降低模块间的耦合程度。
沟通：设计模式为处理不同类型的对象提供了一套通用的术语。
性能：对代码起到优化作用，提高程序的运行速度。当然不是所有的设计模式都能够改善性能。

有三种模式：创建型模式，结构型模式、行为型模式。

创建型模式：解决与创建对象相关的问题。
结构型模式：处理实体之间的关系，以及它们如何共同组成一个更大的结构。
行为型模式：处理对象如何相互通信和交互。

结构型设计模式

结构型设计模式涉及类和对象组合，使用继承来组合接口。

在软件工程中，结构设计模式是通过识别实现实体之间关系的简单方法来简化设计的设计模式。

适配器模式
桥接模式
组合模式
装饰者模式
门面模式
享元模式
代理模式

适配器模式

适配器模式允许具有不兼容接口的类通过将它们自己的接口封装在现有类周围来一起工作。适配器也称为包装器（wrapper），用来把不匹配的接口替换为一个可用于现有系统中的接口。

在软件工程中，适配器模式是一种软件设计模式，它允许将现有类的接口用作另一个接口。它通常用于使现有类在不修改其源代码的情况下与其他类一起使用。

实例

实例将通过一个计算器的例子进行改造。 Calculator1 是旧接口，Calculator2 是新接口。将构建一个适配器，它将包装新接口并使用其新方法为其提供结果。

class Calculator1 {
    constructor() {
        this.operations = function (value1, value2, operation) {
            const operationHandler = {
                add: () => value1 + value2,
                sub: () => value1 - value2,
            };
            return (
                typeof (operationHandler[operation] === "function") &&
                operationHandler[operation]()
            );
        };
    }
}
class Calculator2 {
    constructor() {
        this.add = function (value1, value2) {
            return value1 + value2;
        };
        this.sub = function (value1, value2) {
            return value1 - value2;
        };
    }
}
// 使用适配器模式构建类
class CalcAdapter {
    constructor() {
        const cal2 = new Calculator2();
        this.operations = function (value1, value2, operation) {
            return (
                typeof (cal2[operation] === "function") &&
                cal2[operation](value1, value2)
            );
        };
    }
}
const adaptedCalc = new CalcAdapter();
console.log(adaptedCalc.operations(30, 25, "sub")); // 5

桥接模式

桥接模式将抽象与实现分开，以便两者可以独立变化。是一种既能把两个对象连接在一起，又能避免二者间的强耦合的方法。

桥接模式是一种结构化设计模式，它允许将一个大类或一组密切相关的类拆分为两个独立的层次结构：抽象和实现，它们可以相互独立地开发。—— 维基百科

实例

将创建渲染器类来渲染多个形状。

class VectorRenderer {
    renderCircle(radius) {
        console.log(`渲染一个半径为 ${radius} 的圆`);
    }
}
class RasterRenderer {
    renderCircle(radius) {
        console.log(`绘制一个半径为 ${radius} 的像素圆`);
    }
}
class Shape {
    constructor(renderer) {
        this.renderer = renderer;
    }
}
class Circle extends Shape {
    constructor(renderer, radius) {
        super(renderer);
        this.radius = radius;
    }

    draw() {
        this.renderer.renderCircle(this.radius);
    }
    resize(factor) {
        this.radius *= factor;
    }
}
const raster = new RasterRenderer();
const vector = new VectorRenderer();
const circle = new Circle(vector, 5);
const rasterCircle = new Circle(raster, 5);
circle.draw();
circle.resize(2);
circle.draw();
rasterCircle.draw();
rasterCircle.resize(2);
rasterCircle.draw();

组合模式

组合模式组合对象，以便可以将它们作为单个对象进行操作，非常适合用于创建WEB上的动态用户界面。

组合模式描述了一组对象，这些对象的处理方式与相同类型对象的单个实例相同。—— 维基百科

实例

将使用工作示例：

class Employer {
    constructor(name, role) {
        this.name = name;
        this.role = role;
    }
    print() {
        const { name } = this;
        console.log(`姓名：${name}`);
    }
}
class EmplyerGroup {
    constructor(name, composite = []) {
        console.log(name);
        this.name = name;
        this.composite = composite;
    }
    print() {
        console.log(this.name);
        this.composite.forEach((emp) => {
            emp.print();
        });
    }
}
const ravi = new Employer("ravi", "developer");
const bhavy = new Employer("bhavy", "developer");
const groupDevelopers = new EmplyerGroup("Developer", [ravi, bhavy]);
groupDevelopers.print();

装饰者模式

装饰者模式动态地添加或覆盖对象的行为，用于把对象透明的包装到另一个种具有相同接口的对象中。

装饰器模式是一种设计模式，它允许将行为动态地添加到单个对象，而不会影响同一类中其他对象的行为。

实例

将以颜色和形状为例，如果必须画一个圆，将创建方法并画一个圆。如果要画一个红色的圆圈，将行为被添加到一个对象中，装饰器模式将帮助实现。

class Shape {
    constructor(color = "") {
        this.color = color;
    }
}
class Circle extends Shape {
    constructor(radius = 0) {
        super();
        this.radius = radius;
    }
    resize(factor) {
        this.radius *= factor;
    }
    toString() {
        return `一个直径为 ${this.radius} 的园`;
    }
}
class ColoredShape extends Shape {
    constructor(shape, color) {
        super();
        this.shape = shape;
        this.color = color;
    }
    toString() {
        return `${this.shape.toString()}，颜色为${this.color}`;
    }
}
const circle = new Circle(2);
console.log(circle); // Circle { color: '', radius: 2 }
const redCircle = new ColoredShape(circle, "红色");
console.log(redCircle.toString()); // 一个直径为 2 的园，颜色为红色

门面模式

门面模式为复杂代码提供了一个简化的接口，可以用来把现有接口转换为一个更便于使用的接口。

门面模式是面向对象编程中常用的一种软件设计模式。与架构中的外观类似，外观是一个对象，它充当前端接口，掩盖更复杂的底层或结构代码。 —— 维基百科

实例

举一个客户端与计算机交互的例子：

class CPU {
    freeze() {
        console.log("冻结…");
    }

    jump() {
        console.log("跳过…");
    }

    execute() {
        console.log("执行…");
    }
}
class Memory {
    load(position, data) {
        console.log("加载中…");
    }
}
class HardDrive {
    read(lba, size) {
        console.log("读取中…");
    }
}
class ComputerFacade {
    constructor() {
        this.processor = new CPU();
        this.ram = new Memory();
        this.hd = new HardDrive();
    }
    start() {
        this.processor.freeze();
        this.ram.load("", this.hd.read("lba", "size"));
        this.processor.jump("");
        this.processor.execute();
    }
}
const computer = new ComputerFacade();
computer.start();

享元模式

享元模式降低了创建类似对象的内存成本，是一种可以用于优化目的的设计模式。最适合用于解决因创建大量类似对象而累及性能的问题。

享元是一种通过与其他类似对象共享尽可能多的数据来最小化内存使用的对象。—— 维基百科

实例

以用户为例，让有多个同名的用户，可以通过存储一个名称来节省内存，并将其引用给具有相同名称的用户。

class User {
    constructor(fullname) {
        this.fullname = fullname;
    }
}
class User2 {
    constructor(fullname) {
        const getOrAdd = (s) => {
            const idx = User2.strings.indexOf(s);
            if (idx !== -1) {
                return idx;
            } else {
                User2.strings.push(s);
                return User2.strings.length - 1;
            }
        };
        this.names = fullname.split(" ").map(getOrAdd);
    }
}
User2.strings = [];
const getRadmon = (max) => Math.floor(Math.random() * Math.floor(max));
const randomString = () => {
    const result = [];
    for (let x = 0; x < 10; ++x) {
        result.push(String.fromCharCode(65 + getRadmon(26)));
    }
    return result.join("");
};

现在将通过创建 10k 个用户来进行不使用享元模式和使用享元模式的占用字符大小来类比内存大小。

const users = [];
const users2 = [];
const firstnames = [];
const lastnames = [];
for (let i = 0; i < 100; ++i) {
    firstnames.push(randomString());
    lastnames.push(randomString());
}
for (const first of firstnames) {
    for (const last of lastnames) {
        users.push(new User(`${first} ${last}`));
        users2.push(new User2(`${first} ${last}`));
    }
}
console.log(`10k用户占用了大约 ${JSON.stringify(users).length} 字符`); // 10k用户占用了大约 370001 字符
const user2length = [users2, User2.strings]
    .map((x) => JSON.stringify(x).length)
    .reduce((x, y) => x + y);
console.log(`10k用户在享元模式占用约 ${user2length} 字符`); // 10k用户在享元模式占用约 191602 字符

代理模式

通过使用代理，一个类可以代表另一个类的功能。更加详细的介绍，可以参阅《JavaScript 设计模式之代理模式》

代理模式是一种软件设计模式。代理，在其最一般的形式中，是一个作为与其他事物的接口的类。—— 维基百科

实例

以价值代理作为实例。

class Percentage {
    constructor(percent) {
        this.percent = percent;
    }
    toString() {
        return `${this.percent}%`;
    }
    valueOf() {
        return this.percent / 100;
    }
}
const fivePercent = new Percentage(5);
console.log(fivePercent.toString()); // 5%
console.log(`5% 的50倍是${50 * fivePercent}`); // 5% 的50倍是2.5

加载全部内容