JavaScript设计模式如何实现单例与工厂模式

深入理解JavaScript中的单例模式

单例模式是软件工程中一种经典的设计模式，其核心目标是确保一个类在整个应用程序的全局范围内只有一个唯一的实例，并且为外部提供一个统一的访问入口。在传统的面向对象编程语言中，单例模式通常通过私有化构造函数来实现。然而在JavaScript中，由于语言本身的动态特性以及早期版本缺乏传统的类概念，开发者需要借助其他机制来达成这一目标。单例模式在管理全局状态、共享资源以及避免重复创建开销方面具有不可替代的作用。例如在操作DOM时，我们可能需要一个全局唯一的弹窗管理器，而不是每次触发事件都去创建新的 <div> 元素。

闭包是JavaScript中实现单例模式的一种优雅方式。通过立即执行函数表达式创建一个私有作用域，可以在其中保存唯一的实例引用。外部代码无法直接访问或修改这个私有变量，只能通过暴露出来的公共方法来获取实例。这种方式有效地保护了内部状态，防止了意外的篡改。当首次调用获取实例的方法时，系统会创建该实例并缓存起来；后续的调用则直接返回已缓存的实例，从而保证了全局唯一性。

// 单例模式闭包实现
const Singleton = (function() {
    // 私有变量存储唯一实例
    let instance = null;
    
    // 实际的构造函数，创建实例的逻辑
    function createInstance() {
        const obj = {
            name: '单例实例',
            // 示例方法
            showInfo: function() {
                console.log('当前实例名称：' + this.name);
            }
        };
        return obj;
    }
    
    // 返回获取实例的方法
    return function() {
        // 如果实例不存在则创建
        if (!instance) {
            instance = createInstance();
        }
        // 始终返回同一个实例
        return instance;
    };
})();

// 测试代码
const s1 = Singleton();
const s2 = Singleton();
console.log(s1 === s2); // 输出 true，说明两个引用指向同一个实例
s1.showInfo(); // 输出 当前实例名称：单例实例

除了闭包，利用构造函数的静态属性或者直接使用对象字面量也是实现单例的常见手段。给构造函数添加静态属性来存储实例，这种方式在逻辑上更贴近传统面向对象语言的习惯。在实例化过程中，构造函数会首先检查静态属性上是否已经存在实例，如果存在则直接返回，否则创建新实例并赋值给静态属性。此外，由于JavaScript中的对象字面量在内存中本身就是唯一的引用，对于不需要复杂初始化逻辑的简单场景，直接导出一个对象字面量往往是最直接且高效的单例实现方案。

// 基于静态属性的单例实现
function SingletonClass() {
    // 如果已经存在实例，直接返回
    if (SingletonClass.instance) {
        return SingletonClass.instance;
    }
    // 初始化实例属性
    this.id = Math.random();
    // 保存当前实例到静态属性
    SingletonClass.instance = this;
}

const sc1 = new SingletonClass();
const sc2 = new SingletonClass();
console.log(sc1 === sc2); // 输出 true

// 基于对象字面量的简单单例
const simpleSingleton = {
    data: {},
    setData: function(key, value) {
        this.data[key] = value;
    },
    getData: function(key) {
        return this.data[key];
    }
};

const s3 = simpleSingleton;
const s4 = simpleSingleton;
s3.setData('test', 123);
console.log(s4.getData('test')); // 输出 123

工厂模式在对象创建中的应用

工厂模式是另一种极其重要的创建型设计模式，其核心思想是将对象的创建逻辑进行封装，使得调用者无需关心对象具体的实例化过程。在实际开发中，对象的创建往往伴随着复杂的初始化步骤、依赖注入或是条件判断。如果将这些逻辑散落在业务代码的各个角落，会导致代码高度耦合且难以维护。工厂模式通过提供一个统一的创建接口，调用者只需传入必要的参数，工厂便能返回符合要求的对象实例，从而大幅降低了系统的耦合度。

简单工厂模式是工厂模式中最基础的形态。它通常由一个工厂函数构成，该函数内部包含一个条件分支结构，根据传入的参数类型来决定实例化哪一种具体的产品类。这种方式将对象的创建逻辑集中管理，使得业务代码更加整洁。比如根据配置动态生成 <input> 或是 <select> 表单组件时，简单工厂可以屏蔽底层的DOM操作细节。然而，简单工厂模式也存在明显的局限性：当系统需要引入新的产品类型时，必须修改工厂函数内部的判断逻辑，这违背了面向对象设计中的开闭原则，即对扩展开放，对修改关闭。

// 定义不同的产品类
function ProductA() {
    this.name = '产品A';
    this.getPrice = function() {
        return 100;
    };
}

function ProductB() {
    this.name = '产品B';
    this.getPrice = function() {
        return 200;
    };
}

// 简单工厂函数
function ProductFactory(type) {
    switch(type) {
        case 'A':
            return new ProductA();
        case 'B':
            return new ProductB();
        default:
            throw new Error('不支持的产品类型');
    }
}

// 测试代码
const p1 = ProductFactory('A');
const p2 = ProductFactory('B');
console.log(p1.name); // 输出 产品A
console.log(p2.getPrice()); // 输出 200

为了解决简单工厂模式违反开闭原则的问题，工厂方法模式应运而生。工厂方法模式不再使用一个统一的工厂函数来处理所有产品的创建，而是定义了一个创建对象的抽象接口，并将具体的实例化逻辑延迟到子类中实现。这意味着每一个具体的产品类都有其对应的具体工厂类。当需要新增产品类型时，开发者只需创建新的产品类及其对应的工厂类即可，完全无需修改现有的工厂代码。这种设计极大地提升了系统的可扩展性和灵活性，非常适合产品线不断演进的复杂业务场景。

// 抽象工厂基类
function Factory() {}
Factory.prototype.createProduct = function() {
    throw new Error('子类需要实现createProduct方法');
};

// 产品A的工厂
function FactoryA() {}
FactoryA.prototype = new Factory();
FactoryA.prototype.createProduct = function() {
    return new ProductA();
};

// 产品B的工厂
function FactoryB() {}
FactoryB.prototype = new Factory();
FactoryB.prototype.createProduct = function() {
    return new ProductB();
};

// 测试代码
const fa = new FactoryA();
const productA = fa.createProduct();
console.log(productA.name); // 输出 产品A

const fb = new FactoryB();
const productB = fb.createProduct();
console.log(productB.getPrice()); // 输出 200

设计模式的适用场景与最佳实践

在当下的前端工程化实践中，合理选择和应用设计模式能够显著提升代码的质量与可维护性。单例模式非常适合用于管理那些全局唯一且需要频繁访问的资源。例如，全局状态管理对象、浏览器本地存储的封装、WebSocket连接管理器或是日志记录工具等。在这些场景下，重复创建实例不仅会浪费内存资源，还可能导致状态不一致的问题。不过，使用单例模式时也需保持警惕，过度使用容易导致全局命名空间污染，使得模块之间的依赖关系变得隐晦且难以测试，因此应仅在确有必要时采用。

工厂模式则在处理复杂对象创建逻辑时大放异彩。当系统需要根据不同的运行环境生成不同的适配对象，或者需要根据后端接口返回的数据结构动态生成前端组件时，工厂模式能够提供极大的便利。对于产品类型相对固定且变动不频繁的小型项目，简单工厂模式足以胜任；而对于业务逻辑复杂、产品种类可能频繁扩充的大型系统，工厂方法模式则是更为稳妥的选择。它通过多态性将对象的创建与使用彻底分离，为未来的需求变更留足了空间。

无论是单例模式还是工厂模式，其本质都是为了解决特定场景下的代码组织问题。在实际开发中，开发者不应为了使用设计模式而生搬硬套，而应深入理解业务需求，权衡代码的复杂度与可维护性。JavaScript作为一门多范式的编程语言，为设计模式的实现提供了极大的自由度。通过结合闭包、原型链以及现代的类语法，我们可以编写出既符合设计原则又具备语言特色的优雅代码。掌握这些经典模式的设计思想，将有助于我们在面对复杂业务挑战时，构建出更加健壮、灵活且易于扩展的应用程序架构。

JavaScript单例模式工厂模式设计模式修改时间：2026-06-14 00:39:35