<aside> 📌 조건에 따라 다른 타입이 되는 컨디셔널 타입

</aside>

interface Name {
	name: string;
}

interface Person {
	name: string;
	age: number;
}

interface Animal extends Name {
	age: number;
}

type A = Person extends Name ? string : number; // type A = string
type B = Animal extends Name ? string : number; // type B = string

• extends 는 해당 타입에 대입할 수 있는지 없는지로 판단함
  • 즉 type A 에서 Person 이 Name을 extends 해서 만든 인터페이스가 아님에도 Person이 Name에 대입 가능하므로 extends 한 것과 다름 없음

타입 검사를 위한 컨디셔널 타입

type HiString = 'hi' extends string ? true : false; // type HiString = true
type OneString = [1] extends [string] ? true : false; // type OneString = false

제네릭과 never 함께 사용하기

// 특정 타입이 아닌 경우 never 로 타입 지정하기 

type GenericArr<T> = T extends string ? string[] : never;
type StrArr = GenericArr<string>; // type StrArr = string[]
type Never = GenericArr<number>; // type Never = never
type Test = GenericArr<'hi'>; // type Test = string[]

// 특정 타입의 속성 제거하기

type OmitByType<O, T> = {
	[key in keyof O as O[key] extends T ? never : key]: O[key];
}

type NewType = OmitByType<{ // type NewType = { name: string; age: number; }
	name: string;
	age: number;
	isMarried: boolean;
	isStudent: boolean;
}, boolean>; // boolean 타입 속성 제거하기 

컨디셔널 타입 분배법칙

<aside> 📌 검사하는 타입이 제네릭이면서 유니언이면 분배법칙이 실행된다!!

(A | B) extends U ? X : Y
(A extends U ? X : Y) | (B extends U ? X : Y)

</aside>

예시

// CASE 1
type Animal = 'cat' | 'dog' | 'cow';
type Sound = Animal extends 'cat' ? 'meow' : 'moo'; // type Sound = 'moo'

// CASE 2
type Animal = 'cat' | 'dog' | 'cow';
type Sounds<T> = T extends 'cat' ? 'meow' : 'moo';
type Sound = Sounds<Animal>; // type Sound = 'meow' | 'moo'

• CASE 1

  • Animal 은 ‘cat’ ‘dog’ ‘cow’ 의 합집합
  • Animal 은 ‘cat’ 을 extends 할 수 없음 → 합집합이 더 넓으니까 moo 가 되는 것임

• CASE 2

  • Animal 은 제네릭으로 사용되기 때문에 ‘cat’ 또는 ‘dog’ 또는 ‘cow’ 가 됨
  • 검사하는 타입이 제네릭이면서 유니언이면 분배법칙이 실행됨
  • 즉, 다음과 같음

  
  'cat' extends 'cat' ? 'meow' : 'moo'; // 'meow'
  'dog' extends 'cat' ? 'meow' : 'moo'; // 'moo'
  'cow' extends 'cat' ? 'meow' : 'moo'; // 'moo'
  

[주의] boolean 분배법칙은 true | false

type Union = string | boolean | number;
type Type<T> = T extends string | boolean ? T[] : never;

let n: Type<Union> = ['hi']; // let n: string[] | true[] | false[]

• 제네릭으로 string | boolean | number 가 들어가면,
  • string extends string | boolean → true 이므로 string[]
  • number extends string | boolean → false 이므로 never
  • boolean extends string | boolean → true 이므로 boolean[] 인줄 알았지만? true[] | false[]
    • boolean을 true | false 로 인식하기 때문에 이런 문제가 발생함