单例模式是JavaScript设计模式中最基础也最常用的一种，它的核心目标是确保某个类在整个应用生命周期中只存在一个实例，并且提供一个全局的访问入口，避免重复创建实例造成的内存和资源浪费。这种模式在全局配置管理、缓存对象、数据库连接池等场景中有着广泛的应用。
单例模式的核心作用
单例模式主要有三个核心作用，首先是控制实例数量，避免无意义的重复创建，减少内存占用。其次是提供全局唯一的访问点，方便在应用的各个模块中共享同一个实例的状态和方法。最后是封装实例的创建逻辑，外部不需要关心实例是如何生成的，只需要通过统一的接口获取即可。
常见的单例模式实现方式
1. 基于闭包的实现方式
闭包是JavaScript中实现单例模式的经典方式，利用闭包可以保存私有变量的特性，把唯一的实例保存在闭包内部，外部无法直接修改。
// 闭包实现单例模式
const Singleton = (function() {
// 私有变量，保存唯一实例
let instance = null;
// 定义单例的构造函数
function SingletonConstructor(name) {
// 如果已经存在实例，直接返回
if (instance) {
return instance;
}
// 初始化实例属性
this.name = name;
this.data = [];
// 保存当前实例
instance = this;
}
// 添加实例方法
SingletonConstructor.prototype.addData = function(item) {
this.data.push(item);
};
SingletonConstructor.prototype.getData = function() {
return this.data;
};
// 返回获取实例的静态方法
return function(name) {
if (!instance) {
instance = new SingletonConstructor(name);
}
return instance;
};
})();
// 测试代码
const s1 = Singleton('实例1');
const s2 = Singleton('实例2');
s1.addData('测试数据');
console.log(s1 === s2); // 输出 true，两个引用指向同一个实例
console.log(s2.getData()); // 输出 ["测试数据"]
console.log(s2.name); // 输出 实例1，第二次创建时不会覆盖原有实例的属性
2. 基于ES6类的实现方式
ES6引入class语法之后，我们可以用更符合面向对象的方式实现单例模式，通过类的静态属性保存唯一实例，静态方法提供访问入口。
// ES6类实现单例模式
class SingletonClass {
constructor(name) {
// 如果已经存在实例，直接返回已有实例
if (SingletonClass.instance) {
return SingletonClass.instance;
}
this.name = name;
this.cache = {};
// 保存当前实例到静态属性
SingletonClass.instance = this;
}
// 静态方法，获取唯一实例
static getInstance(name) {
if (!SingletonClass.instance) {
SingletonClass.instance = new SingletonClass(name);
}
return SingletonClass.instance;
}
setCache(key, value) {
this.cache[key] = value;
}
getCache(key) {
return this.cache[key];
}
}
// 测试代码
const sc1 = SingletonClass.getInstance('类实例1');
const sc2 = SingletonClass.getInstance('类实例2');
sc1.setCache('id', 1001);
console.log(sc1 === sc2); // 输出 true
console.log(sc2.getCache('id')); // 输出 1001
3. 惰性单例实现方式
惰性单例指的是实例只有在第一次被需要的时候才会创建，而不是在页面加载时就初始化，这种方式可以减少初始加载的开销，适合实例创建成本比较高的场景。
// 惰性单例实现，以全局弹窗为例
const createModal = (function() {
let modalInstance = null;
// 创建弹窗的函数
function initModal() {
const modal = document.createElement('div');
modal.innerHTML = '我是全局唯一的弹窗';
modal.style.cssText = 'position:fixed;top:50%;left:50%;transform:translate(-50%,-50%);padding:20px;background:#fff;border:1px solid #ccc;';
modal.style.display = 'none';
document.body.appendChild(modal);
return modal;
}
return function() {
// 第一次调用时才创建弹窗实例
if (!modalInstance) {
modalInstance = initModal();
}
return modalInstance;
};
})();
// 使用弹窗
const modal1 = createModal();
const modal2 = createModal();
modal1.style.display = 'block';
console.log(modal1 === modal2); // 输出 true，两次获取的是同一个弹窗实例
不同实现方式的对比
我们可以通过下面的表格对比三种实现方式的特点：
| 实现方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 闭包实现 | 私有变量封装性好，实例创建逻辑隐蔽 | 代码相对复杂，调试时不容易查看内部状态 | 需要严格封装实例创建逻辑的场景 |
| ES6类实现 | 语法清晰，符合面向对象习惯，易维护 | 静态属性可以被外部修改，封装性稍弱 | 现代JavaScript项目，习惯使用class语法的场景 |
| 惰性单例 | 按需创建，减少初始加载开销 | 需要额外的判断逻辑，实现稍复杂 | 实例创建成本高，不一定每次都会用到的场景 |
单例模式的注意事项
在使用单例模式的时候需要注意几个问题，首先单例模式虽然方便共享状态，但过度使用会导致代码的耦合度升高，因为全局都可以访问单例，修改单例的状态可能会影响其他依赖它的模块。其次如果单例实例持有大量数据或者资源，需要注意在不需要的时候是否需要做清理，避免内存泄漏。最后在多线程环境（比如Node.js的工作线程）中，单例模式的实例可能不是跨线程唯一的，需要根据具体场景做适配。
JavaScript单例模式设计模式闭包修改时间：2026-07-12 12:27:26