TypeScript 高级类型

/**
 * @name        sfxATypes
 * @author      shenyc
 * @date        2021-08-09
 * @copyright   Copy right (c) shenyc (shenyczz@163.com).
 *              All rights reserved.
 * @remark      The Advance type in typeScript 
 * 
******************************************************************************/

// 避免把 TypeScript 写成 AnyScript：
// 当应用越来越复杂，我们很容易把一些变量设置为 any 类型，TypeScript 写着写着也就成了 AnyScript。

/**
 * 基础类型
 */
let b: Boolean = true;
let s: String = ''
let n: Number = 0;
let e: null = null;
let u: undefined = undefined;
let o: Object = {};

/**
 * 数组
 */
let as: String[] = [];
let ag: Array<Number> = [1, 2, 3];
let ai: Int16Array = new Int16Array();

/**
 * 接口
 */
interface IPerson {
    age: number;
    name: string;

}

/**
 * 类
 */
class Person implements IPerson {
    age: number;
    name: string;
}
class Famer extends Person { }

/**
 * 泛型
 */
function Foo<T>() {
    // console.log(typeof T);
}

/**
 * 高级类型 - 交叉类型（&）
 */
interface A { id: number; };
interface B { name: string; };
let tab: A & B = {
    id: 10,
    name: "123"
};

/**
 * 高级类型 - 联合类型（|）
 */
let tu: Boolean | Number | String;
tu = true;
tu = 1;
tu = "123";

/**
 * 高级类型 - 类型别名（type）
 */
type StringLike = String | String[];
let talias: StringLike = undefined;
talias = '0';
talias = ['', ''];

/**
 * 类型索引（keyof）
 */
interface Button {
    type: string;
    text: string;
}

type ButtonKeys = keyof Button;


/**
 * 类型约束（extends）
 */
function print<T extends String>(arg: T): void {
    console.log(arg);
}

// extends 经常与 keyof 一起使用，
// 例如我们有一个方法专门用来获取对象的值，但是这个对象并不确定，
// 我们就可以使用 extends 和 keyof 进行约束。
function getValue<T, K extends keyof T>(obj: T, key: K) {
    return obj[key]
}

const obj = { flag: 1 }
const a = getValue(obj, 'flag')

/**
 * 类型映射（in）
 * 
 * in 关键词的作用主要是做类型的映射，遍历已有接口的 key 或者是遍历联合类型。
 * 下面使用内置的泛型接口 Readonly 来举例。
 */

interface Obj {
    a: string
    b: string
}

type ReadOnlyObj = Readonly<Obj>

/**
 * 条件类型（U ? X : Y）
 */
type CommonKeys = Extract<keyof Person, keyof Famer>


/**
 * 工具泛型
 * 
 * TypesScript 中内置了很多工具泛型，前面介绍过 Readonly、Extract 这两种，
 * 内置的泛型在 TypeScript 内置的 lib.es5.d.ts 中都有定义，所以不需要任何依赖都是可以直接使用的。
 * 下面看看一些经常使用的工具泛型吧。
 */

/**
 * 工具泛型 - Partial
 * 用于将一个接口的所有属性设置为可选状态
 */
interface IMan {
    age: number;
    name: string;
}

let one: IMan = {
    // 必须设置所有属性
    age: 0,
    name: "one"
};

let two: Partial<IMan> = {
    // 所有属性都是可选属性
};


/**
 * 工具泛型 - Required
 *  * Required 的作用刚好与 Partial 相反，就是将接口中所有可选的属性改为必须的
 */
interface C {
    x?: number;
    s?: string;
}

let cobj1: C = {};
let cobj2: Required<C> = { x: 0, s: '', };

/**
 * Record
 * Record 接受两个类型变量，Record 生成的类型具有类型 K 中存在的属性，值为类型 T。
 * 这里有一个比较疑惑的点就是给类型 K 加一个类型约束，extends keyof any，我们可以先看看 keyof any 是个什么东西。
 */
interface Food {
    id: string
    name: string
    price: string
    image: string
}
const goodsMap: Record<string, Food> = {};
const goodsList: Food[] = [];

goodsList.forEach(food => {
    goodsMap[food.name] = food;
})


/**
 * Pick
 * Pick 主要用于提取接口的某几个属性。
 */
interface Todo {
    title: string
    completed: boolean
    description: string
}
type TodoPreview = Pick<Todo, "title" | "completed">;

const todo: TodoPreview = {
    title: 'Clean room',
    completed: false
}

/**
 * Exclude
 * Exclude 的作用与之前介绍过的 Extract 刚好相反, 如果 T 中的类型在 U 不存在，则返回，否则抛弃。
 */
interface Teacher {
    name: string
    age: number
    email: string
    salary: number
}

interface Student {
    name: string
    age: number
    email: string
    grade: number
}

type ExcludeKeys = Exclude<keyof Teacher, keyof Student>
// => salary, 取出的是 Teacher 在 Student 中不存在的 salary。 

/**
 * Omit
 * Omit 的作用刚好和 Pick 相反
 * 先通过 Exclude<keyof T, K> 先取出类型 T 中存在，但是 K 不存在的属性，
 * 然后再由这些属性构造一个新的类型。
 * 还是通过前面的 Todo 案例来说，TodoPreview 类型只需要排除接口的 description 属性即可，写法上比之前 Pick 精简了一些。
 */
interface Something {
    id: number;
    name: string;
    description: string;
}
type SomethingOmit = Omit<Something, "description">
// => SomethingOmit { id: number; name: string; }


/**
 * 最后是变量的类型
 */
let x: string = '123'
let xtype = typeof x;