结构化类型系统

class Cat {
  eat() {}
}
 
class Dog {
  eat() {}
}
 
function feedCat(cat: Cat) {}
 
// 竟然不报错！
feedCat(new Dog())

class Cat {
  eat() {}
}
 
class Dog {
  eat() {}
}
 
function feedCat(cat: Cat) {}
 
// OK
feedCat(new Dog())

class Cat {
  meow() {} // Cat独有的方法
  eat() {}
}
 
class Dog {
  eat() {}
}
 
function feedCat(cat: Cat) {}
 
// Error: Property 'meow' is missing in type 'Dog' but required in type 'Cat'.
feedCat(new Dog())

class Cat {
  eat() {}
}
 
class Dog {
  bark() {} // Dog额外的方法
  eat() {}
}
 
function feedCat(cat: Cat) {}
 
// OK
feedCat(new Dog())

interface Point {
  x: number;
  y: number;
}
 
// OK - 使用对象字面量
const p1: Point = { x: 1, y: 2 };
 
// Error: 对象字面量只能指定已知属性，并且 'z' 不在类型 'Point' 中。
const p2: Point = { x: 1, y: 2, z: 3 };
 
// OK - 先赋值给变量，再传递
const p3 = { x: 1, y: 2, z: 3 };
const p4: Point = p3; // 多余属性检查被绕过

class Cat {
  eat(): boolean {
    return true
  }
}
 
class Dog {
  eat(): number {
    return 599
  }
}
 
function feedCat(cat: Cat) {}
 
// Error: Types of property 'eat' are incompatible.
// Type '() => number' is not assignable to type '() => boolean'.
feedCat(new Dog())

class Animal {
  asPet() {}
}
 
class Dog extends Animal {
  bark() {}
}
 
class Corgi extends Dog {
  cute() {}
}
 
// 返回值协变示例
type AnimalFactory = () => Animal;
type DogFactory = () => Dog;
type CorgiFactory = () => Corgi;
 
let makeAnimal: AnimalFactory;
let makeDog: DogFactory;
let makeCorgi: CorgiFactory;
 
makeAnimal = makeDog; // OK - 返回值协变
makeAnimal = makeCorgi; // OK - 返回值协变
makeDog = makeCorgi; // OK - 返回值协变
 
// 参数逆变示例（需要开启 strictFunctionTypes）
type HandleDog = (dog: Dog) => void;
type HandleAnimal = (animal: Animal) => void;
type HandleCorgi = (corgi: Corgi) => void;
 
let handleDog: HandleDog;
let handleAnimal: HandleAnimal;
let handleCorgi: HandleCorgi;
 
handleDog = handleAnimal; // OK - 参数逆变
// handleDog = handleCorgi; // Error - 参数类型不兼容

class Animal {
  name: string = 'animal';
}
 
class Dog extends Animal {
  bark() {
    console.log('Woof!');
  }
}
 
class Cat {
  name: string = 'cat';
  meow() {
    console.log('Meow!');
  }
}
 
let animal: Animal = new Dog(); // OK - 继承关系
animal = new Cat(); // OK - 结构兼容，都有 name 属性

class First {
  private name: string = 'first';
}
 
class Second {
  private name: string = 'second';
}
 
let first: First = new Second(); // Error - 私有成员来自不同的声明

enum Status {
  Pending,
  InProgress,
  Done
}
 
let status: Status = Status.Pending;
let num: number = 0;
 
status = num; // OK
num = status; // OK

enum Color {
  Red,
  Blue
}
 
let status: Status = Status.Pending;
let color: Color = Color.Red;
 
status = color; // Error

// 在结构化类型系统中
type USD = number
type CNY = number
 
const CNYCount: CNY = 200
const USDCount: USD = 200
 
function addCNY(source: CNY, input: CNY) {
  return source + input
}
 
// 竟然不报错，离谱！
addCNY(CNYCount, USDCount)

// 一个通用的"名义化"类型工具
export type Nominal<T, U extends string> = T & {
  // 这个属性只在类型系统中存在，不会编译到 JavaScript
  readonly __brand: U
}

export type CNY = Nominal<number, "CNY">
export type USD = Nominal<number, "USD">
export type UserID = Nominal<string, "UserID">
export type OrderID = Nominal<string, "OrderID">
 
// 创建名义类型的值
function makeCNY(amount: number): CNY {
  return amount as CNY
}
 
function makeUSD(amount: number): USD {
  return amount as USD
}
 
const CNYCount = makeCNY(100)
const USDCount = makeUSD(100)
 
function addCNY(source: CNY, input: CNY): CNY {
  return (source + input) as CNY
}
 
addCNY(CNYCount, CNYCount) // OK
 
// Error: Argument of type 'USD' is not assignable to parameter of type 'CNY'.
//  Types of property '__brand' are incompatible.
addCNY(CNYCount, USDCount)
 
// 其他类型示例
const userId: UserID = "user-123" as UserID
const orderId: OrderID = "order-456" as OrderID
 
function getUser(id: UserID) {
  // ...
}
 
getUser(userId) // OK
// getUser(orderId) // Error - 不同类型不能混用

class CNY {
  // 私有成员确保了类型的唯一性
  private readonly __brand!: "CNY"
 
  constructor(public readonly value: number) {
    if (value < 0) {
      throw new Error("金额不能为负数")
    }
  }
 
  add(other: CNY): CNY {
    return new CNY(this.value + other.value)
  }
 
  toString(): string {
    return `¥${this.value}`
  }
}
 
class USD {
  private readonly __brand!: "USD"
 
  constructor(public readonly value: number) {
    if (value < 0) {
      throw new Error("金额不能为负数")
    }
  }
 
  add(other: USD): USD {
    return new USD(this.value + other.value)
  }
 
  toString(): string {
    return `$${this.value}`
  }
}
 
const CNYCount = new CNY(100)
const USDCount = new USD(100)
 
function addCNY(source: CNY, input: CNY): CNY {
  return source.add(input)
}
 
addCNY(CNYCount, CNYCount) // OK
 
// Error: Argument of type 'USD' is not assignable to parameter of type 'CNY'.
addCNY(CNYCount, USDCount)
 
// 支持运行时验证
try {
  const invalid = new CNY(-100) // Error: 金额不能为负数
} catch (e) {
  console.error(e)
}

// 品牌类型工具
declare const brand: unique symbol
 
type Brand<T, TBrand extends string> = T & {
  readonly [brand]: TBrand
}
 
// 类型安全的构造函数
function createBrand<T, TBrand extends string>(
  value: T,
  brandName: TBrand
): Brand<T, TBrand> {
  return value as Brand<T, TBrand>
}
 
// 实际使用
type CNY = Brand<number, "CNY">
type USD = Brand<number, "USD">
type UserID = Brand<string, "UserID">
 
// 工厂函数
const CNY = {
  from: (amount: number): CNY => {
    if (amount < 0) throw new Error("Invalid amount")
    return createBrand(amount, "CNY")
  },
  add: (a: CNY, b: CNY): CNY => createBrand(a + b, "CNY")
}
 
const userId = createBrand("user-123", "UserID")
const amount = CNY.from(100)
const total = CNY.add(amount, CNY.from(50))

interface User {
  id: string
  name: string
  email: string
}
 
// 来自 API 的数据可能有额外字段
interface APIUser {
  id: string
  name: string
  email: string
  createdAt: string
  updatedAt: string
}
 
function processUser(user: User) {
  console.log(`Processing ${user.name}`)
}
 
// OK - APIUser 兼容 User
const apiUser: APIUser = {
  id: "1",
  name: "John",
  email: "john@example.com",
  createdAt: "2024-01-01",
  updatedAt: "2024-01-02"
}
processUser(apiUser)

interface ComplexService {
  method1(): void
  method2(): void
  method3(): void
  // ... 更多方法
}
 
// 测试时只需要 Mock 需要的方法
const mockService = {
  method1: jest.fn()
  // 不需要实现其他方法
} as ComplexService
 
test('should call method1', () => {
  // 使用 mockService 进行测试
})

// JavaScript 代码可能返回各种结构的对象
function getUser() {
  return {
    name: "John",
    age: 30,
    // 可能还有其他属性
  }
}
 
// TypeScript 中只需要定义核心结构
interface User {
  name: string
  age: number
}
 
const user: User = getUser() // OK - 兼容

interface Point2D {
  x: number
  y: number
}
 
interface Point3D {
  x: number
  y: number
  z: number
}
 
let point2D: Point2D = { x: 1, y: 2 }
let point3D: Point3D = { x: 1, y: 2, z: 3 }
 
point2D = point3D // OK，但可能不是你想要的

type BrandPoint2D = Brand<Point2D, "2D">
type BrandPoint3D = Brand<Point3D, "3D">

interface Config {
  apiUrl: string
  timeout: number
}
 
// 直接传递对象字面量会有检查
function init(config: Config) {
  // ...
}
 
// Error: 多余属性检查
init({ apiUrl: "...", timeout: 1000, invalid: true })
 
// 但这样就不会报错
const config = { apiUrl: "...", timeout: 1000, invalid: true }
init(config) // OK - 绕过了多余属性检查

function init(config: Config) {
  const validKeys: (keyof Config)[] = ['apiUrl', 'timeout']
  const hasInvalidKeys = Object.keys(config).some(
    key => !validKeys.includes(key as keyof Config)
  )
  if (hasInvalidKeys) {
    throw new Error('Invalid config properties')
  }
}

class Animal {
  eat() {}
}
 
class Dog extends Animal {
  bark() {}
}
 
function makeAnimalSound(animal: Animal) {
  animal.eat()
}
 
function makeDogSound(dog: Dog) {
  dog.bark()
}
 
let animalHandler: (animal: Animal) => void = makeAnimalSound
let dogHandler: (dog: Dog) => void = makeDogSound
 
// 在默认模式下这可能不会报错（双变）
// 但在 strictFunctionTypes 模式下会报错
animalHandler = dogHandler // 可能有问题

// ✅ 好：接口保持最小化
interface User {
  id: string
  name: string
}
 
// ❌ 不好：接口过于庞大
interface User {
  id: string
  name: string
  email: string
  age: number
  address: string
  // ... 更多属性
}

// 对于对象结构，优先使用 interface
interface User {
  id: string
  name: string
}
 
// 对于联合类型、工具类型，使用 type
type ID = string | number
type Point = [number, number]
type Nullable<T> = T | null

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "noImplicitAny": true
  }
}

// 对关键业务类型使用品牌类型
type UserID = Brand<string, "UserID">
type OrderID = Brand<string, "OrderID">
type CNY = Brand<number, "CNY">
 
// 避免类型混用
function processUser(id: UserID) { /* ... */ }
function processOrder(id: OrderID) { /* ... */ }
 
const userId = createBrand("user-123", "UserID")
const orderId = createBrand("order-456", "OrderID")
 
processUser(userId) // OK
// processUser(orderId) // Error

// ✅ 正确：从具体到宽泛
function process(value: string): string
function process(value: number): number
function process(value: string | number): string | number {
  return value
}
 
// ❌ 错误：顺序反了
function process(value: string | number): string | number
function process(value: string): string
function process(value: number): number

// 使用类型断言
import { SomeType } from 'third-party-lib'
 
interface MyType {
  id: string
}
 
const myData = thirdPartyData as unknown as MyType
 
// 或使用模块扩展
declare module 'third-party-lib' {
  interface SomeType {
    customProperty?: string
  }
}