typeof 结果，当存储在变量中时，不再被 TS 用于类型推断

Question

consider the following code:

export const func = (foo?: number) => {
  const isNumber = typeof foo === 'number';
  return isNumber ? Math.max(foo, 0) : 0;
};

Here, TS complains that undefined cannot be applied to Math.max . On the other hand, this works just fine:

export const func = (foo?: number) => {
  return typeof foo === 'number' ? Math.max(foo, 0) : 0;
};

Can somebody explain why this is ?

Thanks

Answer 1

Refactoring an expression to create a new variable (or const) like this often doesn't give you the same results from the type-checker, because Typescript infers a type for your variable and then uses that type subsequently, and the type it infers may be different from what would be inferred for the same expression in its original context.

In this case, the type of isNumber is just boolean ; this type has no relationship to the variable foo so a conditional expression on it doesn't narrow the type of the different variable foo . In the original code, however, it is more like a type guard of the form foo is number , which is a subtype of boolean . A type guard can be used as a type annotation for a function, but not as the type of a variable.

To be able to verify code like your example, Typescript would have to keep track not just of the types of variables, but also the relationships between types of multiple variables; instead of inferring isNumber: boolean it would have to infer something like:

• "Either foo: number and isNumber: true , or foo: undefined and isNumber: false " .

Inferring types like this would be messy, complicated, and the complexity of the types would grow exponentially in the number of variables.

More generally, Typescript's type checker does not prove every provable fact about your code, and doesn't try to. It has a set of rules which it follows to infer and narrow types, but this set of rules is not a complete logical system .