[TypeScript] Type Aliases

TypeScript Type Alias, TypeScript type, TS type alias, type declaration, TS 타입 별칭

정의

Type Alias 는 타입에 이름을 붙이는 TypeScript 문법 (type Name = ...). Interface 는 객체 shape 만 표현하지만, type alias 는 모든 타입 표현식 (primitive, union, intersection, tuple, mapped, conditional 등) 에 이름을 붙일 수 있습니다.

기본 사용

type UserId = number;
type UserName = string;

type Point = {
  x: number;
  y: number;
};

type Callback = (result: string) => void;

type Direction = "north" | "south" | "east" | "west";

언제 type, 언제 interface

두 문법이 겹치는 영역이 넓지만, type 만 할 수 있는 것 이 많습니다.

type 만 할 수 있는 것

1. Primitive alias:

type EmailAddress = string;
type Duration = number;   // seconds

2. Union type:

type Status = "loading" | "success" | "error";
type Value = string | number | null;

3. Intersection type:

type Timestamped = {createdAt: Date; updatedAt: Date};
type User = {id: number; name: string};
type TimestampedUser = User & Timestamped;

4. Tuple:

type Point = [number, number];
type NamedPoint = [name: string, x: number, y: number];

5. Mapped type:

type ReadonlyUser = {readonly [K in keyof User]: User[K]};

6. Conditional type:

type Extract<T, U> = T extends U ? T : never;

7. Template literal type:

type Greeting = `Hello, ${string}`;

8. Utility type composition:

type PartialUser = Partial<User>;
type UserKeys = keyof User;

interface 만 할 수 있는 것

1. Declaration merging:

interface Window { myGlobal: string }
interface Window { another: number }
// = merged

2. Module augmentation (라이브러리 확장):

declare module "express" {
  interface Request {
    userId?: string;
  }
}

3. class implements 에 잘 맞음 (type 도 되지만 관용은 interface).

관용 선택 규칙

1. Object shape 이고 확장 필요 없음 -> type
2. Object shape 이고 declaration merging 필요 -> interface
3. Primitive alias, tuple, union, intersection, mapped, conditional -> type
4. 라이브러리 사용자에게 확장 가능성 열어두기 -> interface
5. API response type (외부 데이터) -> type (zod schema 와 짝)

일관성 있게 선택. 팀 프로젝트는 한 스타일로 통일 이 무엇보다 중요 (ESLint 로 강제 가능).

Type Alias 는 새 타입이 아님

type UserId = number;
type ProductId = number;

const uid: UserId = 1;
const pid: ProductId = uid;   // OK! 둘 다 그냥 number

Type alias 는 별칭 이지 새 nominal type 이 아닙니다. 진짜 구분이 필요하면 branded type:

type Brand<T, B> = T & {__brand: B};
type UserId = Brand<number, "UserId">;
type ProductId = Brand<number, "ProductId">;

function createUserId(n: number): UserId { return n as UserId; }
function createProductId(n: number): ProductId { return n as ProductId; }

const uid = createUserId(1);
const pid: ProductId = uid;   // 오류

__brand 는 실제 필드가 아님 (컴파일 시 삭제). 순수 타입 트릭.

Generic Type Alias

type Nullable<T> = T | null;
type Optional<T> = T | undefined;
type Maybe<T> = T | null | undefined;

type ApiResponse<T> = {
  status: "ok" | "error";
  data?: T;
  error?: string;
};

type PromiseOrValue<T> = T | Promise<T>;

자세한 것은 Generics 참조.

Recursive Type Alias

type Json =
  | string
  | number
  | boolean
  | null
  | Json[]
  | {[key: string]: Json};

const value: Json = {
  name: "kim",
  age: 30,
  hobbies: ["read", "hike"],
  meta: {active: true},
};

Tree 구조도 재귀 표현:

type TreeNode<T> = {
  value: T;
  children: TreeNode<T>[];
};

Discriminated Union

type Shape =
  | {kind: "circle"; radius: number}
  | {kind: "square"; side: number}
  | {kind: "rectangle"; width: number; height: number};

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2;
    case "square": return s.side ** 2;
    case "rectangle": return s.width * s.height;
  }
}

kind 필드 (discriminant) 로 union 을 좁힘. TypeScript 가 각 case 에서 정확한 타입으로 narrow.

자세한 것은 Type Narrowing 참조.

Function Type

type Handler = (event: Event) => void;
type Predicate<T> = (item: T) => boolean;
type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
type Middleware = (req: Request, res: Response, next: () => void) => void;

Generic:

type Mapper<T, U> = (item: T) => U;

const toString: Mapper<number, string> = (n) => n.toString();

Type Alias 안에서 keyof, typeof

type User = {id: number; name: string; email: string};

type UserKeys = keyof User;                    // "id" | "name" | "email"
type UserValues = User[keyof User];            // number | string
type UserIdType = User["id"];                  // number

// typeof 로 값에서 타입 추출
const CONFIG = {host: "localhost", port: 8080} as const;
type Config = typeof CONFIG;                   // {readonly host: "localhost", readonly port: 8080}
type ConfigKeys = keyof typeof CONFIG;         // "host" | "port"

as const 는 리터럴 타입 유지에 매우 유용.

Mapped Type

Object 의 모든 필드를 변형:

type Readonly<T> = {readonly [K in keyof T]: T[K]};
type Partial<T> = {[K in keyof T]?: T[K]};
type Required<T> = {[K in keyof T]-?: T[K]};
type Nullable<T> = {[K in keyof T]: T[K] | null};

자세한 것은 Mapped Types 참조.

Conditional Type

type IsString<T> = T extends string ? true : false;
type A = IsString<"hi">;      // true
type B = IsString<42>;         // false

type ReturnType<F> = F extends (...args: any[]) => infer R ? R : never;
type X = ReturnType<() => number>;    // number

자세한 것은 Conditional Types 참조.

Template Literal Type

type Greeting = `Hello, ${string}`;
type CssUnit = `${number}${"px" | "em" | "%"}`;

type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<"click">;         // "onClick"

자세한 것은 Template Literal Types 참조.

Utility Type Composition

type User = {id: number; email: string; password: string; role: string};

type UserPublic = Omit<User, "password">;
type UserUpdate = Partial<Omit<User, "id">>;
type UserRole = Pick<User, "role">;
type UserKeys = keyof User;

자세한 것은 Utility Types 참조.

Type Alias 성능

같은 표현식을 여러 곳에서 반복하지 말고 alias 로 이름 붙이는 편이 컴파일 성능에 유리. 특히 mapped/conditional 조합은 캐시 히트가 중요.

// 반복 확장 (느림)
type A = {x: {a: number; b: string}; y: {a: number; b: string}; z: {a: number; b: string}};

// alias 로 캐시 (빠름)
type Inner = {a: number; b: string};
type A = {x: Inner; y: Inner; z: Inner};

함정

관련 위키

• TypeScript - 상위 개요
• Interfaces - 대비 개념
• Generics
• Primitive Types
• Union / Intersection
• Type Narrowing - Discriminated union
• Mapped Types
• Conditional Types
• Template Literal Types
• Utility Types
• Enums - Literal union 대안