TypeScript疑惑记录

TypeScript遇到问题的个人心得记录📝。

in关键字

in关键字，在文档上基本上找不到描述，在stackoverflow找到一些：相当于js里面的in操作符。

在interface可以这样用

interface Person {
    name: string,
    age: number
}
// 把所有Person key继承过来并且变成可选
type Partial<T> = {
  [P in keyof T]?: T[P];
}
type PersonPartial = Partial<Person>
const p: PersonPartial = {} // 不会报错

keyof关键字

interface Human {
    name: string,
    age: number
}

type HumanName = keyof Human
// 相当于联合类型type HumanName = 'name' | age

infer关键字

PR

表示推断的类型。举个例子，一般我们声明泛型都是interface Animal<T, U>，但是infer可以不必显示传入，而是推断一个泛型。举个例子：

interface Unpack<T> {
    T extends () => infer U ? U : T
}
// 我们会声明这样的变量

type unpack1 = Unpack<string> // string
type unpack2 = Unpack<() => number> // number

翻译成人话：如果传入的泛型 T 是一个函数，那么返回该函数推断出来的返回值 U，否则返回泛型T。

type和interface的区别？

stackoverflow

1. 对于函数/对象，2者使用没有太大的区别。

2. 其他情况有所考究：

// 1. interface不能声明联合类型 type可以
type Shape = Circle | Square

// 2. primitive
type Name = string;

// 3. tuple
type Data = [string, number]

3. 继承extend

// interface 继承
interface Animal {
    name: string
}
// 相当于既有name属性又有age属性
interface Human extends Animal {
    age: number
}

// type 继承 相当于以上
type Animal = { name: string }
type Human = { age: number } & Animal

// interface 继承type
type Animal = { name: string }
interface Human extends Animal {
    age: number
}

// type 继承interface
interface Animal {
    name: string
}
type Human = Animal & { age: number }

4. implements

对于对象而言没有什么区别。但是对于联合类型union。

type PartialPoint = { x: number; } | { y: number; };

// FIXME: can not implement a union type
// error
class SomePartialPoint implements PartialPoint {
  x = 1;
  y = 2;
}

5. 声明合并

// These two declarations become:
// interface Point { x: number; y: number; }
interface Point { x: number; }
interface Point { y: number; }
const point: Point = { x: 1, y: 2 };

Exclude

type Props = 'name' | 'age' | 'sex'

// Exclude<Props, 'name'>
// result: 'age' | sex

Exclude<T, U> = T extends U ? never : T

// 反过来Include

Include<T, U> = T extends U ? T : never

Pick

// Pick<{ name: string, age: number, sex: number }, 'name' | 'age'>
// result: { name: string, age: number }

// T:object interface。K union type
type Pick<T, K extends keyof T> = {
    [P in K]: T[P]
}

Omit

// example
// Omit<{ name: string, age: number, sex: number }, 'age' | sex>
// result { name: string }
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;