如何避免JS/TypeScript带初始化函数的单例空值检查

针对你的需求，我们可以通过拆分类型+统一断言函数的方式解决重复检查、!操作符的问题，同时保留method2在初始化前的可用性，无需强制改用类（也提供类实现的优化方案供选择）。

核心思路 #

• 拆分未初始化/已初始化两种状态的类型，让TypeScript自动推导状态，彻底告别!操作符
• 封装统一的初始化检查断言函数，替代每个方法里的重复判断逻辑
• 保持单例结构，不影响method2的提前调用能力

优化后的对象式实现 #

// 定义已初始化的核心属性类型
interface InitializedStuffCore {
  x: string;
  y: string;
  z: string;
  fn: () => void;
}

// 未初始化状态：仅标记初始化状态
interface UninitializedStuff {
  isInit: false;
}

// 已初始化状态：合并核心属性与初始化标记
type InitializedStuff = InitializedStuffCore & {
  isInit: true;
};

// 内部状态为两种类型的联合
let _stuff: UninitializedStuff | InitializedStuff = {
  isInit: false,
};

// 统一的初始化检查断言函数：未初始化则抛出错误，同时断言为已初始化类型
function assertInitialized(): asserts _stuff is InitializedStuff {
  if (!_stuff.isInit) {
    throw new Error('not init');
  }
}

const isReady = () => _stuff.isInit;

const init = (x: string, y: string, z: string, fn: () => void) => {
  if (_stuff.isInit) return;
  // 初始化后直接切换为已初始化类型
  _stuff = {
    x,
    y,
    z,
    fn,
    isInit: true,
  };
};

const method1 = () => {
  assertInitialized();
  // 此处_stuff已被断言为InitializedStuff，所有属性均为非可选，无需!
  _stuff.fn();
  _stuff.x;
  _stuff.y;
  _stuff.z;
};

// 其他依赖初始化的方法只需调用断言函数即可
const method3 = () => {
  assertInitialized();
  console.log(_stuff.x.toUpperCase());
};

const method2 = () => {
  // 不依赖任何初始化属性，可随时调用
  console.log('method2 executed before init');
};

export const Stuff = {
  init,
  isReady,
  method1,
  method2,
  method3,
};

// 测试逻辑
Stuff.method2(); // 正常执行
// Stuff.method1(); // 抛出错误：not init
Stuff.init('x', 'y', 'z', () => console.log('init done'));
Stuff.method1(); // 正常执行
Stuff.method3(); // 正常执行

方案优势 #

1. 消除重复代码：所有依赖初始化的方法只需调用assertInitialized()，无需重复编写判断和抛错逻辑
2. 类型安全：通过类型断言，TypeScript自动识别初始化后的属性为非可选，彻底避免!操作符
3. 保留前置调用能力：method2不依赖初始化状态，完全可以在init执行前调用
4. 单例特性不变：内部状态全局唯一，符合应用生命周期单例的需求

类实现的优化方案（可选） #

如果更倾向于用类实现，可以通过延迟初始化+静态方法解决参数外部传入和method2提前调用的问题：

class Stuff {
  private static instance: Stuff | null = null;
  private x: string;
  private y: string;
  private z: string;
  private fn: () => void;

  // 私有构造函数，确保只能通过静态init创建实例
  private constructor(x: string, y: string, z: string, fn: () => void) {
    this.x = x;
    this.y = y;
    this.z = z;
    this.fn = fn;
  }

  // 静态初始化方法，接收外部传入的参数
  public static init(x: string, y: string, z: string, fn: () => void) {
    if (Stuff.instance) return;
    Stuff.instance = new Stuff(x, y, z, fn);
  }

  // 统一的实例获取断言
  private static getInstance(): Stuff {
    if (!Stuff.instance) {
      throw new Error('not init');
    }
    return Stuff.instance;
  }

  // 依赖初始化的静态方法
  public static method1() {
    const instance = Stuff.getInstance();
    instance.fn();
    console.log(instance.x);
  }

  // 不依赖初始化的静态方法，随时可调用
  public static method2() {
    console.log('method2 executed before init');
  }

  public static isReady() {
    return !!Stuff.instance;
  }
}

// 测试
Stuff.method2(); // 正常执行
// Stuff.method1(); // 抛出错误
Stuff.init('x', 'y', 'z', () => console.log('init done'));
Stuff.method1(); // 正常执行

这个方案中，method2作为静态方法可在任何时候调用，初始化通过静态init方法接收外部参数，getInstance统一处理实例检查，避免重复代码。

内容的提问来源于stack exchange，提问作者Paperbag Writer