InflearnTS Chapter 28~32 - YDP-SPLOUNGE-CLUB/typescript-study GitHub Wiki

interface Profile {
  name?: string,
  age?: number,
  married?: boolean,
}

const zeroCho: Required<Profile> = {
  name: 'zero',
  age: 29,
  married: false,
}

// 직접 Requried 를 구현해보자.

type R<T> = {
  [Key in keyof T]-?: T[Key];
}

const zeroCho2: R<Profile> = {
  name: 'zero',
  age: 29,
  married: false,
}

interface Profile {
  name?: string,
  age?: number,
  married?: boolean,
}

type R<T> = {
  -readonly [Key in keyof T]: T[Key];
}

interface Obj {
  [key: string]: number;
};

// 동일
const a: Record<string, number> = {a: 3}

// Record 를 직접 만들어보자.

type R<T extends keyof any, S> = {
  [Key in T]: S;
}

type A = string | null | undefined | boolean | number;
type B = NonNullable<A>; // string boolean number;

// 직접 만들어보자

type N<T> = T extends null | undefined ? never: T;

function zip(x: number, y: string, z: boolean): {
  x: number,
  y: string,
  z: boolean
} {
  return { x, y, z }; 
}

// zip 의 파라미터들에게 접근 가능하다.
type Params = Parameters<typeof zip>;

// 또한 Parmas 는 리스트형이기 떄문에 [0] x: number 에 접근 가능하다.
type First = Params[0];

function zip(x: number, y: string, z: boolean): {
  x: number,
  y: string,
  z: boolean
} {
  return { x, y, z }; 
}

// infer 란 추론이란 뜻이다.

// Paramemter 를 의미하는 P 함수는 infer A [parameter] 를 추론한다.
type P<T extends (...args: any) => any> = T extends (...args: infer A) => any ? A : never;

// ReturnType 를 의미하는 R 함수는 infer A [returns 출력값] 를 추론한다.
type R<T extends (...args: any) => any> = T extends (...args: any) => infer A ? A : never;

type Params = P<typeof zip>;
// 다음과 같다.
// [x: number, y: string, z: boolean]
type Returns = R<typeof zip>;
// 다음과 같다.
// type Returns = {
//   x: number;
//   y: string;
//   z: boolean;
// }

class A {
  a: string;
  b: number;
  c: boolean;

  constructor(a: string, b: number, c: boolean) {
    this.a = a;
    this.b = b;
    this.c = c;
  }
}

const c = new A('123', 345, true);

// ConstructorParameter 를 infer 로 추론하여 가져온다.
type C = ConstructorParameters<typeof A>;
// 다음과 같다. [a: string, b: number, c: boolean]

// Instance 자체를 추론해서 가져온다.
type I = InstanceType<typeof A>;
// 다음과 같다. A


type C2<T extends abstract new (...args: any) => any> =
  T extends abstract new (...args: infer P) => any ? P : never;

type I2<T extends abstract new (...args :any) => any> =
  T extends abstract new (...args: any) => infer I ? I : never;

const p1 = Promise.resolve(1).then((a) => a + 1).then((a) => a + 1).then((a) => a.toString());
const p2 = Promise.resolve(2);
const p3 = new Promise((res, rej) => {
  setTimeout(res, 1000);
});

Promise.all([p1, p2, p3]).then((result) => {
  console.log(result); // 타입 추론 [string, number, unknown]
});

all<T extends readonly unknown[] | []>(values: T): Promise<{-readonly [P in keyof T]: Awaited<T[P]>}>;

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): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
      F extends ((value: infer V, ...args: any) => 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

const a = [1,2,3, [1,2], [[1], [2]]].flat(); // (number| number[])[]
const a2 = [1,2,3, [1,2], [[1], [2]]].flat(2); // number[]

type FlatArray<Arr, Depth extends number> = {
  "done": Arr,
  "recur": Arr extends ReadonlyArray<infer InnerArr>
      ? FlatArray<InnerArr, [-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20][Depth]>
      : Arr
}[Depth extends -1 ? "done": "recur"];

// 해당 함수에서 infer InnerArr 는 리스트 안쪽에 있는 배열들이다.
// infer InnerArr = number, number[], number[][]

const a = [1,2,3, [1,2], [[1], [2]]].flat(2);