TypeScript中Array.includes()为何提示参数类型不兼容？

Let's break down why you're seeing that ts(2345) error, then walk through actionable fixes for your code.

The Root Cause #

First, let's recap your type setup:

• TWordType is the union of 'noun' | 'verb' | 'conjunction' (derived from the wordTypes array)
• TGrammarType expands that union with two extra values: 'pronunciation' | 'etymology', making it a union of all five strings

When you call wordTypes.includes(test), TypeScript checks the type of test against the expected parameter type of Array.includes() for wordTypes. The includes() method on an array of TWordType expects its argument to be a TWordType—but test is a TGrammarType, which includes values that aren't present in wordTypes.

TypeScript is doing its strict type checking job here: it can't guarantee at compile time that test won't be 'pronunciation' or 'etymology', so it flags the mismatch to prevent potential runtime inconsistencies (even though we know includes() would just return false for those values at runtime).

Fix Options #

1. Type Assertion (Quick, Simple Fix) #

If you're confident that your logic might only pass values that could belong to wordTypes, you can tell TypeScript to treat test as a TWordType using a type assertion:

const isWord = wordTypes.includes(test as TWordType);

This suppresses the error, but note: it's a "trust me" signal to TypeScript. If test ever ends up being 'pronunciation' or 'etymology' at runtime, includes() will just return false—no crash, but you lose some compile-time safety.

2. Custom Type Guard (Recommended for Robustness) #

For a more robust solution, create a type guard function. This not only checks if the value exists in wordTypes but also narrows the type of test in conditional blocks, giving you better compile-time safety:

function isWord(value: TGrammarType): value is TWordType {
  // We use the assertion only inside the guard function
  return wordTypes.includes(value as TWordType);
}

// Usage example:
if (isWord(test)) {
  // Inside this block, TypeScript knows `test` is a TWordType
  console.log(`Valid word type: ${test}`);
} else {
  // Here, `test` is narrowed to 'pronunciation' | 'etymology'
  console.log(`Not a word type: ${test}`);
}

This gives you the best of both worlds: runtime validation and precise type narrowing.

3. Widen the includes() Parameter Type (Least Recommended) #

You can modify the type of wordTypes to accept any TGrammarType in its includes() method, but this weakens TypeScript's strict checks:

// Cast wordTypes to an array that accepts TGrammarType in includes
const wordTypes = ['noun', 'verb', 'conjunction'] as const as readonly TGrammarType[];
type TWordType = typeof wordTypes[number];

// Now this works without extra assertions
const isWord = wordTypes.includes(test);

Only use this if you need to frequently check TGrammarType values against wordTypes and don't mind losing the strict parameter validation for includes().

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