为何TypeScript中按索引访问数组元素的类型不含undefined？

Great question—this is a super common gotcha with TypeScript's array type handling, and it all comes down to intentional design choices around type safety vs. developer ergonomics. Let's break this down:

1. The Default Behavior: Trusting Your Index Access #

By default, TypeScript assumes that when you access an array via an index (like a[1]), you know that index is valid. This means it infers the type as just number (matching the array's element type) instead of number | undefined.

This choice is practical for everyday code: imagine looping through an array with a known length, like:

const a: number[] = [1, 2, 3];
for (let i = 0; i < a.length; i++) {
  const num: number = a[i]; // No need for undefined checks here—TypeScript trusts the index is valid
}

If TypeScript forced number | undefined everywhere, you'd have to add unnecessary checks in cases where you know the index exists, which would slow down development.

2. How to Enable Strict Index Checking (To Catch Hidden Bugs) #

If you want TypeScript to flag potential undefined values from array index accesses, you can turn on the noUncheckedIndexedAccess compiler option in your tsconfig.json:

{
  "compilerOptions": {
    "noUncheckedIndexedAccess": true
  }
}

With this enabled, const c = a[1] will now have the type number | undefined, and assigning it directly to a number variable (let b: number = a[1]) will throw a type error—exactly what you want to catch those hidden bugs.

3. Manual Workarounds (If You Don't Want Global Strict Mode) #

If you don't want to enable noUncheckedIndexedAccess for your entire project, you can handle potential undefined values manually:

• Check the index against the array length: TypeScript will narrow the type once you prove the index is valid:

  const a: number[] = [];
  if (1 < a.length) {
    let b: number = a[1]; // Safe now—TypeScript knows the index exists
  }
  

• Use optional chaining: If you just need to access a property or method safely, optional chaining (?.) handles undefined gracefully:

  const value = a[1]?.toString(); // value is string | undefined
  

• Use a type assertion (carefully): Only do this if you're 100% sure the index exists—assertions bypass TypeScript's checks:

  let b: number = a[1] as number; // Risky if a[1] is actually undefined!
  

Wrapping Up #

The default behavior is a tradeoff between convenience and strict safety. For projects where avoiding hidden undefined bugs is critical, enabling noUncheckedIndexedAccess is a great move. For most everyday code, the default keeps things concise while still letting you add checks where you need them.

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