ts泛型

可以粗暴理解为：封装一个万能方法，方便于各场景使用八～

// 通用
function log<T>(arg: T): T {
  console.log(arg);
  return arg;
}

function log1<T>(arg: Array<T>): T[] {
  console.log(arg);
  return arg;
}

function getProperty<T, K extends keyof T>(obj: T, key: K) {
  return obj[key];
}

const x = { a: 1, b: 2, c: 3, d: 4 };
console.log(getProperty(x, "a")); // 1
// console.log(getProperty(x, "m")); // Error: Argument of type '"m"' is not assignable to parameter of type '"a" | "b" | "c" | "d"'.

//在泛型中使用类型类型
// function create<Type>(ctor: { new (): Type }): Type {
//   return new ctor();
// }

class BeeKeeper {
  hasMask: boolean = true;
}
class ZooKeeper {
  nametag: string = "nametag";
}

class Animal {
  numLegs: number = 4;
}

class Bee extends Animal {
  keeper: BeeKeeper = new BeeKeeper();
}

class Lion extends Animal {
  keeper: ZooKeeper = new ZooKeeper();
}

function createInstance<A extends Animal>(c: new () => A): A {
  return new c();
}

createInstance(Lion).keeper.nametag;
createInstance(Bee).keeper.hasMask;
// createInstance(Lion).keeper.hasMask; // Error

// keyof 类型操作符
type Point = { x: number; y: number };
type P = keyof Point; // "x" | "y"
const p1: P = "x";
const p2: P = "y";

type Point1 = { x: number; y: number };
type P1 = keyof Point1; // "x" | "y"
const p3: P1 = "x";
const p4: P1 = "y";
// const p5: P1 = "z"; // Error

type Arrayish = { [n: number]: unknown };
type A = keyof Arrayish; // number
const a: A = 0;

type Mapish = { [k: string]: boolean };
type M = keyof Mapish; // string | number
const m: M = "a";
const m1: M = 0;
// const m2: M = true; // Error
// const m3: M = 42; // Error
// const m4: M = {}; // Error