Rain9Rain9
首页
AI 岗位
AI 目录
前端
后端
桌面端
WebGL
Web3
  • 算法与面试
  • 面试八股
  • Vim 练级
  • Github
  • 掘金
  • 公众号《与 IT 有约》
首页
AI 岗位
AI 目录
前端
后端
桌面端
WebGL
Web3
  • 算法与面试
  • 面试八股
  • Vim 练级
  • Github
  • 掘金
  • 公众号《与 IT 有约》
  • 前端

    • 前端
    • AI 产品前端开发指南:流式、对话 UI 与 Copilot 交互
    • CDN 容错
    • 面试官问:了解哪些最新的 ES 新特性?——这样回答更好!
    • first_paint
    • Flutter
    • 强制缓存和协商缓存
    • js 高级程序设计
    • JSBridge·
    • 垃圾回收机制
    • 下一代高性能跨平台UI渲染引擎
    • 日志埋点 SDK
    • 日志中心
    • 录音与压缩编码
    • 站内信
    • 小程序
    • PWA1
    • React
    • Tailwind
    • Taro
    • video
    • vite
    • Webassembly
    • Webpack 5
    • 小程序直播
    • 移动端适配

TypeScript

一、核心概念与类型收窄

  • any / unknown / never / void 的区别与使用场景
    • any:放弃类型检查,传染性强
    • unknown:需先收窄后使用,更安全
    • never:不可达或不会返回的类型
    • void:函数无返回值
function f1(x: any) { x.trim() }
function f2(x: unknown) { if (typeof x === "string") x.trim() }
function f3(): never { throw new Error("boom") }
function f4(): void {}
  • 类型收窄与可辨识联合(discriminated union)
    • 通过 typeof / instanceof / in / 字面量标签进行收窄
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number }

function area(s: Shape) {
  switch (s.kind) {
    case "circle": return Math.PI * s.r * s.r
    case "rect": return s.w * s.h
  }
}
  • 可选、非空与空值处理:?. / ?? / !
type User = { profile?: { name?: string } }
const u: User = {}
const n1 = u.profile?.name ?? "anonymous"
const n2 = (u.profile!.name as string)
  • keyof 与 typeof 的配合
const config = { host: "a", port: 80 }
type Config = typeof config
type Keys = keyof Config
  • 交叉类型与联合类型的差异
    • 联合:A | B,取并集
    • 交叉:A & B,需同时满足
type A = { a: number }
type B = { b: string }
type U = A | B
type I = A & B

二、泛型与高级类型

  • 泛型约束与默认参数
type IdOf<T extends { id: string } = { id: string }> = T["id"]
  • 条件类型与分布式条件类型
type Nullable<T> = T | null | undefined
type NonNullable<T> = T extends null | undefined ? never : T
type Dist<T> = T extends any ? T[] : never
type R = Dist<string | number>
  • infer 的典型使用
type Awaited<T> = T extends Promise<infer U> ? U : T
type Return<T> = T extends (...args: any) => infer R ? R : never
type Params<T> = T extends (...args: infer P) => any ? P : never
  • 映射类型与键重映射
type Readonly<T> = { readonly [K in keyof T]: T[K] }
type Optional<T> = { [K in keyof T]?: T[K] }
type Rename<T> = { [K in keyof T as `new_${Extract<K, string>}`]: T[K] }
  • 索引签名与记录类型
type Dict = { [k: string]: number }
type Rcd = Record<string, number>
  • 函数类型的协变/逆变与 strictFunctionTypes
class Animal {}
class Dog extends Animal {}
type FnA = (a: Animal) => void
type FnD = (d: Dog) => void
let fa: FnA
let fd: FnD
fa = fd

三、工程实践与模块化

  • 类型空间与值空间分离,import type
import type { Config } from "./types"
  • 声明合并与模块增强
declare global {
  interface Window { appVersion: string }
}
  • tsconfig 严格模式关键项

    • strict / noImplicitAny / strictNullChecks / exactOptionalPropertyTypes
  • API 类型建模与错误处理

type Result<T, E = string> = { ok: true; data: T } | { ok: false; error: E }
  • React 专项
    • Props 类型、children、事件类型
type ButtonProps = { onClick: (e: React.MouseEvent<HTMLButtonElement>) => void; children?: React.ReactNode }
const Button = (p: ButtonProps) => <button onClick={p.onClick}>{p.children}</button>

四、手写 Utility Types

  • DeepReadonly / DeepPartial
type DeepReadonly<T> =
  T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T

type DeepPartial<T> =
  T extends object
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : T
  • Mutable
type Mutable<T> = { -readonly [K in keyof T]: T[K] }
  • PickByValue
type PickByValue<T, V> = { [K in keyof T as T[K] extends V ? K : never]: T[K] }
  • UnionToIntersection
type UnionToIntersection<U> =
  (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never

五、模板字面量类型技巧

  • 路径拼接与受限路由
type Route = "/home" | "/user" | "/search"
type WithId<R extends string> = `${R}/${string}`
type UserDetail = WithId<"/user">
  • 类型级字符串转换(驼峰/短横线)
type Kebab<S extends string> =
  S extends `${infer H}${infer T}`
    ? `${Lowercase<H>}${T extends Capitalize<T> ? `-${Lowercase<T>}` : T}`
    : S

六、常见陷阱与最佳实践

  • enum vs const enum 的编译差异与性能影响
  • 数字枚举的反向映射导致的可枚举性问题
  • any 污染链,应优先 unknown 并收窄
  • as const 的使用与不可变数据建模
  • Date 与字符串时间的建模选择
const a = { x: 1, y: 2 } as const
type A = typeof a

七、综合题(思路与实现)

  • 题:实现一个类型 SafeGet<T, P>,从对象类型 T 中按路径 P 提取类型
type Split<S extends string> =
  S extends `${infer H}.${infer T}` ? [H, ...Split<T>] : [S]

type SafeGet<T, P extends string> =
  Split<P> extends [infer H extends keyof T, ...infer R]
    ? R["length"] extends 0
      ? T[H]
      : SafeGet<T[H], Extract<R, string[]>[number]>
    : never
  • 题:将联合类型转换为并集对象键
type UnionKeys<T> = T extends any ? keyof T : never
type U = { a: number } | { b: string } | { c: boolean }
type K = UnionKeys<U>

面试使用建议:

  • 先讲场景与痛点,再用两到三个高级类型题展示深度
  • 结合真实工程实践(tsconfig、声明增强、SDK 类型建模)证明落地能力
  • 适当写出 Utility Types 与模板字面量题,体现类型编程思维
最近更新: 2026/10/31 10:01