TS2722错误排查：strictNullChecks开启后函数重载调用报错

问题背景 #

启用strictNullChecks（通过tsconfig.json的strict: true开启）后，Σ函数的switch语句内触发15次TS2722错误：

TS2722: Cannot invoke an object which is possibly undefined

从逻辑上看，当arguments.length === 2时，ab函数应存在（基于函数重载定义），但TypeScript仍判定其可能为undefined。

相关配置与代码 #

tsconfig.json

{
  "compilerOptions": {
    "module": "CommonJS",
    "noUncheckedIndexedAccess": true,
    "strict": true,
    "target": "ESNext"
  }
}

Σ函数代码

function Σ<A>(a: A): A;
function Σ<A, B>(a: A, ab: (a: A) => B): B;
function Σ<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
function Σ<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
function Σ<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
function Σ<A, B, C, D, E, F>(
  a: A,
  ab: (a: A) => B,
  bc: (b: B) => C,
  cd: (c: C) => D,
  de: (d: D) => E,
  ef: (e: E) => F
): F;
function Σ(a: unknown, ab?: Function, bc?: Function, cd?: Function, de?: Function, ef?: Function): unknown {
  switch (arguments.length) {
    case 1:
      return a;
    case 2:
      return ab(a);
    case 3:
      return bc(ab(a));
    case 4:
      return cd(bc(ab(a)));
    case 5:
      return de(cd(bc(ab(a))));
    case 6:
      return ef(de(cd(bc(ab(a)))));
  }
}

错误原因 #

TypeScript的类型检查逻辑不会将arguments.length的运行时判断与函数参数的可选性做关联推导：

1. 函数重载仅约束调用方的参数传入规则，函数实现内部的参数仍被标记为可选（如ab?: Function）。
2. arguments是运行时对象，TypeScript编译器无法通过arguments.length === 2推断出ab一定存在，因此仍会判定其可能为undefined。

解决与优化建议 #

方案1：非空断言（快速解决） #

在调用可选参数前添加非空断言运算符!，明确告诉编译器该参数一定存在：

function Σ(a: unknown, ab?: Function, bc?: Function, cd?: Function, de?: Function, ef?: Function): unknown {
  switch (arguments.length) {
    case 1:
      return a;
    case 2:
      return ab!(a);
    case 3:
      return bc!(ab!(a));
    case 4:
      return cd!(bc!(ab!(a)));
    case 5:
      return de!(cd!(bc!(ab!(a))));
    case 6:
      return ef!(de!(cd!(bc!(ab!(a)))));
  }
}

注意：该方案依赖重载规则保证运行时参数非空，若调用方绕过类型检查传入参数，可能引发运行时错误。

方案2：运行时参数校验（更安全） #

在调用前添加运行时检查，既保证类型安全，也能在参数异常时抛出明确错误：

function Σ(a: unknown, ab?: Function, bc?: Function, cd?: Function, de?: Function, ef?: Function): unknown {
  switch (arguments.length) {
    case 1:
      return a;
    case 2:
      if (!ab) throw new Error('Expected function argument for ab');
      return ab(a);
    case 3:
      if (!ab || !bc) throw new Error('Expected function arguments for ab and bc');
      return bc(ab(a));
    case 4:
      if (!ab || !bc || !cd) throw new Error('Expected function arguments for ab, bc and cd');
      return cd(bc(ab(a)));
    case 5:
      if (!ab || !bc || !cd || !de) throw new Error('Expected function arguments for ab, bc, cd and de');
      return de(cd(bc(ab(a))));
    case 6:
      if (!ab || !bc || !cd || !de || !ef) throw new Error('Expected function arguments for ab, bc, cd, de and ef');
      return ef(de(cd(bc(ab(a)))));
    default:
      throw new Error(`Invalid number of arguments: ${arguments.length}`);
  }
}

方案3：重构为Rest参数+Reduce（代码简化） #

用Rest参数接收所有函数，结合Array.reduce串联调用，大幅简化代码，同时让TypeScript更好地做类型推导：

function Σ<A>(a: A): A;
function Σ<A, B>(a: A, ab: (a: A) => B): B;
function Σ<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
function Σ<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
function Σ<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
function Σ<A, B, C, D, E, F>(
  a: A,
  ab: (a: A) => B,
  bc: (b: B) => C,
  cd: (c: C) => D,
  de: (d: D) => E,
  ef: (e: E) => F
): F;
function Σ(a: unknown, ...fns: Function[]): unknown {
  return fns.reduce((acc, fn) => fn(acc), a);
}

该方案利用Rest参数的数组特性，TypeScript能通过fns.length的隐式判断（结合重载）确保数组元素非空，同时代码更简洁易维护。

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