์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐ŸŽฏ ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ ์—ด๊ฑฐํ˜• Enum๊ณผ const assertion์„ ํ†ตํ•œ ์ƒ์ˆ˜ ๊ด€๋ฆฌ

๐ŸŽฏ ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ ์—ด๊ฑฐํ˜• Enum๊ณผ const assertion์„ ํ†ตํ•œ ์ƒ์ˆ˜ ๊ด€๋ฆฌ

์นœ๊ตฌ์•ผ, ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ๋กœ ์ƒ์ˆ˜ ๊ด€๋ฆฌํ•˜๋Š” ๋ฒ• ์ œ๋Œ€๋กœ ์•Œ๋ ค์ค„๊ฒŒ! ๐Ÿš€

๐Ÿค” ์™œ ์ƒ์ˆ˜ ๊ด€๋ฆฌ๊ฐ€ ์ค‘์š”ํ• ๊นŒ?

์•ผ, ์ฝ”๋“œ ์งœ๋‹ค ๋ณด๋ฉด ์ด๋Ÿฐ ๊ฒฝํ—˜ ์žˆ์ง€ ์•Š์•„? "์ด ์ƒํƒœ๊ฐ’์ด 'pending'์ด์—ˆ๋‚˜ 'PENDING'์ด์—ˆ๋‚˜?" ํ•˜๋ฉด์„œ ๋‹ค๋ฅธ ํŒŒ์ผ ๋’ค์ ๊ฑฐ๋ฆฌ๋Š” ๊ฑฐ. ๐Ÿ˜…

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์ƒ์ˆ˜ ๊ด€๋ฆฌ๋Š” ์ง„์งœ ์ค‘์š”ํ•ด. ํŠนํžˆ ํ”„๋กœ์ ํŠธ๊ฐ€ ์ปค์งˆ์ˆ˜๋ก ๋ง์ด์•ผ. ์˜คํƒ€ ํ•˜๋‚˜๋กœ ๋ฒ„๊ทธ ์ฐพ๋А๋ผ ๋ฐค์ƒ ์ˆ˜๋„ ์žˆ๊ฑฐ๋“ !

๐Ÿ’ก ์ƒ์ˆ˜ ๊ด€๋ฆฌ๊ฐ€ ํ•„์š”ํ•œ ์ด์œ  1. ํƒ€์ž… ์•ˆ์ •์„ฑ: ์ปดํŒŒ์ผ ํƒ€์ž„์— ์˜ค๋ฅ˜๋ฅผ ์žก์„ ์ˆ˜ ์žˆ์–ด
2. ์ž๋™์™„์„ฑ: IDE๊ฐ€ ๊ฐ€๋Šฅํ•œ ๊ฐ’๋“ค์„ ์•Œ๋ ค์ค˜์„œ ๊ฐœ๋ฐœ ์†๋„ UP โšก
3. ์œ ์ง€๋ณด์ˆ˜: ๊ฐ’์„ ํ•œ ๊ณณ์—์„œ ๊ด€๋ฆฌํ•˜๋‹ˆ๊นŒ ๋ณ€๊ฒฝ์ด ์‰ฌ์›Œ
4. ๊ฐ€๋…์„ฑ: ๋งค์ง ๋„˜๋ฒ„๋‚˜ ๋งค์ง ์ŠคํŠธ๋ง ๋Œ€์‹  ์˜๋ฏธ์žˆ๋Š” ์ด๋ฆ„ ์‚ฌ์šฉ

ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ๋Š” ์ด๋Ÿฐ ์ƒ์ˆ˜ ๊ด€๋ฆฌ๋ฅผ ์œ„ํ•ด ์—ฌ๋Ÿฌ ๋ฐฉ๋ฒ•์„ ์ œ๊ณตํ•˜๋Š”๋ฐ, ์˜ค๋Š˜์€ ๊ทธ ์ค‘์—์„œ๋„ ๊ฐ€์žฅ ๋งŽ์ด ์“ฐ์ด๋Š” Enum๊ณผ const assertion์— ๋Œ€ํ•ด ๊นŠ์ด ํŒŒํ—ค์ณ๋ณผ ๊ฑฐ์•ผ! ๐Ÿ”

๐Ÿ“š Enum, ๋„ˆ๋Š” ๋ˆ„๊ตฌ๋ƒ?

Enum์€ "Enumeration(์—ด๊ฑฐ)"์˜ ์ค„์ž„๋ง์ด์•ผ. ์‰ฝ๊ฒŒ ๋งํ•˜๋ฉด ๊ด€๋ จ๋œ ์ƒ์ˆ˜๋“ค์˜ ์ง‘ํ•ฉ์„ ์ •์˜ํ•˜๋Š” ๊ฑฐ์ง€. ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ์—์„œ ์ œ๊ณตํ•˜๋Š” ๋ช‡ ์•ˆ ๋˜๋Š” ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ํ™•์žฅ ๊ธฐ๋Šฅ ์ค‘ ํ•˜๋‚˜์•ผ.

๐ŸŽจ ์ˆซ์žํ˜• Enum (Numeric Enum)

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ํ˜•ํƒœ๋ถ€ํ„ฐ ๋ณผ๊นŒ? ์ˆซ์žํ˜• Enum์€ ์ž๋™์œผ๋กœ 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ 1์”ฉ ์ฆ๊ฐ€ํ•˜๋Š” ๊ฐ’์„ ๊ฐ€์ ธ.

enum Direction {
  Up,      // 0
  Down,    // 1
  Left,    // 2
  Right    // 3
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
let playerDirection: Direction = Direction.Up;
console.log(playerDirection); // 0

// ๊ฐ’์œผ๋กœ ์ ‘๊ทผ๋„ ๊ฐ€๋Šฅ (์—ญ๋ฐฉํ–ฅ ๋งคํ•‘)
console.log(Direction[0]); // "Up"

์‹ ๊ธฐํ•˜์ง€? ๐Ÿ˜ฎ Direction.Up์€ 0์ด๊ณ , Direction[0]์€ "Up"์„ ๋ฐ˜ํ™˜ํ•ด. ์ด๊ฑธ ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘(Reverse Mapping)์ด๋ผ๊ณ  ํ•ด. ์ˆซ์žํ˜• Enum๋งŒ ๊ฐ€๋Šฅํ•œ ํŠน์ง•์ด์•ผ!

๐ŸŽฏ ์ดˆ๊ธฐ๊ฐ’ ์ง€์ •ํ•˜๊ธฐ

๋ฌผ๋ก  ์›ํ•˜๋Š” ์ˆซ์ž๋ถ€ํ„ฐ ์‹œ์ž‘ํ•  ์ˆ˜๋„ ์žˆ์–ด:
enum Status {
  Pending = 1,
  InProgress,  // 2
  Done         // 3
}

// ๋˜๋Š” ๊ฐ๊ฐ ๋‹ค๋ฅธ ๊ฐ’ ์ง€์ •
enum HttpStatus {
  OK = 200,
  NotFound = 404,
  ServerError = 500
}

๐Ÿ”ค ๋ฌธ์ž์—ด Enum (String Enum)

๊ฐœ์ธ์ ์œผ๋กœ ์‹ค๋ฌด์—์„œ ๋” ๋งŽ์ด ์“ฐ๋Š” ๊ฑด ๋ฌธ์ž์—ด Enum์ด์•ผ. ๋””๋ฒ„๊น…ํ•  ๋•Œ ๊ฐ’์ด ๋ช…ํ™•ํ•˜๊ฒŒ ๋ณด์ด๊ฑฐ๋“ ! ๐Ÿ‘€

enum UserRole {
  Admin = "ADMIN",
  Editor = "EDITOR",
  Viewer = "VIEWER"
}

function checkPermission(role: UserRole) {
  if (role === UserRole.Admin) {
    console.log("๋ชจ๋“  ๊ถŒํ•œ ์žˆ์Œ! ๐Ÿ”“");
  } else if (role === UserRole.Editor) {
    console.log("ํŽธ์ง‘ ๊ถŒํ•œ ์žˆ์Œ โœ๏ธ");
  } else {
    console.log("์ฝ๊ธฐ ์ „์šฉ ๐Ÿ‘€");
  }
}

checkPermission(UserRole.Admin);

๋ฌธ์ž์—ด Enum์€ ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘์ด ์•ˆ ๋ผ. ๋Œ€์‹  ๊ฐ’ ์ž์ฒด๊ฐ€ ์˜๋ฏธ์žˆ๋Š” ๋ฌธ์ž์—ด์ด๋ผ์„œ ๋กœ๊ทธ ์ฐ์„ ๋•Œ๋‚˜ API ์‘๋‹ต ๋ณผ ๋•Œ ํ›จ์”ฌ ์ดํ•ดํ•˜๊ธฐ ์‰ฌ์›Œ! ๐ŸŽฏ

๐ŸŽญ ์ด์ข… Enum (Heterogeneous Enum)

์ˆซ์ž์™€ ๋ฌธ์ž์—ด์„ ์„ž์–ด ์“ธ ์ˆ˜๋„ ์žˆ์–ด. ๊ทผ๋ฐ ์†”์งํžˆ ๋งํ•˜๋ฉด... ๋ณ„๋กœ ์ถ”์ฒœํ•˜์ง€ ์•Š์•„. ๐Ÿ˜… ํ˜ผ๋ž€์Šค๋Ÿฌ์šธ ์ˆ˜ ์žˆ๊ฑฐ๋“ .

enum Mixed {
  No = 0,
  Yes = "YES"
}

// ๊ฐ€๋Šฅ์€ ํ•˜์ง€๋งŒ... ์™œ ์ด๋ ‡๊ฒŒ ์“ฐ์ง€? ๐Ÿค”
Enum์˜ ์„ธ ๊ฐ€์ง€ ํƒ€์ž… ์ˆซ์žํ˜• Enum 0 1 2 ์ž๋™ ์ฆ๊ฐ€ ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๊ฐ€๋Šฅ ๋ฌธ์ž์—ด Enum ADMIN EDITOR VIEWER ๋ช…์‹œ์  ๊ฐ’ ์ง€์ • ๋””๋ฒ„๊น… ์šฉ์ด ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๋ถˆ๊ฐ€ ์ด์ข… Enum 0 YES 1 NO ์ˆซ์ž + ๋ฌธ์ž์—ด ํ˜ผํ•ฉ ๊ถŒ์žฅํ•˜์ง€ ์•Š์Œ ํ˜ผ๋ž€ ์•ผ๊ธฐ ๊ฐ€๋Šฅ

โš™๏ธ Enum์˜ ์ปดํŒŒ์ผ ๊ฒฐ๊ณผ์™€ ํŠน์ง•

์—ฌ๊ธฐ์„œ ์ค‘์š”ํ•œ ํฌ์ธํŠธ! ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ์˜ ๋Œ€๋ถ€๋ถ„ ๊ธฐ๋Šฅ์€ ์ปดํŒŒ์ผ ํ›„ ์‚ฌ๋ผ์ง€๋Š”๋ฐ, Enum์€ ์‹ค์ œ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ์ฝ”๋“œ๋กœ ๋ณ€ํ™˜๋ผ. ์ด๊ฒŒ ์žฅ์ ์ด์ž ๋‹จ์ ์ด ๋  ์ˆ˜ ์žˆ์–ด. ๐Ÿคทโ€โ™‚๏ธ

๐Ÿ“ฆ ์ˆซ์žํ˜• Enum์˜ ์ปดํŒŒ์ผ ๊ฒฐ๊ณผ

TypeScript ์ฝ”๋“œ
enum Direction {
  Up,
  Down,
  Left,
  Right
}
JavaScript ๊ฒฐ๊ณผ
var Direction;
(function (Direction) {
  Direction[Direction["Up"] = 0] = "Up";
  Direction[Direction["Down"] = 1] = "Down";
  Direction[Direction["Left"] = 2] = "Left";
  Direction[Direction["Right"] = 3] = "Right";
})(Direction || (Direction = {}));

์™€... ๋ณต์žกํ•ด ๋ณด์ด์ง€? ๐Ÿ˜ต ์ด๊ฒŒ ๋ฐ”๋กœ ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘์„ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ์‹์ด์•ผ. Direction["Up"] = 0์„ ํ• ๋‹นํ•˜๋ฉด์„œ ๋™์‹œ์— Direction[0] = "Up"๋„ ์„ค์ •ํ•˜๋Š” ๊ฑฐ์ง€.

๐Ÿ” ์‹ค์ œ ๊ฐ์ฒด ๊ตฌ์กฐ

์œ„ ์ฝ”๋“œ๊ฐ€ ๋งŒ๋“œ๋Š” Direction ๊ฐ์ฒด๋Š” ์ด๋ ‡๊ฒŒ ์ƒ๊ฒผ์–ด:
{
  0: "Up",
  1: "Down",
  2: "Left",
  3: "Right",
  Up: 0,
  Down: 1,
  Left: 2,
  Right: 3
}
์–‘๋ฐฉํ–ฅ์œผ๋กœ ์ ‘๊ทผ ๊ฐ€๋Šฅํ•œ ๊ตฌ์กฐ์•ผ! ๐Ÿ”„

๐ŸŽฏ const Enum - ์ตœ์ ํ™”์˜ ๋น„๋ฐ€

"Enum์ด ์ฝ”๋“œ๋ฅผ ์ƒ์„ฑํ•œ๋‹ค๊ณ ? ๋ฒˆ๋“ค ํฌ๊ธฐ๊ฐ€ ๊ฑฑ์ •๋˜๋Š”๋ฐ..." ํ•˜๋Š” ์นœ๊ตฌ๋“ค์„ ์œ„ํ•œ ํ•ด๊ฒฐ์ฑ…! const enum์„ ์“ฐ๋ฉด ์ปดํŒŒ์ผ ์‹œ ์ธ๋ผ์ธ์œผ๋กœ ์น˜ํ™˜๋ผ์„œ ์ถ”๊ฐ€ ์ฝ”๋“œ๊ฐ€ ์ƒ์„ฑ๋˜์ง€ ์•Š์•„. ๐Ÿš€

const enum Direction {
  Up,
  Down,
  Left,
  Right
}

let dir = Direction.Up;

// ์ปดํŒŒ์ผ ๊ฒฐ๊ณผ
let dir = 0; // ๊ทธ๋ƒฅ ๊ฐ’์œผ๋กœ ์น˜ํ™˜!

์™„์ „ ๊น”๋”ํ•˜์ง€? ๐Ÿ˜Ž ํ•˜์ง€๋งŒ ์ฃผ์˜ํ•  ์ ์ด ์žˆ์–ด:

โš ๏ธ const enum ์‚ฌ์šฉ ์‹œ ์ฃผ์˜์‚ฌํ•ญ

์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๋ถˆ๊ฐ€ ์™ธ๋ถ€ ๋ชจ๋“ˆ์—์„œ ์‚ฌ์šฉ ์ œํ•œ isolatedModules ์˜ต์…˜๊ณผ ์ถฉ๋Œ

ํŠนํžˆ Babel์„ ์‚ฌ์šฉํ•˜๋Š” ํ”„๋กœ์ ํŠธ์—์„œ๋Š” const enum์ด ์ œ๋Œ€๋กœ ๋™์ž‘ํ•˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ์–ด. ์ด๋Ÿด ๋• ์ผ๋ฐ˜ enum์ด๋‚˜ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์„ ๊ณ ๋ คํ•ด์•ผ ํ•ด!

๐ŸŽช Enum์˜ ์‹ค์ „ ํ™œ์šฉ ํŒจํ„ด

์ด๋ก ์€ ์ด์ œ ์ถฉ๋ถ„ํ•ด! ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ์“ฐ๋Š”์ง€ ๋ณด์ž๊ตฌ. ๐Ÿ’ช

๐ŸŽฎ ๊ฒŒ์ž„ ์ƒํƒœ ๊ด€๋ฆฌ

enum GameState {
  Menu = "MENU",
  Playing = "PLAYING",
  Paused = "PAUSED",
  GameOver = "GAME_OVER"
}

class Game {
  private state: GameState = GameState.Menu;
  
  start() {
    if (this.state === GameState.Menu) {
      this.state = GameState.Playing;
      console.log("๊ฒŒ์ž„ ์‹œ์ž‘! ๐ŸŽฎ");
    }
  }
  
  pause() {
    if (this.state === GameState.Playing) {
      this.state = GameState.Paused;
      console.log("์ผ์‹œ์ •์ง€ โธ๏ธ");
    }
  }
  
  resume() {
    if (this.state === GameState.Paused) {
      this.state = GameState.Playing;
      console.log("์žฌ๊ฐœ! โ–ถ๏ธ");
    }
  }
}

๐ŸŒ API ์‘๋‹ต ์ƒํƒœ ์ฝ”๋“œ

enum ApiStatus {
  Success = 200,
  Created = 201,
  BadRequest = 400,
  Unauthorized = 401,
  NotFound = 404,
  ServerError = 500
}

async function fetchData(url: string) {
  const response = await fetch(url);
  
  switch (response.status) {
    case ApiStatus.Success:
      return await response.json();
    case ApiStatus.NotFound:
      throw new Error("๋ฆฌ์†Œ์Šค๋ฅผ ์ฐพ์„ ์ˆ˜ ์—†์–ด์š” ๐Ÿ˜ข");
    case ApiStatus.ServerError:
      throw new Error("์„œ๋ฒ„ ์˜ค๋ฅ˜ ๋ฐœ์ƒ! ๐Ÿ”ฅ");
    default:
      throw new Error(`์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์ƒํƒœ: ${response.status}`);
  }
}

๐ŸŽจ ํ…Œ๋งˆ ๊ด€๋ฆฌ

enum Theme {
  Light = "light",
  Dark = "dark",
  Auto = "auto"
}

enum ColorScheme {
  Primary = "#6c5ce7",
  Secondary = "#74b9ff",
  Success = "#00b894",
  Warning = "#fdcb6e",
  Danger = "#d63031"
}

interface AppConfig {
  theme: Theme;
  primaryColor: ColorScheme;
}

const config: AppConfig = {
  theme: Theme.Dark,
  primaryColor: ColorScheme.Primary
};

์ด๋ ‡๊ฒŒ Enum์„ ์“ฐ๋ฉด IDE์—์„œ ์ž๋™์™„์„ฑ๋„ ๋˜๊ณ , ์˜คํƒ€ ๊ฑฑ์ •๋„ ์—†์–ด์„œ ๊ฐœ๋ฐœ์ด ์ •๋ง ํŽธํ•ด์ ธ! โœจ

๐Ÿ”ฅ const assertion - ํ˜„๋Œ€์ ์ธ ๋Œ€์•ˆ

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ const assertion์— ๋Œ€ํ•ด ์•Œ์•„๋ณผ ์‹œ๊ฐ„์ด์•ผ! ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ 3.4 ๋ฒ„์ „๋ถ€ํ„ฐ ๋„์ž…๋œ ์ด ๊ธฐ๋Šฅ์€ Enum์˜ ๋Œ€์•ˆ์œผ๋กœ ๋งŽ์ด ์‚ฌ์šฉ๋˜๊ณ  ์žˆ์–ด. ๐ŸŽฏ

๐Ÿคทโ€โ™‚๏ธ const assertion์ด ๋ญ”๋ฐ?

const assertion์€ as const๋ผ๋Š” ํ‚ค์›Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๊ฐ’์„ ๋ฆฌํ„ฐ๋Ÿด ํƒ€์ž…์œผ๋กœ ์ขํžˆ๊ณ  ์ฝ๊ธฐ ์ „์šฉ์œผ๋กœ ๋งŒ๋“œ๋Š” ๊ธฐ๋Šฅ์ด์•ผ. ๋ง์ด ์–ด๋ ต์ง€? ์˜ˆ์ œ๋ฅผ ๋ณด๋ฉด ๋ฐ”๋กœ ์ดํ•ด๋  ๊ฑฐ์•ผ! ๐Ÿ‘€

// ์ผ๋ฐ˜ ๊ฐ์ฒด
const colors1 = {
  red: "#ff0000",
  blue: "#0000ff"
};
// ํƒ€์ž…: { red: string; blue: string; }

// const assertion ์‚ฌ์šฉ
const colors2 = {
  red: "#ff0000",
  blue: "#0000ff"
} as const;
// ํƒ€์ž…: { readonly red: "#ff0000"; readonly blue: "#0000ff"; }

// ์ฐจ์ด์  ํ™•์ธ
colors1.red = "#ff1111"; // โœ… ๊ฐ€๋Šฅ
colors2.red = "#ff1111"; // โŒ ์—๋Ÿฌ! ์ฝ๊ธฐ ์ „์šฉ

๋ณด์ด์ง€? as const๋ฅผ ๋ถ™์ด๋ฉด ๊ฐ’์ด ์ •ํ™•ํ•œ ๋ฆฌํ„ฐ๋Ÿด ํƒ€์ž…์œผ๋กœ ์ถ”๋ก ๋˜๊ณ , ์ˆ˜์ •๋„ ๋ถˆ๊ฐ€๋Šฅํ•ด์ ธ! ๐Ÿ”’

๐Ÿ“‹ ๋ฐฐ์—ด์—์„œ์˜ const assertion

// ์ผ๋ฐ˜ ๋ฐฐ์—ด
const fruits1 = ["apple", "banana", "orange"];
// ํƒ€์ž…: string[]

// const assertion ์‚ฌ์šฉ
const fruits2 = ["apple", "banana", "orange"] as const;
// ํƒ€์ž…: readonly ["apple", "banana", "orange"]

// ํŠœํ”Œ์ฒ˜๋Ÿผ ๋™์ž‘!
const first: "apple" = fruits2[0]; // โœ…
const second: "banana" = fruits2[1]; // โœ…

fruits2.push("grape"); // โŒ ์—๋Ÿฌ! ์ฝ๊ธฐ ์ „์šฉ ๋ฐฐ์—ด

๐ŸŽฏ Enum ๋Œ€์‹  const assertion ์‚ฌ์šฉํ•˜๊ธฐ

์ด์ œ ํ•ต์‹ฌ์ด์•ผ! const assertion์œผ๋กœ Enum๊ณผ ๋น„์Šทํ•œ ํšจ๊ณผ๋ฅผ ๋‚ผ ์ˆ˜ ์žˆ์–ด. ๐Ÿ‘Š

Enum ๋ฐฉ์‹
enum UserRole {
  Admin = "ADMIN",
  Editor = "EDITOR",
  Viewer = "VIEWER"
}

function checkRole(role: UserRole) {
  // ...
}

checkRole(UserRole.Admin);
const assertion ๋ฐฉ์‹
const UserRole = {
  Admin: "ADMIN",
  Editor: "EDITOR",
  Viewer: "VIEWER"
} as const;

type UserRole = typeof UserRole[keyof typeof UserRole];

function checkRole(role: UserRole) {
  // ...
}

checkRole(UserRole.Admin);

์Œ... const assertion ๋ฐฉ์‹์ด ์ข€ ๋” ๋ณต์žกํ•ด ๋ณด์ด์ง€? ๐Ÿ˜… ํ•˜์ง€๋งŒ ์žฅ์ ์ด ์žˆ์–ด!

โœจ const assertion์˜ ์žฅ์  1. ๋ฒˆ๋“ค ํฌ๊ธฐ: ์ถ”๊ฐ€ ์ฝ”๋“œ ์ƒ์„ฑ ์—†์Œ (๊ฐ์ฒด ๊ทธ๋Œ€๋กœ ์œ ์ง€)
2. ํŠธ๋ฆฌ ์‰์ดํ‚น: ์‚ฌ์šฉํ•˜์ง€ ์•Š๋Š” ๊ฐ’์€ ๋ฒˆ๋“ค์—์„œ ์ œ๊ฑฐ ๊ฐ€๋Šฅ
3. ์œ ์—ฐ์„ฑ: ์ผ๋ฐ˜ ๊ฐ์ฒด๋ผ์„œ ๋‹ค์–‘ํ•œ ๋ฐฉ์‹์œผ๋กœ ํ™œ์šฉ ๊ฐ€๋Šฅ
4. ํ˜ธํ™˜์„ฑ: Babel, esbuild ๋“ฑ ๋ชจ๋“  ํŠธ๋žœ์ŠคํŒŒ์ผ๋Ÿฌ์™€ ํ˜ธํ™˜

๐Ÿ› ๏ธ ํƒ€์ž… ์ถ”์ถœ ํŒจํ„ด

const assertion์„ ์‚ฌ์šฉํ•  ๋•Œ ํƒ€์ž…์„ ์ถ”์ถœํ•˜๋Š” ํŒจํ„ด์ด ์ค‘์š”ํ•ด. ์—ฌ๋Ÿฌ ๋ฐฉ๋ฒ•์ด ์žˆ๋Š”๋ฐ ํ•˜๋‚˜์”ฉ ๋ณผ๊นŒ? ๐Ÿ”

// ๋ฐฉ๋ฒ• 1: typeof์™€ keyof ์กฐํ•ฉ
const Status = {
  Pending: "pending",
  InProgress: "in_progress",
  Done: "done"
} as const;

type Status = typeof Status[keyof typeof Status];
// "pending" | "in_progress" | "done"

// ๋ฐฉ๋ฒ• 2: ๊ฐ’ ํƒ€์ž… ์ง์ ‘ ์ถ”์ถœ
type StatusValue = typeof Status.Pending | typeof Status.InProgress | typeof Status.Done;

// ๋ฐฉ๋ฒ• 3: ์œ ํ‹ธ๋ฆฌํ‹ฐ ํƒ€์ž… ๋งŒ๋“ค๊ธฐ
type ValueOf<T> = T[keyof T];
type Status2 = ValueOf<typeof Status>;

// ์‚ฌ์šฉ ์˜ˆ์‹œ
function updateStatus(status: Status) {
  console.log(`์ƒํƒœ ๋ณ€๊ฒฝ: ${status}`);
}

updateStatus(Status.Done); // โœ…
updateStatus("done"); // โœ… ๋ฆฌํ„ฐ๋Ÿด ๊ฐ’๋„ ๊ฐ€๋Šฅ
updateStatus("invalid"); // โŒ ํƒ€์ž… ์—๋Ÿฌ!

typeof Status[keyof typeof Status] ์ด ๋ถ€๋ถ„์ด ์ข€ ํ—ท๊ฐˆ๋ฆด ์ˆ˜ ์žˆ๋Š”๋ฐ, ์ฐจ๊ทผ์ฐจ๊ทผ ํ’€์–ด๋ณด์ž:

๐Ÿงฉ ํƒ€์ž… ์ถ”์ถœ ๊ณผ์ • ๋ถ„ํ•ดํ•˜๊ธฐ

1. typeof Status โ†’ Status ๊ฐ์ฒด์˜ ํƒ€์ž…์„ ๊ฐ€์ ธ์™€
2. keyof typeof Status โ†’ "Pending" | "InProgress" | "Done" (ํ‚ค๋“ค์˜ ์œ ๋‹ˆ์˜จ)
3. typeof Status[keyof typeof Status] โ†’ ๊ฐ ํ‚ค์˜ ๊ฐ’ ํƒ€์ž…๋“ค์˜ ์œ ๋‹ˆ์˜จ

๊ฒฐ๊ณผ: "pending" | "in_progress" | "done" ๐ŸŽ‰
Enum vs const assertion ๋น„๊ต Enum const assertion ํƒ€์ž… ์•ˆ์ •์„ฑ ๋ณด์žฅ ์ž๋™์™„์„ฑ ์ง€์› ๋ช…ํ™•ํ•œ ์˜๋„ ํ‘œํ˜„ ์ถ”๊ฐ€ ์ฝ”๋“œ ์ƒ์„ฑ ๋ฒˆ๋“ค ํฌ๊ธฐ ์ฆ๊ฐ€ ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๊ฐ€๋Šฅ ์ˆซ์žํ˜• ์ž๋™ ์ฆ๊ฐ€ ํƒ€์ž… ์•ˆ์ •์„ฑ ๋ณด์žฅ ์ž๋™์™„์„ฑ ์ง€์› ๋ฒˆ๋“ค ํฌ๊ธฐ ์ตœ์†Œํ™” ํŠธ๋ฆฌ ์‰์ดํ‚น ๊ฐ€๋Šฅ ๋„๊ตฌ ํ˜ธํ™˜์„ฑ ์šฐ์ˆ˜ ํƒ€์ž… ์ถ”์ถœ ๋ณต์žก ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๋ถˆ๊ฐ€ ์ „ํ†ต์  ๋ฐฉ์‹ ํ˜„๋Œ€์  ๋ฐฉ์‹

๐ŸŽจ ์‹ค์ „ ํŒจํ„ด: const assertion ํ™œ์šฉ๋ฒ•

์ด์ œ const assertion์„ ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•˜๋Š”์ง€ ๋‹ค์–‘ํ•œ ํŒจํ„ด์„ ์‚ดํŽด๋ณด์ž! ๐Ÿš€

๐ŸŽฏ ํŒจํ„ด 1: ์„ค์ • ๊ฐ์ฒด ๊ด€๋ฆฌ

// API ์—”๋“œํฌ์ธํŠธ ๊ด€๋ฆฌ
const API_ENDPOINTS = {
  users: "/api/users",
  posts: "/api/posts",
  comments: "/api/comments",
  auth: {
    login: "/api/auth/login",
    logout: "/api/auth/logout",
    refresh: "/api/auth/refresh"
  }
} as const;

type ApiEndpoint = typeof API_ENDPOINTS;

// ํƒ€์ž… ์•ˆ์ „ํ•˜๊ฒŒ ์‚ฌ์šฉ
async function fetchData(endpoint: string) {
  const response = await fetch(endpoint);
  return response.json();
}

// ์ž๋™์™„์„ฑ ์ง€์›!
fetchData(API_ENDPOINTS.users);
fetchData(API_ENDPOINTS.auth.login);

๐ŸŽฎ ํŒจํ„ด 2: ์•ก์…˜ ํƒ€์ž… ๊ด€๋ฆฌ (Redux ์Šคํƒ€์ผ)

// ์•ก์…˜ ํƒ€์ž… ์ •์˜
const ActionTypes = {
  ADD_TODO: "ADD_TODO",
  REMOVE_TODO: "REMOVE_TODO",
  TOGGLE_TODO: "TOGGLE_TODO",
  SET_FILTER: "SET_FILTER"
} as const;

type ActionType = typeof ActionTypes[keyof typeof ActionTypes];

// ์•ก์…˜ ์ƒ์„ฑ์ž
interface AddTodoAction {
  type: typeof ActionTypes.ADD_TODO;
  payload: { text: string };
}

interface RemoveTodoAction {
  type: typeof ActionTypes.REMOVE_TODO;
  payload: { id: number };
}

type TodoAction = AddTodoAction | RemoveTodoAction;

// ๋ฆฌ๋“€์„œ
function todoReducer(state: any[], action: TodoAction) {
  switch (action.type) {
    case ActionTypes.ADD_TODO:
      // action.payload.text ์ž๋™์™„์„ฑ ๋จ! โœจ
      return [...state, { text: action.payload.text }];
    case ActionTypes.REMOVE_TODO:
      // action.payload.id ์ž๋™์™„์„ฑ ๋จ! โœจ
      return state.filter(todo => todo.id !== action.payload.id);
    default:
      return state;
  }
}

๐ŸŽจ ํŒจํ„ด 3: ํ…Œ๋งˆ ์‹œ์Šคํ…œ

const THEME = {
  colors: {
    primary: "#6c5ce7",
    secondary: "#74b9ff",
    success: "#00b894",
    warning: "#fdcb6e",
    danger: "#d63031",
    dark: "#2d3436",
    light: "#dfe6e9"
  },
  spacing: {
    xs: "4px",
    sm: "8px",
    md: "16px",
    lg: "24px",
    xl: "32px"
  },
  breakpoints: {
    mobile: "320px",
    tablet: "768px",
    desktop: "1024px",
    wide: "1440px"
  }
} as const;

type Theme = typeof THEME;
type ThemeColor = typeof THEME.colors[keyof typeof THEME.colors];
type ThemeSpacing = typeof THEME.spacing[keyof typeof THEME.spacing];

// ์‚ฌ์šฉ ์˜ˆ์‹œ
function Button({ color }: { color: ThemeColor }) {
  return `<button style="background: ${color}">Click</button>`;
}

Button({ color: THEME.colors.primary }); // โœ…
Button({ color: "#123456" }); // โŒ ํƒ€์ž… ์—๋Ÿฌ!

๐ŸŒ ํŒจํ„ด 4: ๋‹ค๊ตญ์–ด ํ‚ค ๊ด€๋ฆฌ

const TRANSLATION_KEYS = {
  common: {
    save: "common.save",
    cancel: "common.cancel",
    delete: "common.delete",
    confirm: "common.confirm"
  },
  auth: {
    login: "auth.login",
    logout: "auth.logout",
    signUp: "auth.signUp",
    forgotPassword: "auth.forgotPassword"
  },
  errors: {
    required: "errors.required",
    invalidEmail: "errors.invalidEmail",
    networkError: "errors.networkError"
  }
} as const;

type TranslationKey = typeof TRANSLATION_KEYS[keyof typeof TRANSLATION_KEYS][string];

// ๋ฒˆ์—ญ ํ•จ์ˆ˜
function t(key: TranslationKey): string {
  // ์‹ค์ œ ๋ฒˆ์—ญ ๋กœ์ง
  return key;
}

// ํƒ€์ž… ์•ˆ์ „ํ•˜๊ฒŒ ์‚ฌ์šฉ
console.log(t(TRANSLATION_KEYS.common.save)); // โœ…
console.log(t(TRANSLATION_KEYS.auth.login)); // โœ…
console.log(t("random.key")); // โŒ ํƒ€์ž… ์—๋Ÿฌ!

์ด๋Ÿฐ ํŒจํ„ด๋“ค์„ ๋ณด๋ฉด ์•Œ๊ฒ ์ง€๋งŒ, const assertion์€ ์ •๋ง ๋‹ค์–‘ํ•˜๊ฒŒ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ํŠนํžˆ ์„ค์ •์ด๋‚˜ ์ƒ์ˆ˜๊ฐ€ ๋งŽ์€ ํ”„๋กœ์ ํŠธ์—์„œ ๋น›์„ ๋ฐœํ•ด. โœจ

โš–๏ธ ์–ธ์ œ ๋ญ˜ ์จ์•ผ ํ• ๊นŒ?

์ž, ์ด์ œ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ์งˆ๋ฌธ! "Enum์„ ์“ธ๊นŒ, const assertion์„ ์“ธ๊นŒ?" ๐Ÿค”
์ •๋‹ต์€... ์ƒํ™ฉ์— ๋”ฐ๋ผ ๋‹ค๋ฅด๋‹ค! (์˜ˆ์ƒํ–ˆ์ง€? ใ…‹ใ…‹) ๊ฐ๊ฐ์˜ ์žฅ๋‹จ์ ์„ ์ •๋ฆฌํ•ด๋ณผ๊ฒŒ.

โœ… Enum์„ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹์€ ๊ฒฝ์šฐ

1. ์ˆซ์ž ๊ฐ’์ด ํ•„์š”ํ•  ๋•Œ
๋น„ํŠธ ํ”Œ๋ž˜๊ทธ๋‚˜ ์ˆœ์„œ๊ฐ€ ์ค‘์š”ํ•œ ๊ฒฝ์šฐ ์ˆซ์žํ˜• Enum์ด ํŽธํ•ด.
enum Permission {
  None = 0,
  Read = 1 << 0,    // 1
  Write = 1 << 1,   // 2
  Execute = 1 << 2  // 4
}

const userPermission = Permission.Read | Permission.Write; // 3
2. ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘์ด ํ•„์š”ํ•  ๋•Œ
์ˆซ์ž ๊ฐ’์œผ๋กœ ์ด๋ฆ„์„ ์ฐพ์•„์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ.
enum Status {
  Pending,
  Active,
  Inactive
}

console.log(Status[1]); // "Active"
3. ๋ช…ํ™•ํ•œ ํƒ€์ž… ๊ตฌ๋ถ„์ด ํ•„์š”ํ•  ๋•Œ
Enum์€ ๊ณ ์œ ํ•œ ํƒ€์ž…์„ ์ƒ์„ฑํ•˜๋ฏ€๋กœ ๋‹ค๋ฅธ ๋ฌธ์ž์—ด๊ณผ ๊ตฌ๋ถ„๋ผ.

โœ… const assertion์„ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹์€ ๊ฒฝ์šฐ

1. ๋ฒˆ๋“ค ํฌ๊ธฐ๊ฐ€ ์ค‘์š”ํ•  ๋•Œ
ํ”„๋ก ํŠธ์—”๋“œ ํ”„๋กœ์ ํŠธ์—์„œ ๋ฒˆ๋“ค ํฌ๊ธฐ ์ตœ์ ํ™”๊ฐ€ ํ•„์š”ํ•œ ๊ฒฝ์šฐ. 2. ํŠธ๋ฆฌ ์‰์ดํ‚น์ด ํ•„์š”ํ•  ๋•Œ
์‚ฌ์šฉํ•˜์ง€ ์•Š๋Š” ๊ฐ’๋“ค์„ ๋ฒˆ๋“ค์—์„œ ์ œ๊ฑฐํ•˜๊ณ  ์‹ถ์„ ๋•Œ. 3. Babel์ด๋‚˜ esbuild๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ
const enum์ด ์ œ๋Œ€๋กœ ๋™์ž‘ํ•˜์ง€ ์•Š๋Š” ํ™˜๊ฒฝ. 4. ๊ฐ์ฒด์˜ ์œ ์—ฐ์„ฑ์ด ํ•„์š”ํ•  ๋•Œ
์ผ๋ฐ˜ ๊ฐ์ฒด์ด๋ฏ€๋กœ ๋‹ค์–‘ํ•œ ๋ฐฉ์‹์œผ๋กœ ์กฐ์ž‘ ๊ฐ€๋Šฅ.
const STATUS = {
  pending: "pending",
  active: "active"
} as const;

// ๊ฐ์ฒด ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ ๊ฐ€๋Šฅ
const allStatuses = Object.values(STATUS);
const statusKeys = Object.keys(STATUS);

๐ŸŽฏ ์‹ค์šฉ์ ์ธ ์„ ํƒ ๊ฐ€์ด๋“œ

๐Ÿข ๋Œ€๊ทœ๋ชจ ์—”ํ„ฐํ”„๋ผ์ด์ฆˆ Enum ์ถ”์ฒœ

๋ช…ํ™•ํ•œ ํƒ€์ž… ๊ตฌ๋ถ„๊ณผ ์•ˆ์ •์„ฑ์ด ์ค‘์š”. ๋ฒˆ๋“ค ํฌ๊ธฐ๋ณด๋‹ค ์œ ์ง€๋ณด์ˆ˜์„ฑ ์šฐ์„ .
๐Ÿ“ฑ ํ”„๋ก ํŠธ์—”๋“œ ์•ฑ const assertion ์ถ”์ฒœ

๋ฒˆ๋“ค ํฌ๊ธฐ ์ตœ์ ํ™”๊ฐ€ ์ค‘์š”. ํ˜„๋Œ€์ ์ธ ๋นŒ๋“œ ๋„๊ตฌ์™€ ํ˜ธํ™˜์„ฑ ์ข‹์Œ.
๐ŸŽฎ ๊ฒŒ์ž„ ๊ฐœ๋ฐœ Enum ์ถ”์ฒœ

์ˆซ์ž ๊ฐ’๊ณผ ๋น„ํŠธ ์—ฐ์‚ฐ์ด ์ž์ฃผ ํ•„์š”. ์ƒํƒœ ๊ด€๋ฆฌ๊ฐ€ ๋ณต์žกํ•จ.
๐Ÿš€ ์Šคํƒ€ํŠธ์—… ํ”„๋กœ์ ํŠธ const assertion ์ถ”์ฒœ

๋น ๋ฅธ ๊ฐœ๋ฐœ๊ณผ ์œ ์—ฐ์„ฑ์ด ์ค‘์š”. ์ตœ์‹  ๊ธฐ์ˆ  ์Šคํƒ ์‚ฌ์šฉ.

๐Ÿ”ง ๊ณ ๊ธ‰ ํ…Œํฌ๋‹‰๊ณผ ํŒ

์—ฌ๊ธฐ์„œ๋ถ€ํ„ฐ๋Š” ์ข€ ๋” ๊ณ ๊ธ‰ ๋‚ด์šฉ์ด์•ผ! ์‹ค๋ฌด์—์„œ ์œ ์šฉํ•œ ํ…Œํฌ๋‹‰๋“ค์„ ๊ณต์œ ํ• ๊ฒŒ. ๐ŸŽ“

๐Ÿ’ก ์œ ํ‹ธ๋ฆฌํ‹ฐ ํƒ€์ž… ๋งŒ๋“ค๊ธฐ

// ๊ฐ์ฒด์˜ ๊ฐ’ ํƒ€์ž… ์ถ”์ถœ
type ValueOf<T> = T[keyof T];

// ์ค‘์ฒฉ ๊ฐ์ฒด์˜ ๊ฐ’ ํƒ€์ž… ์ถ”์ถœ
type DeepValueOf<T> = T extends object
  ? ValueOf<{ [K in keyof T]: DeepValueOf<T[K]> }>
  : T;

const CONFIG = {
  api: {
    timeout: 5000,
    retries: 3
  },
  ui: {
    theme: "dark",
    language: "ko"
  }
} as const;

type ConfigValue = DeepValueOf<typeof CONFIG>;
// 5000 | 3 | "dark" | "ko"

// Enum ๊ฐ’์„ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜
function enumToArray<T extends Record<string, string | number>>(
  enumObj: T
): Array<T[keyof T]> {
  return Object.values(enumObj);
}

enum Color {
  Red = "red",
  Blue = "blue",
  Green = "green"
}

const colors = enumToArray(Color);
// ["red", "blue", "green"]

๐ŸŽจ ํƒ€์ž… ๊ฐ€๋“œ ํ™œ์šฉ

const STATUS = {
  pending: "pending",
  active: "active",
  inactive: "inactive"
} as const;

type Status = typeof STATUS[keyof typeof STATUS];

// ํƒ€์ž… ๊ฐ€๋“œ ํ•จ์ˆ˜
function isStatus(value: unknown): value is Status {
  return Object.values(STATUS).includes(value as Status);
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
function processStatus(input: unknown) {
  if (isStatus(input)) {
    // ์—ฌ๊ธฐ์„œ input์€ Status ํƒ€์ž…์œผ๋กœ ์ขํ˜€์ง!
    console.log(`์œ ํšจํ•œ ์ƒํƒœ: ${input}`);
  } else {
    console.log("์ž˜๋ชป๋œ ์ƒํƒœ๊ฐ’");
  }
}

processStatus("pending"); // โœ…
processStatus("invalid"); // โŒ

๐Ÿ”„ Enum๊ณผ const assertion ํ˜ผํ•ฉ ์‚ฌ์šฉ

// Enum์œผ๋กœ ๊ธฐ๋ณธ ๊ตฌ์กฐ ์ •์˜
enum UserRoleEnum {
  Admin = "ADMIN",
  Editor = "EDITOR",
  Viewer = "VIEWER"
}

// const assertion์œผ๋กœ ์ถ”๊ฐ€ ๋ฉ”ํƒ€๋ฐ์ดํ„ฐ
const USER_ROLE_META = {
  [UserRoleEnum.Admin]: {
    label: "๊ด€๋ฆฌ์ž",
    permissions: ["read", "write", "delete"],
    level: 3
  },
  [UserRoleEnum.Editor]: {
    label: "ํŽธ์ง‘์ž",
    permissions: ["read", "write"],
    level: 2
  },
  [UserRoleEnum.Viewer]: {
    label: "๋ทฐ์–ด",
    permissions: ["read"],
    level: 1
  }
} as const;

type RoleMeta = typeof USER_ROLE_META;

function getRoleInfo(role: UserRoleEnum) {
  const meta = USER_ROLE_META[role];
  return `${meta.label} (๋ ˆ๋ฒจ ${meta.level})`;
}

console.log(getRoleInfo(UserRoleEnum.Admin));
// "๊ด€๋ฆฌ์ž (๋ ˆ๋ฒจ 3)"

๐ŸŽฏ ์ œ๋„ค๋ฆญ๊ณผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•˜๊ธฐ

// ์ œ๋„ค๋ฆญ ์ƒ์ˆ˜ ๊ฐ์ฒด
function createEnum<T extends Record<string, string>>(obj: T) {
  return Object.freeze(obj) as { readonly [K in keyof T]: T[K] };
}

const HttpMethod = createEnum({
  GET: "GET",
  POST: "POST",
  PUT: "PUT",
  DELETE: "DELETE"
});

type HttpMethod = typeof HttpMethod[keyof typeof HttpMethod];

// ์ œ๋„ค๋ฆญ ํ•จ์ˆ˜์™€ ์กฐํ•ฉ
function request<M extends HttpMethod>(
  url: string,
  method: M,
  data?: M extends "GET" ? never : unknown
) {
  console.log(`${method} ${url}`);
  if (data) {
    console.log("Data:", data);
  }
}

request("/api/users", HttpMethod.GET); // โœ…
request("/api/users", HttpMethod.GET, { name: "John" }); // โŒ ํƒ€์ž… ์—๋Ÿฌ!
request("/api/users", HttpMethod.POST, { name: "John" }); // โœ…

์ด๋Ÿฐ ๊ณ ๊ธ‰ ํ…Œํฌ๋‹‰๋“ค์„ ํ™œ์šฉํ•˜๋ฉด ํƒ€์ž… ์•ˆ์ •์„ฑ์„ ๊ทน๋Œ€ํ™”ํ•˜๋ฉด์„œ๋„ ์œ ์—ฐํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ช

๐Ÿ› ํ”ํ•œ ์‹ค์ˆ˜์™€ ํ•ด๊ฒฐ๋ฒ•

์‹ค๋ฌด์—์„œ ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ์‹ค์ˆ˜๋“ค๊ณผ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ •๋ฆฌํ•ด๋ดค์–ด. ๋‚˜๋„ ๋‹ค ๊ฒช์–ด๋ณธ ๊ฒƒ๋“ค์ด์•ผ! ๐Ÿ˜…

โŒ ์‹ค์ˆ˜ 1: const assertion ์œ„์น˜ ์ฐฉ๊ฐ

// ์ž˜๋ชป๋œ ์˜ˆ
const colors = {
  red: "#ff0000" as const,
  blue: "#0000ff" as const
};
// ํƒ€์ž…: { red: "#ff0000"; blue: "#0000ff"; }
// ํ•˜์ง€๋งŒ ๊ฐ์ฒด ์ž์ฒด๋Š” ์ˆ˜์ • ๊ฐ€๋Šฅ!

colors.red = "#ff1111"; // โœ… ๊ฐ€๋Šฅ (์˜๋„ํ•˜์ง€ ์•Š์Œ!)

// ์˜ฌ๋ฐ”๋ฅธ ์˜ˆ
const colors = {
  red: "#ff0000",
  blue: "#0000ff"
} as const;
// ํƒ€์ž…: { readonly red: "#ff0000"; readonly blue: "#0000ff"; }

colors.red = "#ff1111"; // โŒ ์—๋Ÿฌ! (์˜๋„ํ•œ ๋Œ€๋กœ)
๐Ÿ’ก ํ•ด๊ฒฐ์ฑ…
as const๋Š” ํ•ญ์ƒ ๊ฐ์ฒด๋‚˜ ๋ฐฐ์—ด ์ „์ฒด์— ์ ์šฉํ•ด์•ผ ํ•ด! ๊ฐœ๋ณ„ ์†์„ฑ์— ์ ์šฉํ•˜๋ฉด ์ฝ๊ธฐ ์ „์šฉ์ด ์•ˆ ๋ผ.

โŒ ์‹ค์ˆ˜ 2: Enum ๊ฐ’ ์ง์ ‘ ๋น„๊ต

enum Status {
  Active = "ACTIVE",
  Inactive = "INACTIVE"
}

// API์—์„œ ๋ฐ›์€ ๋ฐ์ดํ„ฐ
const apiResponse = "ACTIVE";

// ์ž˜๋ชป๋œ ๋น„๊ต
if (apiResponse === Status.Active) {
  // ์ด๊ฑด ๋™์ž‘ํ•˜์ง€๋งŒ...
}

// ๋” ์•ˆ์ „ํ•œ ๋ฐฉ๋ฒ•
function isValidStatus(value: string): value is Status {
  return Object.values(Status).includes(value as Status);
}

if (isValidStatus(apiResponse)) {
  // ํƒ€์ž… ๊ฐ€๋“œ๋กœ ์•ˆ์ „ํ•˜๊ฒŒ ์ฒดํฌ!
  const status: Status = apiResponse;
}

โŒ ์‹ค์ˆ˜ 3: const enum๊ณผ ์ผ๋ฐ˜ ๊ฐ์ฒด ํ˜ผ๋™

// const enum์€ ์ปดํŒŒ์ผ ์‹œ ์ธ๋ผ์ธ๋จ
const enum Direction {
  Up,
  Down
}

// ๋Ÿฐํƒ€์ž„์— ๊ฐ์ฒด๋กœ ์ ‘๊ทผ ๋ถˆ๊ฐ€!
const directions = Object.values(Direction); // โŒ ์—๋Ÿฌ!

// ํ•ด๊ฒฐ: ์ผ๋ฐ˜ enum ์‚ฌ์šฉ
enum Direction2 {
  Up,
  Down
}

const directions2 = Object.values(Direction2); // โœ… ๊ฐ€๋Šฅ

โŒ ์‹ค์ˆ˜ 4: ํƒ€์ž… ์ถ”์ถœ ์‹ค์ˆ˜

const CONFIG = {
  timeout: 5000,
  retries: 3
} as const;

// ์ž˜๋ชป๋œ ํƒ€์ž… ์ถ”์ถœ
type ConfigKey = keyof typeof CONFIG; // "timeout" | "retries" (ํ‚ค๋งŒ!)

// ์˜ฌ๋ฐ”๋ฅธ ํƒ€์ž… ์ถ”์ถœ
type ConfigValue = typeof CONFIG[keyof typeof CONFIG]; // 5000 | 3 (๊ฐ’!)

// ๋” ๋ช…ํ™•ํ•œ ๋ฐฉ๋ฒ•
type TimeoutValue = typeof CONFIG.timeout; // 5000
type RetriesValue = typeof CONFIG.retries; // 3
๐ŸŽฏ ๋””๋ฒ„๊น… ํŒ

ํƒ€์ž…์ด ์˜ˆ์ƒ๊ณผ ๋‹ค๋ฅด๊ฒŒ ์ถ”๋ก ๋  ๋•Œ๋Š” VSCode์—์„œ ๋ณ€์ˆ˜์— ๋งˆ์šฐ์Šค๋ฅผ ์˜ฌ๋ ค๋ณด๊ฑฐ๋‚˜, ๋‹ค์Œ ์œ ํ‹ธ๋ฆฌํ‹ฐ ํƒ€์ž…์„ ์‚ฌ์šฉํ•ด๋ด:
type Debug<T> = { [K in keyof T]: T[K] };

type MyType = Debug<typeof CONFIG>;
// ํƒ€์ž… ๊ตฌ์กฐ๊ฐ€ ๋ช…ํ™•ํ•˜๊ฒŒ ๋ณด์ž„!

๐ŸŒŸ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ์˜ˆ์ œ

์ด์ œ ๋ฐฐ์šด ๋‚ด์šฉ์„ ์ข…ํ•ฉํ•ด์„œ ์‹ค์ œ ํ”„๋กœ์ ํŠธ์—์„œ ์‚ฌ์šฉํ•  ๋งŒํ•œ ์˜ˆ์ œ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ! ๐Ÿš€

๐Ÿ“ Todo ์•ฑ ์ƒํƒœ ๊ด€๋ฆฌ

// ์ƒํƒœ ์ •์˜
const TODO_STATUS = {
  pending: "pending",
  inProgress: "in_progress",
  completed: "completed",
  archived: "archived"
} as const;

type TodoStatus = typeof TODO_STATUS[keyof typeof TODO_STATUS];

// ์šฐ์„ ์ˆœ์œ„ ์ •์˜
enum Priority {
  Low = 1,
  Medium = 2,
  High = 3,
  Urgent = 4
}

// Todo ์ธํ„ฐํŽ˜์ด์Šค
interface Todo {
  id: string;
  title: string;
  status: TodoStatus;
  priority: Priority;
  createdAt: Date;
  updatedAt: Date;
}

// ์ƒํƒœ ์ „ํ™˜ ๊ทœ์น™
const STATUS_TRANSITIONS = {
  [TODO_STATUS.pending]: [TODO_STATUS.inProgress, TODO_STATUS.archived],
  [TODO_STATUS.inProgress]: [TODO_STATUS.completed, TODO_STATUS.pending],
  [TODO_STATUS.completed]: [TODO_STATUS.archived],
  [TODO_STATUS.archived]: []
} as const;

// ์ƒํƒœ ์ „ํ™˜ ๊ฐ€๋Šฅ ์—ฌ๋ถ€ ์ฒดํฌ
function canTransition(from: TodoStatus, to: TodoStatus): boolean {
  const allowedTransitions = STATUS_TRANSITIONS[from];
  return allowedTransitions.includes(to as any);
}

// Todo ๊ด€๋ฆฌ ํด๋ž˜์Šค
class TodoManager {
  private todos: Map<string, Todo> = new Map();
  
  updateStatus(id: string, newStatus: TodoStatus): boolean {
    const todo = this.todos.get(id);
    if (!todo) return false;
    
    if (!canTransition(todo.status, newStatus)) {
      console.log(`โŒ ${todo.status}์—์„œ ${newStatus}๋กœ ์ „ํ™˜ ๋ถˆ๊ฐ€`);
      return false;
    }
    
    todo.status = newStatus;
    todo.updatedAt = new Date();
    console.log(`โœ… ์ƒํƒœ ๋ณ€๊ฒฝ: ${newStatus}`);
    return true;
  }
  
  getByPriority(priority: Priority): Todo[] {
    return Array.from(this.todos.values())
      .filter(todo => todo.priority === priority);
  }
  
  getByStatus(status: TodoStatus): Todo[] {
    return Array.from(this.todos.values())
      .filter(todo => todo.status === status);
  }
}

๐ŸŽฎ ๊ฒŒ์ž„ ์บ๋ฆญํ„ฐ ์‹œ์Šคํ…œ

// ์บ๋ฆญํ„ฐ ํด๋ž˜์Šค
enum CharacterClass {
  Warrior = "WARRIOR",
  Mage = "MAGE",
  Archer = "ARCHER",
  Healer = "HEALER"
}

// ์Šคํ‚ฌ ํƒ€์ž…
const SKILL_TYPE = {
  attack: "attack",
  defense: "defense",
  heal: "heal",
  buff: "buff"
} as const;

type SkillType = typeof SKILL_TYPE[keyof typeof SKILL_TYPE];

// ํด๋ž˜์Šค๋ณ„ ๊ธฐ๋ณธ ์Šคํƒฏ
const CLASS_BASE_STATS = {
  [CharacterClass.Warrior]: {
    hp: 150,
    mp: 50,
    attack: 20,
    defense: 15,
    speed: 8
  },
  [CharacterClass.Mage]: {
    hp: 80,
    mp: 150,
    attack: 25,
    defense: 5,
    speed: 10
  },
  [CharacterClass.Archer]: {
    hp: 100,
    mp: 80,
    attack: 22,
    defense: 8,
    speed: 15
  },
  [CharacterClass.Healer]: {
    hp: 90,
    mp: 120,
    attack: 10,
    defense: 10,
    speed: 12
  }
} as const;

type ClassStats = typeof CLASS_BASE_STATS[CharacterClass];

// ์บ๋ฆญํ„ฐ ์ธํ„ฐํŽ˜์ด์Šค
interface Character {
  name: string;
  class: CharacterClass;
  level: number;
  stats: ClassStats;
}

// ์บ๋ฆญํ„ฐ ์ƒ์„ฑ ํŒฉํ† ๋ฆฌ
function createCharacter(
  name: string,
  characterClass: CharacterClass
): Character {
  return {
    name,
    class: characterClass,
    level: 1,
    stats: { ...CLASS_BASE_STATS[characterClass] }
  };
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const warrior = createCharacter("์šฉ์‚ฌ", CharacterClass.Warrior);
console.log(`${warrior.name}์˜ HP: ${warrior.stats.hp}`);
// "์šฉ์‚ฌ์˜ HP: 150"

๐ŸŒ API ํด๋ผ์ด์–ธํŠธ

// HTTP ๋ฉ”์„œ๋“œ
const HTTP_METHOD = {
  GET: "GET",
  POST: "POST",
  PUT: "PUT",
  PATCH: "PATCH",
  DELETE: "DELETE"
} as const;

type HttpMethod = typeof HTTP_METHOD[keyof typeof HTTP_METHOD];

// API ์—”๋“œํฌ์ธํŠธ
const API_ENDPOINT = {
  users: "/api/users",
  posts: "/api/posts",
  comments: "/api/comments"
} as const;

type ApiEndpoint = typeof API_ENDPOINT[keyof typeof API_ENDPOINT];

// ์‘๋‹ต ์ƒํƒœ
enum ResponseStatus {
  Success = 200,
  Created = 201,
  BadRequest = 400,
  Unauthorized = 401,
  NotFound = 404,
  ServerError = 500
}

// API ํด๋ผ์ด์–ธํŠธ
class ApiClient {
  private baseUrl: string;
  
  constructor(baseUrl: string) {
    this.baseUrl = baseUrl;
  }
  
  async request<T>(
    endpoint: ApiEndpoint,
    method: HttpMethod,
    data?: unknown
  ): Promise<T> {
    const url = `${this.baseUrl}${endpoint}`;
    
    const response = await fetch(url, {
      method,
      headers: {
        "Content-Type": "application/json"
      },
      body: data ? JSON.stringify(data) : undefined
    });
    
    switch (response.status) {
      case ResponseStatus.Success:
      case ResponseStatus.Created:
        return await response.json();
      case ResponseStatus.BadRequest:
        throw new Error("์ž˜๋ชป๋œ ์š”์ฒญ์ž…๋‹ˆ๋‹ค");
      case ResponseStatus.Unauthorized:
        throw new Error("์ธ์ฆ์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค");
      case ResponseStatus.NotFound:
        throw new Error("๋ฆฌ์†Œ์Šค๋ฅผ ์ฐพ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค");
      case ResponseStatus.ServerError:
        throw new Error("์„œ๋ฒ„ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค");
      default:
        throw new Error(`์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์ƒํƒœ: ${response.status}`);
    }
  }
  
  // ํŽธ์˜ ๋ฉ”์„œ๋“œ
  get<T>(endpoint: ApiEndpoint) {
    return this.request<T>(endpoint, HTTP_METHOD.GET);
  }
  
  post<T>(endpoint: ApiEndpoint, data: unknown) {
    return this.request<T>(endpoint, HTTP_METHOD.POST, data);
  }
  
  put<T>(endpoint: ApiEndpoint, data: unknown) {
    return this.request<T>(endpoint, HTTP_METHOD.PUT, data);
  }
  
  delete<T>(endpoint: ApiEndpoint) {
    return this.request<T>(endpoint, HTTP_METHOD.DELETE);
  }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const client = new ApiClient("https://api.example.com");

async function fetchUsers() {
  try {
    const users = await client.get(API_ENDPOINT.users);
    console.log("์‚ฌ์šฉ์ž ๋ชฉ๋ก:", users);
  } catch (error) {
    console.error("์—๋Ÿฌ ๋ฐœ์ƒ:", error);
  }
}

์ด๋Ÿฐ ์‹์œผ๋กœ Enum๊ณผ const assertion์„ ์กฐํ•ฉํ•˜๋ฉด ํƒ€์ž… ์•ˆ์ „ํ•˜๋ฉด์„œ๋„ ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฌ์šด ์ฝ”๋“œ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ๐ŸŽ‰

๐ŸŽ“ ์„ฑ๋Šฅ๊ณผ ์ตœ์ ํ™”

๋งˆ์ง€๋ง‰์œผ๋กœ ์„ฑ๋Šฅ ๊ด€๋ จ ์ด์•ผ๊ธฐ๋ฅผ ํ•ด๋ณผ๊ฒŒ. ์‹ค์ œ ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ์—์„œ ์ค‘์š”ํ•œ ๋ถ€๋ถ„์ด๊ฑฐ๋“ ! โšก

๐Ÿ“Š ๋ฒˆ๋“ค ํฌ๊ธฐ ๋น„๊ต

์‹คํ—˜ ์กฐ๊ฑด
10๊ฐœ์˜ ์ƒ์ˆ˜๋ฅผ ์ •์˜ํ•˜๊ณ  ๊ฐ๊ฐ 5๋ฒˆ์”ฉ ์‚ฌ์šฉํ–ˆ์„ ๋•Œ์˜ ๋ฒˆ๋“ค ํฌ๊ธฐ ๋น„๊ต
// 1. ์ผ๋ฐ˜ Enum (์•ฝ 250 bytes)
enum Status {
  Pending = "pending",
  Active = "active",
  // ... 8๊ฐœ ๋”
}

// 2. const Enum (์•ฝ 50 bytes)
const enum Status {
  Pending = "pending",
  Active = "active",
  // ... 8๊ฐœ ๋”
}

// 3. const assertion (์•ฝ 80 bytes)
const STATUS = {
  pending: "pending",
  active: "active",
  // ... 8๊ฐœ ๋”
} as const;
๊ฒฐ๊ณผ: const enum์ด ๊ฐ€์žฅ ์ž‘์ง€๋งŒ, const assertion๋„ ์ถฉ๋ถ„ํžˆ ์ž‘๊ณ  ํ˜ธํ™˜์„ฑ์ด ์ข‹์•„! ๐Ÿ“‰

โšก ๋Ÿฐํƒ€์ž„ ์„ฑ๋Šฅ

// ์„ฑ๋Šฅ ํ…Œ์ŠคํŠธ ํ•จ์ˆ˜
function benchmark(name: string, fn: () => void, iterations: number) {
  const start = performance.now();
  for (let i = 0; i < iterations; i++) {
    fn();
  }
  const end = performance.now();
  console.log(`${name}: ${(end - start).toFixed(2)}ms`);
}

// Enum ์‚ฌ์šฉ
enum Status1 { Pending, Active, Done }
benchmark("Enum", () => {
  const s = Status1.Active;
}, 1000000);

// const assertion ์‚ฌ์šฉ
const STATUS2 = { pending: 0, active: 1, done: 2 } as const;
benchmark("const assertion", () => {
  const s = STATUS2.active;
}, 1000000);

// ๊ฒฐ๊ณผ: ๊ฑฐ์˜ ์ฐจ์ด ์—†์Œ! (๋‘˜ ๋‹ค ๋‹จ์ˆœ ๊ฐ์ฒด ์ ‘๊ทผ)

๋Ÿฐํƒ€์ž„ ์„ฑ๋Šฅ์€ ๊ฑฐ์˜ ์ฐจ์ด๊ฐ€ ์—†์–ด. ๋‘˜ ๋‹ค ๊ฒฐ๊ตญ ๊ฐ์ฒด ํ”„๋กœํผํ‹ฐ ์ ‘๊ทผ์ด๋‹ˆ๊นŒ! ์ค‘์š”ํ•œ ๊ฑด ๋ฒˆ๋“ค ํฌ๊ธฐ์™€ ๊ฐœ๋ฐœ ๊ฒฝํ—˜์ด์•ผ. ๐Ÿ˜Š

๐ŸŽฏ ์ตœ์ ํ™” ํŒ

1. ํŠธ๋ฆฌ ์‰์ดํ‚น ํ™œ์šฉ
const assertion์„ ์‚ฌ์šฉํ•˜๋ฉด ์‚ฌ์šฉํ•˜์ง€ ์•Š๋Š” ๊ฐ’๋“ค์ด ๋ฒˆ๋“ค์—์„œ ์ œ๊ฑฐ๋  ์ˆ˜ ์žˆ์–ด.
// ์ด ์ค‘์—์„œ pending๋งŒ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด
const STATUS = {
  pending: "pending",
  active: "active",
  done: "done"
} as const;

// ๋ฒˆ๋“ค์—๋Š” pending๋งŒ ํฌํ•จ๋  ์ˆ˜ ์žˆ์Œ!
2. ์ฝ”๋“œ ์Šคํ”Œ๋ฆฌํŒ…
ํฐ Enum์ด๋‚˜ ์ƒ์ˆ˜ ๊ฐ์ฒด๋Š” ๋ณ„๋„ ํŒŒ์ผ๋กœ ๋ถ„๋ฆฌํ•˜๊ณ  ๋™์  import ์‚ฌ์šฉ.
// constants.ts
export const LARGE_CONFIG = { /* ๋งŽ์€ ์„ค์ • */ } as const;

// main.ts
const config = await import("./constants");
// ํ•„์š”ํ•  ๋•Œ๋งŒ ๋กœ๋“œ!
3. ํƒ€์ž…๋งŒ import
ํƒ€์ž…๋งŒ ํ•„์š”ํ•œ ๊ฒฝ์šฐ type import ์‚ฌ์šฉ.
import type { Status } from "./types";
// ๋Ÿฐํƒ€์ž„ ์ฝ”๋“œ์— ํฌํ•จ๋˜์ง€ ์•Š์Œ!

๐ŸŽฏ ์žฌ๋Šฅ๋„ท์—์„œ ๋ฐฐ์šฐ๋Š” ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ

ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ๋ฅผ ๋” ๊นŠ์ด ๋ฐฐ์šฐ๊ณ  ์‹ถ๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท์„ ํ™œ์šฉํ•ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ! ๐ŸŒŸ

์žฌ๋Šฅ๋„ท(https://www.jaenung.net)์˜ '์ง€์‹์ธ์˜ ์ˆฒ'์—๋Š” ์ด๋Ÿฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹๋“ค์ด ๊ฐ€๋“ํ•˜๊ณ , ์‹ค๋ฌด ๊ฒฝํ—˜์ด ํ’๋ถ€ํ•œ ๊ฐœ๋ฐœ์ž๋“ค์—๊ฒŒ ์ง์ ‘ ๋ฐฐ์šธ ์ˆ˜๋„ ์žˆ์–ด. ํŠนํžˆ ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ ๊ฐ™์€ ๊ธฐ์ˆ ์€ ์‹ค์ „ ๊ฒฝํ—˜์ด ์ค‘์š”ํ•œ๋ฐ, ์žฌ๋Šฅ๋„ท์—์„œ ๋ฉ˜ํ† ๋ฅผ ์ฐพ์•„ 1:1๋กœ ์ฝ”๋“œ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ›๊ฑฐ๋‚˜ ํ”„๋กœ์ ํŠธ ์ƒ๋‹ด์„ ๋ฐ›์œผ๋ฉด ํ›จ์”ฌ ๋น ๋ฅด๊ฒŒ ์„ฑ์žฅํ•  ์ˆ˜ ์žˆ์ง€! ๐Ÿ’ช

๐Ÿ’ก ํ•™์Šต ํŒ 1. ์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘: Todo ์•ฑ์ด๋‚˜ ๊ฐ„๋‹จํ•œ API ํด๋ผ์ด์–ธํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณด๋ฉด์„œ Enum๊ณผ const assertion์„ ์ง์ ‘ ์จ๋ด
2. ํƒ€์ž… ์—๋Ÿฌ๋ฅผ ๋‘๋ ค์›Œํ•˜์ง€ ๋งˆ: ์—๋Ÿฌ ๋ฉ”์‹œ์ง€๊ฐ€ ์นœ์ ˆํ•˜๊ฒŒ ์•Œ๋ ค์ฃผ๋‹ˆ๊นŒ ์˜คํžˆ๋ ค ๋ฐฐ์šฐ๊ธฐ ์ข‹์•„
3. ์‹ค๋ฌด ์ฝ”๋“œ ์ฐธ๊ณ : ์˜คํ”ˆ์†Œ์Šค ํ”„๋กœ์ ํŠธ๋“ค์ด ์–ด๋–ป๊ฒŒ ์ƒ์ˆ˜๋ฅผ ๊ด€๋ฆฌํ•˜๋Š”์ง€ ์‚ดํŽด๋ด
4. ํŒ€ ์ปจ๋ฒค์…˜ ์ •ํ•˜๊ธฐ: ํ”„๋กœ์ ํŠธ๋งˆ๋‹ค ์ผ๊ด€๋œ ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด

๐ŸŽฌ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€... ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์—ˆ๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ๐Ÿ‘๐Ÿ‘๐Ÿ‘

์šฐ๋ฆฌ๊ฐ€ ์˜ค๋Š˜ ๋‹ค๋ฃฌ ๋‚ด์šฉ์„ ์ •๋ฆฌํ•ด๋ณผ๊นŒ?

๐Ÿ“š ํ•ต์‹ฌ ์š”์•ฝ โœ… Enum
โ€ข ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ์˜ ์ „ํ†ต์ ์ธ ์ƒ์ˆ˜ ๊ด€๋ฆฌ ๋ฐฉ๋ฒ•
โ€ข ์ˆซ์žํ˜•, ๋ฌธ์ž์—ดํ˜•, ์ด์ข… Enum ์ง€์›
โ€ข ์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ๊ฐ€๋Šฅ (์ˆซ์žํ˜•๋งŒ)
โ€ข ์ถ”๊ฐ€ ์ฝ”๋“œ ์ƒ์„ฑ์œผ๋กœ ๋ฒˆ๋“ค ํฌ๊ธฐ ์ฆ๊ฐ€

โœ… const assertion
โ€ข ํ˜„๋Œ€์ ์ด๊ณ  ๊ฐ€๋ฒผ์šด ๋Œ€์•ˆ
โ€ข ์ถ”๊ฐ€ ์ฝ”๋“œ ์ƒ์„ฑ ์—†์Œ
โ€ข ํŠธ๋ฆฌ ์‰์ดํ‚น ๊ฐ€๋Šฅ
โ€ข ๋ชจ๋“  ๋นŒ๋“œ ๋„๊ตฌ์™€ ํ˜ธํ™˜

โœ… ์„ ํƒ ๊ธฐ์ค€
โ€ข ๋ฒˆ๋“ค ํฌ๊ธฐ ์ค‘์š” โ†’ const assertion
โ€ข ์ˆซ์ž ๊ฐ’/์—ญ๋ฐฉํ–ฅ ๋งคํ•‘ ํ•„์š” โ†’ Enum
โ€ข ๋ช…ํ™•ํ•œ ํƒ€์ž… ๊ตฌ๋ถ„ ํ•„์š” โ†’ Enum
โ€ข ์œ ์—ฐ์„ฑ๊ณผ ํ˜ธํ™˜์„ฑ ์ค‘์š” โ†’ const assertion

๊ฒฐ๊ตญ ์ •๋‹ต์€ ์—†์–ด. ํ”„๋กœ์ ํŠธ์˜ ์š”๊ตฌ์‚ฌํ•ญ, ํŒ€์˜ ์„ ํ˜ธ๋„, ๊ธฐ์ˆ  ์Šคํƒ์— ๋”ฐ๋ผ ์ ์ ˆํ•œ ๋ฐฉ๋ฒ•์„ ์„ ํƒํ•˜๋ฉด ๋ผ. ์ค‘์š”ํ•œ ๊ฑด ์ผ๊ด€์„ฑ์ด์•ผ! ๐ŸŽฏ

์ฒ˜์Œ์—๋Š” ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ, ๊ณ„์† ์‚ฌ์šฉํ•˜๋‹ค ๋ณด๋ฉด ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ์ต์ˆ™ํ•ด์งˆ ๊ฑฐ์•ผ. ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ์˜ ํƒ€์ž… ์‹œ์Šคํ…œ์€ ์ •๋ง ๊ฐ•๋ ฅํ•˜๊ณ , ์ œ๋Œ€๋กœ ํ™œ์šฉํ•˜๋ฉด ๋ฒ„๊ทธ๋ฅผ ์‚ฌ์ „์— ๋งŽ์ด ์žก์„ ์ˆ˜ ์žˆ์–ด. ๐Ÿ˜Š

๐Ÿš€ ๋‹ค์Œ ๋‹จ๊ณ„

์ด์ œ ๋ฐฐ์šด ๋‚ด์šฉ์„ ์‹ค์ œ ํ”„๋กœ์ ํŠธ์— ์ ์šฉํ•ด๋ด! ์ž‘์€ ๊ฒƒ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ํŒจํ„ด์œผ๋กœ ๋ฐœ์ „์‹œ์ผœ ๋‚˜๊ฐ€๋ฉด ๋ผ.

๊ถ๊ธˆํ•œ ์ ์ด ์žˆ๊ฑฐ๋‚˜ ๋” ๊นŠ์ด ๋ฐฐ์šฐ๊ณ  ์‹ถ๋‹ค๋ฉด ํƒ€์ž…์Šคํฌ๋ฆฝํŠธ ๊ณต์‹ ๋ฌธ์„œ๋‚˜ ์ปค๋ฎค๋‹ˆํ‹ฐ๋ฅผ ํ™œ์šฉํ•˜๊ณ , ์‹ค๋ฌด ๊ฒฝํ—˜์ด ํ•„์š”ํ•˜๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ๋ฉ˜ํ† ๋ฅผ ์ฐพ์•„๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ! ๐Ÿ’ช

ํ–‰๋ณตํ•œ ์ฝ”๋”ฉ ๋˜๊ธธ ๋ฐ”๋ผ! ๐ŸŽ‰โœจ
ํƒ€์ž… ์•ˆ์ „ํ•œ ์ฝ”๋“œ๋กœ ๋ฒ„๊ทธ ์—†๋Š” ์„ธ์ƒ์„ ๋งŒ๋“ค์–ด๋ณด์ž! ๐Ÿš€

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.