Unknown & any

unknown is the parent type of all other types. it's a regular type in the type system.

any means "disable the type check". it's a compiler directive.

Extends

这东西可以被用在 interface，也可以被用在 Generic type 里，其中后者的理解和 java 中差不多。

例子：

interface BasicAddress {
  name?: string;
  street: string;
  city: string;
  country: string;
  postalCode: string;
}
interface AddressWithUnit extends BasicAddress {
  unit: string;
}

此时的作用是声明 AddressWithUnit 扩充自 BasicAddress。

例子：

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

这是 TS 里工具类 Pick 的定义，注意到 K extends keyof T 这里的 K 必须是 keyof T 的子集。

因为这里如果我按照位置信息去理解的话会有点奇怪，如果按我之前的理解 K 应该作为 keyof T 的超集才对，但是明显，这里指的是它的子集。

此外注意，这里例子中的 K 是一种 Union Type，而不是我们常见的 Object Type。

这很关键，因为 { name: string, age: number } extends { name: string } 是 true。而 x | y extends x 是 false 因为前者更加泛化，而对于前面的 object 的，左侧更加具化。详情看这里。

Infer

最近在研究 TS 的工具类，由于在项目中没怎么用到，根本不熟悉，感觉还是挺有用的。

然后在看到 Awaited 时，想看一下实现方法，就看到了 Infer 发现很奇怪，根本看不懂是干嘛的：

/**
 * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
 */
type Awaited<T> = T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
    T extends object & { then(onfulfilled: infer F, ...args: infer _): any; } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
        F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
            Awaited<V> : // recursively unwrap the value
        never : // the argument to `then` was not callable
    T; // non-object or non-thenable

源码来自下面的链接：