TypeScript 개념 정리 - 조건부 타입

조건부 타입

type A = number extends string ? sring : number; // number

type objA = {
  a: number;
}

type objB = {
 a: number;
 b: number;
}

type B = objB extends objA ? number : string; // number

// 제네릭과 조건부 타입
type StringNumberSwitch<T> = T extends number ? string : number;

let varA: StringNumberSwitch<number>; // string
let varB: StringNumberSwitch<string>; // number

function removeSpaces<T>(text: T):T extends string ? string : undefined;
function removeSpaces(text: any) {
 if(typeof text === 'string') {
   return text.replaceAll(' ', '');
 }
 else {
   return undefined;
 }
}

let result = removeSpaces('hi im sooyeon');
result.toUpperCase();

let result2 = removeSpaces(undefined);

분산적인 조건부 타입

// 제네릭과 조건부 타입
type StringNumberSwitch<T> = T extends number ? string : number;

let c: StringNumberSwitch<number | string>; // number | string
// 한 번은 StringNumberSwitch<number>만 전달이 되고
// 한 번은 StringNumberSwitch<string>만 전달이 된다.
// 두 개의 타입이 | 유니온으로 묶이게 되는 것이다.

let d: StringNumberSwitch<boolean | numer | string>;
// number | string | number
// number | string

type Exclude<T, U> = T extends U ? never : T;
type A = Exclude<number | string | boolean, string>;
// 1. Exclude<number, string> |
// 2. Exclude<string, string> |
// 3. Exclude<boolean, string>
// 4. number | never | boolean
// 5. number | boolean

type Extract<T, U> = T extends U ? T : never;
type B = Extract<number | string | boolean, string>;
// 1. Extract<number, string> |
// 2. Extract<string, string> |
// 3. Extract<boolean, string>
// 4. never | string | never
// 5. string

infer

inference(추론)의 줄임말이다.
타입을 추론해 대입해주며, 참이 되는 타입으로 추론된다.

type FuncA = () => string;
type FuncB = () => number;
type ReturnType<T> = T extends () => string ? string : never;

type A = ReturnType<FuncA>; // string
type B = ReturnType<FuncB>; // never

type ReturnType<T> = T extends () => infer R ? R : never;
type A = ReturnType<FuncA>; // string
type B = ReturnType<FuncB>; // number
// 조건식이 참이되게 하는 타입이 R로 된다.

type C = ReturnType<number>; // never
// R 타입이 뭐가 되도 참이 될 수 없음
// number가 () => R의 서브 타입이 되는 참이 없음

type PromiseUnpack<T> = T extends Promise<infer R> ? R : never;
type PromiseA = PromiseUnpack<Promise<number>>; // number
type PromiseB = PromiseUnpack<Promise<string>>; // string