补充-1

1. unknown 类型

export default {};

// 1.任何类型都可以赋值给unknown类型
let str: unknown;
str = 18;
str = "张馨予";
str = false;
str = [1, 2, 3];

// 2.不能将unknown类型赋值给其他类型
let val: unknown = 18;
let num: number;
// num = val;
// 解决方案
// 1.使用类型断言
// num = val as number;
// console.log(num);
// 2.使用类型缩小
// if(typeof val == "number") {
//   num = val;
// }

// 3.unknown与其他任何类型组成的交叉类型最后都是其他类型
// &  交叉类型
type MyType1 = number & unknown;
type MyType2 = unknown & boolean;
let a: MyType1 = 18;
let b: MyType2 = true;

// 4.unknown除了与any以外, 与其他任何类型组成的联合类型都是unknown类型
type MyType3 = unknown | any;
type MyType4 = unknown | number;
type MyType5 = unknown | string | boolean;

let c: MyType3; // any类型
let d: MyType4;
let e: MyType5;

// 5.never类型都是unknown类型的子类型
type MyType6 = never extends unknown ? true : false;

2. map 类型

export default {};

// 创建
let nameSiteMapping = new Map();

// 设置
nameSiteMapping.set("邱淑贞", 1);
nameSiteMapping.set("宋茜", 2);
nameSiteMapping.set("景甜", 3);

// 获取键队友的值
// console.log(nameSiteMapping.get("景甜"));

// // 判断 map 中是否包含键队友的值
// console.log(nameSiteMapping.has("宋茜")); //  true
// console.log(nameSiteMapping.has("刘亦菲")); // false

// // f返回 map 对象键/值的数量
// console.log(nameSiteMapping.size);

// // 删除
// console.log(nameSiteMapping.delete("景甜"));
// console.log(nameSiteMapping);

// 可迭代
for (let key of nameSiteMapping.keys()) {
  console.log(key);
}

for (let value of nameSiteMapping.values()) {
  console.log(value);
}

for (let entry of nameSiteMapping.entries()) {
  console.log(entry); // [ '邱淑贞', 1 ]
}

for (let [key, value] of nameSiteMapping) {
  console.log(key, value); // 邱淑贞 1
}

3. 索引类型

export default {};

// class Person {
//   name: string;
//   age: number;
// }

// type MyType = Person["name"];
// let a: MyType = "赵韩樱子";
// console.log(a);

// 需求：获取指定的对象, 它的部分属性, 将结果放在数组返回
let obj = {
  name: "吴倩",
  age: 18,
  sex: true,
};

// obj[name]   obj[age]
function getValues<T, K extends keyof T>(obj: T, keys: K[]): T[K][] {
  let arr = [] as T[K][];

  keys.forEach((key) => {
    arr.push(obj[key]);
  });

  return arr;
}

let res = getValues(obj, ["name", "age"]);
console.log(res);

4. 条件类型

export default {};

// 1.条件类型基本使用
// type MyType<T> = T extends string ? string : any;
// type res = MyType<boolean>

// 2.函数重载
// interface IName {
//   name: string;
// }

// interface IAge {
//   age: number;
// }

// function reLoad(name: string): IName;
// function reLoad(age: number): IAge;
// function reLoad(nameorAge: string | number): IName | IAge;

// function reLoad(nameorAge: string | number): IName | IAge {
//   throw ""
// }

// 3.条件类型优化函数重载
interface IName {
  name: string;
}

interface IAge {
  age: number;
}

type Condition<T> = T extends string ? IName : IAge;

function reLoad<T extends number | string>(nameOrAge: T): Condition<T> {
  throw "";
}

reLoad("王丽坤");
reLoad(100);

5. 分布式条件类型

export default {};

// type MyType<T> = T extends any ? T : never;
// type res = MyType<string | number | boolean>;

// 从 T 中提出可以赋值给U的类型. Exclude
// type res = Exclude<string | number | boolean, boolean | number>;

// 从中剔除null和undefined  NonNullable
// type res = NonNullable<string | number | boolean | null | undefined>;

// 获取函数返回值类型  ReturnType
// type res = ReturnType<() => string>;

// 获取一个类的构造函数组成的元组类型  ConstructorParamsters
// class Person {
//   constructor(name: string, age: number) {}
// }

// type res = ConstructorParameters<typeof Person>;

// 获得函数的参数类型组成的元组类型  Parameters
// function show(name: string, age: number, sex: boolean) {

// }

// type res = Parameters<typeof show>;