TypeScript 类型推断：何时需要写类型注解

类型推断就是 TypeScript 替你算出你没写的类型。给变量赋初值，它就取这个值的类型；函数返回一个值，返回类型也随之确定。大多数 TypeScript 代码里的类型注解比人们想象的少得多。

let count = 0;            // number
let language = "TypeScript"; // string
let tags = ["ts", "js"];  // string[]
let user = { name: "Ada", age: 36 }; // { name: string; age: number }

function area(w: number, h: number) {
    return w * h;          // return type inferred as number
}

const size = area(3, 4);  // number
console.log(count, language, tags, user, size);

// The inferred types are enforced like written ones:
// @ts-expect-error: Type 'string' is not assignable to type 'number'.
count = "one";

注释里写的是在编辑器中悬停每个名字时显示的内容。最后一行是编译错误（TS2322），尽管 count 从未被注解；// @ts-expect-error 把它标记为预期中的错误，这样代码块的其余部分才能运行。

let 与 const：字面量拓宽

const 永远不会改变，所以 TypeScript 给它最窄的类型：字面量值本身。let 得到更宽的类型，因为它之后可能被重新赋值。

let a = "left";    // string
const b = "left";  // "left"
let c = 42;        // number
const d = 42;      // 42
const e = true;    // true

当函数只接受特定的值时，这一点就很重要：

// This does not compile: `let` widened "left" to string.
function move(direction: "left" | "right") {
    console.log("moving", direction);
}

let dir = "left";
move(dir);

const fixed = "left";
move(fixed); // fine: fixed has type "left"

index.ts(7,6): error TS2345: Argument of type 'string' is not assignable to parameter of type '"left" | "right"'.

改用 const，或者给变量加上注解 let dir: "left" | "right" = "left"，就能修复。字面量类型有单独的页面：字面量类型。

对象和数组会拓宽其成员

对象字面量的属性是可变的，所以即使对象本身是 const，属性也会像 let 一样被拓宽。数组元素也是如此。as const 会让一切变成只读，并保留字面量类型。

const config = { mode: "dark", retries: 3 };
// config: { mode: string; retries: number }
config.mode = "light"; // allowed: mode is string

const frozen = { mode: "dark", retries: 3 } as const;
// frozen: { readonly mode: "dark"; readonly retries: 3 }

const sizes = ["s", "m", "l"];            // string[]
const fixedSizes = ["s", "m", "l"] as const; // readonly ["s", "m", "l"]

console.log(config.mode, frozen.mode, sizes.length, fixedSizes[0]);

返回类型推断

函数的返回类型由它的 return 语句推断。有多个 return 时，结果是它们的联合类型。

function parsePort(text: string) {
    if (text === "") return null;
    return Number(text);
}
// parsePort returns number | null

const port = parsePort("8080");
if (port !== null) {
    console.log(port + 1); // 8081: port is number inside the check
}

function log(message: string) {
    console.log(message);
}
// log returns void: there is no return value

log("done");

对大多数函数来说，推断出的返回类型就够用了。如果希望函数签名成为一份约定，就在导出或公开的函数上显式写出返回类型：函数体内的改动一旦返回了不同的类型，报错就出现在函数本身，而不是某个遥远的调用处。

上下文类型：回调函数自动获得类型

参数不会根据函数的调用方式推断，但有两个例外。带默认值的参数取默认值的类型（function retry(times = 3) 中 times 是 number）。另外，在已经需要某个函数类型的位置写出的函数，会从上下文获得参数类型，所以回调函数的参数不需要注解。

const names = ["ada", "grace", "alan"];

// s is string: map on a string[] passes strings
const upper = names.map((s) => s.toUpperCase());

// a and b are strings, the result must be a number
const sorted = [...names].sort((a, b) => a.length - b.length);

// The variable's type gives the arrow its parameter and return types
const greet: (name: string) => string = (n) => `Hello, ${n}`;

console.log(upper, sorted, greet("Ada"));

forEach、filter、reduce、Promise 的回调、事件处理函数，以及任何传给已声明函数类型参数的函数，都适用同样的规则。

参数需要类型注解

如果没有默认值，也没有上面那样的上下文，TypeScript 不会通过观察函数的调用方式来猜测参数类型。开启 strict 时，没有注解的参数会报错 TS7006：

// This does not compile: a parameter with no type and no context.
function double(x) {
    return x * 2;
}
console.log(double(21));

index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type.

写成 function double(x: number)，代码块就会打印 42，返回类型 number 由 x * 2 推断得出。

最佳通用类型

对于包含不同种类值的数组字面量，TypeScript 推断出的是这些值类型的联合类型组成的数组。它不会去寻找你没提到的共同基类。

const mixed = [1, "two", null]; // (string | number | null)[]
const nums = [1, 2.5, -3];      // number[]

class Animal { name = "animal"; }
class Dog extends Animal { bark() { return "woof"; } }
class Cat extends Animal { meow() { return "meow"; } }

const pets = [new Dog(), new Cat()];            // (Cat | Dog)[]
const animals: Animal[] = [new Dog(), new Cat()]; // annotate to get Animal[]

console.log(mixed.length, nums, pets.length, animals[0].name);

需要留意的是空数组。const list = [] 一开始是一个“演化中”的数组，类型随每次 push 增长；加上注解 const list: string[] = [] 能事先表明意图，也更清晰。

何时写类型注解

查看推断结果最快的方法是在编辑器里悬停在名字上。没有编辑器时，把值赋给一个类型错误的变量，比如 const probe: boolean = mixed;，编译器的错误信息就会写出推断出的类型。