typescript rank piece of high-level types and condition type (Readonly, Partial, Pick, Record)

This article in typescript everything as much as possible the official website to find the document, but different shades

Advanced Type

lib library of five senior type
all of the following examples begin with the person, for example

interface Person {
    name: string;
    age?: number;
}

Partial

Source:

type Partial<T> = {
    [P in keyof T]?: T[P];
};

Example:

type person2 = Partial<Person>;
// person2 === {name?: string; age?: number}

Required

Source:

type Required<T> = {
    [P in keyof T]-?: T[P];
};

Example:

type person3 = Required<Person>;
// person3 === {name: string; age: number}

Readonly

Source:

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

Example:

type person4 = Readonly<Person>;
// person4 === {
//        readonly name: string;
//        readonly age?: number;
//  }

Pick

Source:

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

Example:

type person5 = Pick<Person, "name">;
// person5 === {name: string}

Record

Source:

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

Example:

type person6 = Record<'name' | 'age', string>
// person6 === {name: string; age: string}

Condition Type

On condition type, the official website said very detailed, I'll just take over

type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"

type T02 = Exclude<string | number | (() => void), Function>;  // string | number
type T03 = Extract<string | number | (() => void), Function>;  // () => void

type T04 = NonNullable<string | number | undefined>;  // string | number
type T05 = NonNullable<(() => string) | string[] | null | undefined>;  // (() => string) | string[]

function f1(s: string) {
    return { a: 1, b: s };
}

class C {
    x = 0;
    y = 0;
}

type T10 = ReturnType<() => string>;  // string
type T11 = ReturnType<(s: string) => void>;  // void
type T12 = ReturnType<(<T>() => T)>;  // {}
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
type T14 = ReturnType<typeof f1>;  // { a: number, b: string }
type T15 = ReturnType<any>;  // any
type T16 = ReturnType<never>;  // any
type T17 = ReturnType<string>;  // Error
type T18 = ReturnType<Function>;  // Error

type T20 = InstanceType<typeof C>;  // C
type T21 = InstanceType<any>;  // any
type T22 = InstanceType<never>;  // any
type T23 = InstanceType<string>;  // Error
type T24 = InstanceType<Function>;  // Error

Superior type and conditions of these types, if they can grasp, you will be able to travel to any ocean ts of the