---
id: wiki-2026-0508-약한-타입-탐지-weak-type-detection
title: 약한 타입 탐지 (Weak Type Detection)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Weak Types, TypeScript Weak Type, Empty-like Type Detection]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [typescript, type-system, weak-types, type-safety]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: TypeScript
  framework: TypeScript 5.7+
---

# 약한 타입 탐지 (Weak Type Detection)

## 매 한 줄
> **"매 모든 property 가 optional 인 type — 매 거의 모든 object 와 assignable 한 위험한 type"**. TypeScript 가 weak type 을 special-case 로 인식해 매 disjoint object 와의 assignment 를 차단하는 기능. 매 config object, 매 settings, 매 partial DTO 에서 매 silent typo bug 차단.

## 매 핵심

### 매 정의
- **Weak type**: 매 모든 member 가 optional 한 object type.
  ```ts
  interface Options {
    timeout?: number;
    retries?: number;
    debug?: boolean;
  }
  ```
- 매 normal structural rule 에 따르면 매 `{}` 도 매 `Options` 와 호환.
- TS 가 매 special rule — 매 source object 가 매 weak type 의 어떤 property 도 매 안 가지면 매 error.

### 매 동작
```ts
const opts: Options = { timoeut: 100 };  // 매 typo
// 매 Error: Object literal may only specify known properties...
//        AND
// 매 Type {} has no properties in common with type Options
```

### 매 응용
1. Config / settings object — 매 typo prevention.
2. Partial DTO update.
3. CSS-in-JS style props.
4. Plugin options.

## 💻 패턴

### Basic weak type
```ts
interface FetchOptions {
  timeout?: number;
  retries?: number;
  signal?: AbortSignal;
}

function fetchWith(url: string, opts: FetchOptions) { /* ... */ }

fetchWith("/api", { timeout: 5000 });           // 매 ok
fetchWith("/api", { timoeut: 5000 });           // 매 error — 매 unknown property
fetchWith("/api", {});                          // 매 ok — 매 모두 optional 이므로
fetchWith("/api", { foo: 1 } as any);           // 매 escape hatch (매 X 권장)
```

### Weak type detection in lib code
```ts
// 매 utility — 매 type 이 weak 인지 compile-time check
type IsWeakType<T> = {} extends T
  ? keyof T extends never ? false : true
  : false;

type CheckOpts = IsWeakType<FetchOptions>;  // 매 true
type CheckUser = IsWeakType<{ id: string; name: string }>;  // 매 false
```

### Required + Optional 명확 분리
```ts
// 매 weak type 위험 회피 — 매 최소 1 required
interface SafeConfig {
  endpoint: string;        // 매 required
  timeout?: number;
  retries?: number;
}

const c: SafeConfig = { endpoint: "/api" };
```

### Discriminated union 으로 weak type 회피
```ts
type Config =
  | { mode: "polling"; intervalMs: number }
  | { mode: "websocket"; url: string }
  | { mode: "sse"; endpoint: string };

function start(c: Config) {
  switch (c.mode) {
    case "polling": return startPolling(c.intervalMs);
    case "websocket": return startWS(c.url);
    case "sse": return startSSE(c.endpoint);
  }
}

start({ mode: "polling", intervalMs: 1000 });
start({});  // 매 error — 매 discriminator 없음
```

### Brand to forbid empty object assignment
```ts
import { Brand } from "effect";
type ValidatedOptions = FetchOptions & Brand.Brand<"ValidatedOptions">;

function validateOpts(o: FetchOptions): ValidatedOptions {
  if (Object.keys(o).length === 0)
    throw new Error("at least one option required");
  return o as ValidatedOptions;
}

function fetchStrict(url: string, opts: ValidatedOptions) { /* ... */ }
fetchStrict("/api", validateOpts({ timeout: 5000 }));  // 매 ok
fetchStrict("/api", {});                               // 매 type error
```

### ESLint rule 매 weak type 사용 보강
```jsonc
{
  "rules": {
    "@typescript-eslint/no-misused-promises": "error",
    "@typescript-eslint/strict-boolean-expressions": "error",
    "@typescript-eslint/no-empty-object-type": "error"
  }
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 완전 optional config | Weak type (TS native check 활용) |
| 매 1+ required 명시 가능 | Required + optional 분리 |
| 매 mode-dependent options | Discriminated union |
| 매 strict validation 필요 | Brand + smart constructor |
| 매 plugin/3rd-party 매 default | Required + optional |

**기본값**: 매 1+ required field 추가. 매 truly all-optional 매 weak type detection 의존.

## 🔗 Graph
- 부모: [[TypeScript Type System]] · [[Structural Typing]]
- 변형: [[Excess Property Check]] · [[Discriminated Union]]
- 응용: [[Config Object Pattern]] · [[Plugin Options]] · [[Partial DTO]]
- Adjacent: [[브랜디드 타입 (Branded Types)]] · [[Type Narrowing]] · [[안전한 TypeScript 데이터 모델링 및 설정 관리 구축]]

## 🤖 LLM 활용
**언제**: 매 config / options object 설계, 매 typo prevention 강조, 매 plugin API 설계.
**언제 X**: 매 internal data, 매 1-callsite, 매 typing overhead > value.

## ❌ 안티패턴
- **All-optional 매 무지각 사용**: 매 weak type protection 우연 의존 — 매 명시적 required 1 권장.
- **`as any` 우회**: 매 weak type error 매 cast 로 무시 — 매 typo 통과.
- **Object spread 매 weak type 회피**: 매 `{...userInput}` 매 typed 안 됨.
- **Optional 만의 enum-like**: 매 mode 분기 매 optional bool — 매 discriminated union 사용.

## 🧪 검증 / 중복
- Verified (TypeScript Handbook "Weak Types", TS 2.4 release notes, Marius Schulz blog).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — weak type 정의 + 회피 패턴 6개 |
