如何在TypeScript/JavaScript中创建非构造返回的特殊类单例实例

核心需求是：创建一个单例对象，不允许通过构造函数（new）生成实例，但该单例可以像类的普通实例一样被调用和引用。以下是几种实用实现方案：

JavaScript 实现方案 #

方案1：原型创建+构造函数拦截 #

直接通过Object.create基于类的原型创建实例，同时禁止构造函数直接生成实例：

class MySingleton {
  constructor() {
    // 拦截直接实例化操作
    throw new Error('请通过 MySingleton.instance 访问单例');
  }

  // 实例方法
  doSomething() {
    console.log('单例方法执行');
  }

  // 实例属性（需手动初始化）
  value = '默认值';
}

// 基于类原型创建单例，绕过构造函数
MySingleton.instance = Object.create(MySingleton.prototype);
// 手动初始化实例属性
Object.assign(MySingleton.instance, { value: '单例专属值' });

// 使用方式
MySingleton.instance.doSomething(); // 输出：单例方法执行
console.log(MySingleton.instance.value); // 输出：单例专属值
// new MySingleton(); // 抛出错误，禁止直接实例化

方案2：闭包封装单例 #

用立即执行函数封装类和单例，避免外部篡改：

const MySingleton = (() => {
  class InnerClass {
    constructor() {
      throw new Error('无法直接实例化');
    }

    greet() {
      console.log(`Hello from ${this.name}`);
    }
  }

  // 创建单例并初始化
  const instance = Object.create(InnerClass.prototype);
  instance.name = 'Singleton Instance';

  // 暴露类和单例
  return Object.assign(InnerClass, { instance });
})();

// 使用
MySingleton.instance.greet(); // 输出：Hello from Singleton Instance

TypeScript 实现方案 #

TS需要兼顾类型安全，利用私有构造函数+类型断言实现：

标准实现 #

class MySingleton {
  // 只读静态属性，确保单例不被篡改
  static readonly instance: MySingleton;

  // 实例属性
  public name: string;

  // 私有构造函数，外部无法通过new创建实例
  private constructor() {
    this.name = '初始值';
  }

  // 实例方法
  public doTask(): void {
    console.log(`单例任务执行：${this.name}`);
  }
}

// 基于原型创建实例，通过类型断言匹配MySingleton类型
MySingleton.instance = Object.create(MySingleton.prototype) as MySingleton;
// 初始化实例属性
MySingleton.instance.name = 'TS单例专属值';

// 使用
MySingleton.instance.doTask(); // 输出：单例任务执行：TS单例专属值
// new MySingleton(); // 编译报错，运行时也会抛出错误

优化：自动初始化实例逻辑 #

如果类的构造函数有复杂初始化逻辑，可以把逻辑抽离成私有方法，在创建单例时手动调用：

class MySingleton {
  static readonly instance: MySingleton;

  private config: Record<string, any>;

  private constructor() {
    this._initConfig();
  }

  private _initConfig(): void {
    this.config = { apiUrl: 'https://example.com' };
  }

  public getConfig(): Record<string, any> {
    return this.config;
  }
}

// 创建单例并调用初始化方法
MySingleton.instance = Object.create(MySingleton.prototype) as MySingleton;
MySingleton.instance._initConfig();

console.log(MySingleton.instance.getConfig()); // 输出：{ apiUrl: 'https://example.com' }

关键原理说明 #

• 原型继承：通过Object.create(Class.prototype)创建的对象，会继承类原型上的所有方法，行为和类的实例完全一致。
• 构造函数拦截：通过抛出错误（JS）或设为私有构造函数（TS），禁止外部通过new创建新实例。
• 静态属性挂载：将单例挂载到类的静态属性上，方便外部以Class.instance的形式引用，符合类实例的使用习惯。

内容的提问来源于stack exchange，提问作者Gurjeet Singh