在 TypeScript 项目中，数组解构是高频操作。比如 const [first, second] = pair，类型推断通常很直接。但一旦给解构元素加上默认值，比如 const [first = 'fallback'] = maybeArray，推导逻辑就会变得微妙：变量 first 的类型究竟是 string 还是 string | undefined？如果数组元素类型是 string | undefined，默认值又是什么作用？这篇文章就来拆解 TypeScript 在这类场景下的类型推导过程。

一、数组解构与默认值的基本推导

在没有默认值的情况下，TypeScript 会根据数组元素的类型直接推导解构变量。例如：

const pair: string[] = ['left', 'right'];
const [first, second] = pair;
// first: string
// second: string

这里 pair 的元素类型是 string，因此 first 和 second 都被推断为 string。即使数组长度不足，在默认配置下解构超出索引的值类型也不会自动包含 undefined，除非开启了 noUncheckedIndexedAccess。解构模式同样受该选项影响，所以在常规配置下，上述代码不会出现 string | undefined。

当数组元素类型明确包含 undefined 时，情况就不同了。看下面的例子：

const maybeArray: (string | undefined)[] = ['a', undefined];
const [p, q] = maybeArray;
// p: string | undefined
// q: string | undefined

由于数组元素是 string 和 undefined 的联合类型，解构得到的变量自然也是 string | undefined。这时如果在代码中直接调用 p.toUpperCase()，编译器会报错，因为 p 可能为 undefined。要给 p 一个安全值，默认值就派上了用场。

为解构元素添加默认值后，类型推断会发生变化。例如：

const [m = 'default'] = maybeArray;
// m: string

这里变量 m 的类型被推断为 string，而不是 string | undefined。默认值的作用是在解构结果为 undefined 时提供替代值，因此 TypeScript 从结果类型中移除了 undefined。注意这个移除只针对 undefined，并不能影响 null。

二、默认值类型与数组元素类型的并集规则

当默认值类型与数组元素类型不完全一致时，TypeScript 会尝试生成一个联合类型。规则可以概括为：绑定变量的推断类型等于数组元素类型去掉 undefined 之后再与默认值类型取并集。比如数组元素类型为 number | undefined，默认值为字符串：

const mixed: (number | undefined)[] = [1, undefined];
const [value = 'fallback'] = mixed;
// value: number | string

这里数组元素去掉 undefined 后是 number，默认值类型是 string，最终 value 的类型是 number | string。这说明默认值不仅会收窄 undefined，还会把自身类型带入结果，即使它与原数组元素类型没有交集。这样的推断对于后续使用 value 时需要同时处理 number 和 string 两种可能性。

如果数组元素类型本身不包含 undefined，默认值类型是否会被并入呢？答案是会。例如：

const nums: number[] = [1, 2];
const [first = 'zero'] = nums;
// first: number | string

虽然 nums 的元素类型是 number，理论上默认值永远不会触发，但 TypeScript 仍然会把默认值类型 string 并入 first 的类型。这样做可以保证类型行为一致，但也可能导致类型比实际值更宽。如果你的代码只依赖 number 操作，这里就会被迫处理 string 分支。一般情况下，不建议给非 undefined 的数组元素设置类型差异过大的默认值，除非你确实需要这种宽联合类型。

这个规则也适用于对象解构中的属性默认值，例如 const { name = 'unknown' } = user 若 user.name 类型是 string | undefined，则 name 会被推断为 string。数组解构和对象解构在这一点上保持同样的逻辑。

三、undefined 与 null 的差异以及 strictNullChecks 的影响

解构赋值中的默认值只对 undefined 生效，null 不会触发默认值。TypeScript 的类型推断也严格遵循这一运行时行为。例如：

const nullable: (string | null)[] = [null, 'x'];
const [first = 'fallback'] = nullable;
// first: string | null

数组元素类型是 string | null，不包含 undefined。虽然给 first 设置了默认值，但实际上当元素为 null 时默认值不会生效，所以 TypeScript 推断的结果仍然包含 null。这一点很容易被误解：很多人以为默认值能兜住所有空值，其实它只针对 undefined。如果你的数据源可能产生 null，应该使用空值合并运算符或者手动类型收窄，而不是依赖解构默认值。

strictNullChecks 开关会让这个差异更加明显。关闭 strictNullChecks 时，null 和 undefined 可以赋值给任意类型，类型系统对空值比较宽松，默认值对推导的影响也不再那么关键。开启 strictNullChecks 后，undefined 和 null 会被严格区分，上面的推断结果才更有参考价值。现代 TypeScript 项目通常都会开启 strictNullChecks，因此理解 undefined 的收窄逻辑非常实用。

另一个常见场景是函数参数解构。假设函数接收一个可能包含 undefined 的数组：

function format([head = 'empty']: (string | undefined)[]): string {
  return head.toUpperCase();
}

在函数体内部，head 类型已经是 string，可以直接调用 toUpperCase。如果去掉默认值，head 就会是 string | undefined，需要先判空。对于需要安全处理的参数，使用默认值可以简化内部逻辑。

四、嵌套解构与复杂场景的推断陷阱

当数组元素是对象，并且需要从对象属性中解构时，默认值同样会参与类型推断，但需要注意作用的位置。例如：

interface Item {
  id: number | undefined;
  label: string;
}
const items: (Item | undefined)[] = [{ id: undefined, label: 'a' }, undefined];
const [{ id = 0, label } = {} as Item] = items;
// id: number
// label: string

这个例子中，外层数组元素类型为 Item | undefined，内层解构使用了默认值空对象，然后再给 id 设置默认值。解构过程会先处理数组元素的 undefined，再处理对象属性的 undefined。最终 id 被推断为 number，label 为 string。但如果少了外层的默认空对象，解构 undefined 时会直接报错，因为无法从 undefined 中读取属性。

一个容易忽略的陷阱是：多层默认值可能掩盖数据缺失，导致类型上看似安全，但运行时仍然出现 undefined 相关错误。例如当对象默认值为空对象时，内部属性可能拿不到预期的值，如果属性默认值类型与需要类型不匹配，仍可能产生宽类型。建议在复杂嵌套中显式标注变量类型，避免依赖过深的推断链条。

还有一种情况是数组元素为联合类型时，默认值只对 undefined 分支有效，但类型推断会保留其他所有分支。假设元素类型为 string | number | undefined，默认值类型为 boolean，最终解构变量的类型会是 string | number | boolean。这种宽联合类型可能超出预期，使用时需要额外的类型守卫。

五、最佳实践与类型标注建议

理解解构默认值的类型推断，能帮助你在日常编码中少走弯路。当数组元素可能为 undefined 时，默认值是收窄类型的好工具，但只对 undefined 生效，对 null 无效。设置默认值时，要留意默认值类型会并入最终联合类型，可能让变量类型变宽。如果你需要精确控制变量类型，可以在解构模式上显式标注。例如：

const maybe: (string | undefined)[] = ['ok', undefined];
const [value = 'default'] = maybe;
// value: string

这里虽然自动推断结果已经是 string，但如果元素类型更复杂，手动标注可以避免意外宽类型。比如元素类型为 string | number | undefined 且默认值是 boolean 时，推断结果会是 string | number | boolean，而你期望的可能是 string | number。这时可以写：

const items: (string | number | undefined)[] = [1, 'two', undefined];
const [first = true] = items;
// first: string | number | boolean

如果你只想要 string | number，可以直接给解构变量标注类型：

const [first]: [string | number] = items as [string | number];
// first: string | number

不过这种断言需要你确保运行时值满足类型，否则可能掩盖问题。更稳妥的做法是在数据源头就定义好准确的类型，并在函数参数中写清楚输入输出，让默认值只负责处理 undefined。例如：

function handle([first = 'none']: Array<string | undefined>): void {
  console.log(first);
}

这样既保证了 first 类型为 string，又明确了输入数组的元素类型。对于可能产生 null 的数据源，可以结合 ?? 运算符：

const [maybeNull = 'fallback'] = arr as (string | null | undefined)[];
const safe = maybeNull ?? 'fallback';
// safe: string

最终 safe 的类型为 string，因为空值合并运算符会同时处理 null 和 undefined，比单纯的解构默认值更彻底。

通过本文的拆解，可以看到 TypeScript 对解构默认值的类型推断并非简单的“替换”，而是结合 undefined、默认值类型和数组元素类型做联合运算。掌握这一点后，你可以在数组解构、函数参数处理和复杂嵌套中写出更准确、更安全的类型代码。