---
id: wiki-2026-0508-typescript-타입-시스템-typescript-typ
title: TypeScript 타입 시스템 (TypeScript Type System)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [TypeScript Type System, TS Types, 타입 시스템]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [typescript, types, frontend, language]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: TypeScript
  framework: TypeScript 5.7
---

# TypeScript 타입 시스템 (TypeScript Type System)

## 매 한 줄
> **"매 structural typing 위에 매 set-theoretic 연산을 얹은 gradual type system"**. 매 JavaScript 의 동적 본질을 유지하면서 매 compile-time guarantee 를 더한다. 매 2026 기준 TS 5.7 은 매 inference, narrowing, conditional types 의 매 강력한 조합으로 매 frontend / Node / Bun 생태계의 매 사실상 표준이다.

## 매 핵심

### 매 Structural typing
- 매 nominal 아닌 shape 기준 호환성.
- 매 duck typing 의 compile-time 버전.
- 매 `interface` / `type` 의 매 동등 (extension semantic 차이만).

### 매 Set-theoretic 연산
- Union `A | B`, Intersection `A & B`.
- `never` (empty), `unknown` (top), `any` (escape hatch).
- 매 narrowing 으로 매 union 좁히기.

### 매 응용
1. API contract — request/response shape.
2. State machine — discriminated union.
3. DSL — template literal types.

## 💻 패턴

### Discriminated union + exhaustive check
```typescript
type Result<T> =
  | { kind: 'ok'; value: T }
  | { kind: 'err'; error: Error };

function unwrap<T>(r: Result<T>): T {
  switch (r.kind) {
    case 'ok': return r.value;
    case 'err': throw r.error;
    default: {
      const _exhaustive: never = r;
      return _exhaustive;
    }
  }
}
```

### Generic constraint
```typescript
function pluck<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const u = { id: 1, name: 'a' };
pluck(u, 'name'); // string
```

### Conditional + infer
```typescript
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
```

### Template literal type
```typescript
type Route = `/api/${'users' | 'posts'}/${number}`;
const r1: Route = '/api/users/42'; // ok
```

### Branded type for nominal
```typescript
type UserId = string & { readonly __brand: 'UserId' };
const make = (s: string) => s as UserId;
```

### satisfies (TS 4.9+)
```typescript
const config = {
  port: 3000,
  host: 'localhost'
} satisfies Record<string, string | number>;
// keeps literal types but validates shape
```

### const type parameters (TS 5.0+)
```typescript
function tuple<const T extends readonly unknown[]>(...args: T): T {
  return args;
}
const t = tuple('a', 1, true); // ['a', 1, true] not (string|number|boolean)[]
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 단일 shape, extension 가능 | `interface` |
| union / mapped / conditional | `type` |
| runtime validation | `zod` / `valibot` 와 매 infer |
| 외부 JS lib | `unknown` + type guard |

**기본값**: `type` 으로 시작, 매 extension 필요 시 `interface`.

## 🔗 Graph
- 부모: [[TypeScript]] · [[Type Theory]]
- 변형: [[TypeScript Utility Types (Record Readonly)]] · [[Branded-Types-for-Nominal-Typing]]
- 응용: [[TypeScript_Type_Safety]] · [[Discriminated Union]]
- Adjacent: [[Zod]] · [[JavaScript]]

## 🤖 LLM 활용
**언제**: 매 schema-driven code generation, 매 API client typing, 매 refactor.
**언제 X**: 매 1-shot prototype script — 매 `any` 가 더 빠름.

## ❌ 안티패턴
- **`any` 남용**: 매 type 시스템 의 의미 상실.
- **Type assertion `as`**: 매 진짜 narrowing 대체로 사용.
- **Excessive generic**: 매 4개 이상의 type parameter — 매 readability 폭망.

## 🧪 검증 / 중복
- Verified (TypeScript Handbook, microsoft/TypeScript v5.7 docs).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — TS 5.7 structural + set-theoretic 정리 |
