TS 类型推导什么是类型推导？类型推导是 TypeScript 编译器的一项核心能力。简单来说，当你在代码中没有显式地

什么是类型推导？

类型推导是 TypeScript 编译器的一项核心能力。简单来说，当你在代码中没有显式地通过类型注解 (: Type) 来指定一个变量或表达式的类型时，TypeScript 编译器会尝试根据上下文信息（主要是变量的初始值或函数的返回值）自动推断出这个变量或表达式应该具有的类型。

为什么需要类型推导？

减少代码冗余： 你不需要为每一个变量都写上类型注解，尤其是在类型很明显的情况下，这让代码更简洁。
保持类型安全： 即使没有显式注解，TypeScript 依然知道变量的类型，并在后续的使用中进行类型检查，保证类型安全。
提高开发效率： 少写一些模板化的注解代码。

类型推导在哪些场景下发生？

变量初始化时 (Variable Initialization): 这是最常见的场景。当你声明一个变量并立即为其赋初始值时，TypeScript 会根据初始值的类型来推断变量的类型。

// 基本类型推导
let name = "Alice";      // 推断为 string
let age = 30;          // 推断为 number
let isStudent = false; // 推断为 boolean

// name = 123; // Error: Type 'number' is not assignable to type 'string'.

// 数组推导
let numbers = [1, 2, 3]; // 推断为 number[]
let mixed = [1, "hello", true]; // 推断为 (string | number | boolean)[]

// numbers.push("four"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

// 对象推导
let person = { name: "Bob", age: 42 }; // 推断为 { name: string; age: number; }

// person.age = "forty-two"; // Error: Type 'string' is not assignable to type 'number'.
// person.location = "City"; // Error: Property 'location' does not exist on type '{ name: string; age: number; }'.

函数返回值 (Function Return Types): 如果一个函数没有显式注解返回值类型，TypeScript 会尝试根据函数体中的 return 语句来推断返回类型。

function add(a: number, b: number) { // 没有 : number 返回值注解
  return a + b; // TypeScript 分析 return 语句，推断返回类型为 number
}
let sum = add(5, 3); // sum 被推断为 number

function createGreeting(name: string) {
  if (name) {
    return "Hello, " + name; // 返回 string
  } else {
    return "Hello!";       // 返回 string
  }
  // 推断返回类型为 string
}

function process(value: string | number) {
    if (typeof value === 'string') {
        return value.length; // 返回 number
    }
    return value * 2;     // 返回 number
    // 推断返回类型为 number
}

function logMessage(message: string) {
    console.log(message);
    // 没有 return 语句，或者只有空的 return;
    // 推断返回类型为 void
}

注意： 对于复杂的函数、递归函数或有多个不同类型返回值的函数（除非它们能形成明确的联合类型），TypeScript 可能无法精确推断，或者推断出的类型可能不是你想要的。在这些情况下，以及为了代码清晰和作为“契约”，显式注解函数返回值通常是更好的实践。

参数默认值 (Default Parameter Values): 如果函数参数有默认值，TypeScript 会根据默认值的类型推断参数的类型。

function greet(name = "World") { // name 被推断为 string
  console.log(`Hello, ${name.toUpperCase()}!`);
}
// greet(123); // Error: Argument of type 'number' is not assignable to parameter of type 'string | undefined'.

解构赋值 (Destructuring Assignments): 从对象或数组解构时，变量的类型也会被推断。

      let point = { x: 10, y: 20 };
let { x, y } = point; // x 和 y 都被推断为 number

let rgb: [number, number, number] = [255, 0, 128];
let [r, g, b] = rgb; // r, g, b 都被推断为 number

“最佳通用类型” (Best Common Type) 算法

当需要从多个表达式（例如数组中的元素或 if/else 的不同分支返回值）推断类型时，TypeScript 会尝试找到一个能兼容所有这些表达式的“最佳通用类型”。

let arr = [1, null, "hello"];
// 元素类型：number, null, string
// 最佳通用类型：(string | number | null)[]
// arr 被推断为 (string | number | null)[]

function checkValue(input: number) {
    if (input > 0) {
        return "positive"; // string
    } else if (input < 0) {
        return "negative"; // string
    }
    return 0; // number
    // 多个返回类型：string, string, number
    // 最佳通用类型：string | number
    // 函数返回值被推断为 string | number
}

如果无法找到合适的通用类型（例如，数组包含结构完全不同的复杂对象），编译器可能会推断出一个不太有用的类型（如 {}[]），或者在严格模式下报错，此时最好提供显式的类型注解。

上下文类型 (Contextual Typing)

这是一种稍微不同的推断形式，类型信息从“上下文”流向表达式，而不是从表达式流向变量。

事件处理:

window.onclick = function(event) {
  // TypeScript 根据 window.onclick 的预期类型
  // 推断出 event 参数是 MouseEvent 类型
  console.log(event.button); // 可以安全访问 MouseEvent 的属性
};

数组方法的回调:

let nums = [1, 2, 3];
nums.forEach(n => {
  // TypeScript 根据 number[] 的 forEach 方法签名
  // 推断出 n 参数是 number 类型
  console.log(n.toFixed(2));
});

赋值给已有类型的变量:

let calculate: (x: number, y: number) => number;
calculate = (a, b) => { // a 和 b 会被上下文推断为 number
  return a + b;
};

何时仍需显式注解？

尽管类型推导很强大，但在以下情况推荐或必须使用显式类型注解：

变量声明时没有初始值:

let value; // 推断为 any (如果 noImplicitAny 关闭) 或报错 (如果开启)
value = 10;
value = "hello"; // 如果是 any 则不会报错，类型不安全

// 推荐做法:
let betterValue: string | number;
betterValue = 10;
// betterValue = true; // Error!

希望变量类型比推断出的类型更通用/抽象:

interface Animal { name: string; }
interface Dog extends Animal { breed: string; }

// 推断类型为 Dog
let dog = { name: "Buddy", breed: "Golden Retriever" };

// 如果希望变量只关注 Animal 部分，需要显式注解
let animal: Animal = { name: "Max", breed: "Labrador" }; // OK
// console.log(animal.breed); // Error: Property 'breed' does not exist on type 'Animal'.

函数返回值类型不明显或为了代码清晰/API契约: 如前所述，显式注解函数返回值通常是个好主意。

对象字面量可能包含额外属性（绕过额外属性检查）：

interface Options { color?: string; width?: number; }
// let opts = { color: "red", width: 100, speed: 10 }; // Error: Object literal may only specify known properties...

// 通过注解可以绕过初始赋值时的额外属性检查（但类型仍需兼容）
let opts: Options = { color: "red", width: 100, speed: 10 }; // Error依然存在，除非 Options 允许额外属性

// 更常见的是先创建变量再赋值
let optsVar: Options;
optsVar = { color: "red", width: 100, speed: 10 }; // Error: 'speed' does not exist in type 'Options'

// 或者使用类型断言（不推荐，除非你确定）
let optsAssert = { color: "red", width: 100, speed: 10 } as Options; // 类型断言

避免 TypeScript 错误地推断出 any 类型: 当 TypeScript 无法确定类型且 noImplicitAny 编译选项关闭时，它可能会回退到 any。显式注解可以避免这种情况。