비용이 큰 형식 연산 피하기

타입 연산의 처리 비용이 커지는 이유

// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;

지나치게 큰 유니온 피하기

// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }

복잡한 타입 별칭보다 인터페이스 선호

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

재귀 깊이 제한

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

중간 타입 캐시

// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;

// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;

큰 객체에 깊은 매핑 타입 적용 피하기

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

지연 제네릭 평가 사용

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

명시적 반환 타입 선호

// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }

// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }

병렬 검사를 위한 isolatedDeclarations

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

격리를 위한 프로젝트 참조

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

처리 비용이 큰 타입 피하기 요약

빠른 확인

배운 내용