🏛️ 14. 클래스 — 프로토타입의 진화, 그리고 현대적 OOP의 실무 활용

class Post {
  // 클래스 필드 선언 (ES2022)
  viewCount = 0;        // 퍼블릭 인스턴스 필드
  likeCount = 0;
  comments = [];
 
  constructor(id, title, authorId) {
    this.id = id;
    this.title = title;
    this.authorId = authorId;
    this.createdAt = new Date();
  }
 
  // 프로토타입 메서드 (모든 인스턴스가 공유)
  addView() {
    this.viewCount++;
    return this;  // 메서드 체이닝을 위해 this 반환
  }
 
  addLike() {
    this.likeCount++;
    return this;
  }
 
  // toString 오버라이드
  toString() {
    return `[Post #${this.id}] ${this.title} (조회: ${this.viewCount})`;
  }
}
 
const post = new Post(1, "클로저 완전정복", 42);
post.addView().addView().addLike(); // 체이닝
console.log(post.toString()); // "[Post #1] 클로저 완전정복 (조회: 2)"

// ES2022 private 필드 — 진정한 캡슐화
class PostManager {
  // # 로 시작하는 필드는 클래스 외부에서 접근 불가
  #posts = new Map();
  #maxPosts;
  #adminIds = new Set();
 
  constructor(maxPosts = 1000) {
    this.#maxPosts = maxPosts;
  }
 
  addPost(post) {
    if (this.#posts.size >= this.#maxPosts) {
      throw new Error(`최대 게시글 수(${this.#maxPosts})를 초과했습니다.`);
    }
    this.#posts.set(post.id, post);
    return this;
  }
 
  // private 메서드
  #validatePost(post) {
    if (!post.title?.trim()) throw new Error("제목이 필요합니다.");
    return true;
  }
 
  getPost(id) {
    return this.#posts.get(id) ?? null;
  }
 
  get size() {
    return this.#posts.size; // getter로만 노출
  }
}
 
const manager = new PostManager(100);
manager.addPost({ id: 1, title: "클로저" });
manager.size; // 1
 
// 외부에서 접근 불가
manager.#posts;      // SyntaxError: Private field '#posts' must be declared
manager.#maxPosts;   // SyntaxError
manager.#adminIds;   // SyntaxError
 
// in 연산자로 private 필드 존재 확인 (ES2022)
#posts in manager; // true

class User {
  // static 필드 — 클래스 자체에 속함 (인스턴스 공유 안 함)
  static #count = 0;
  static MAX_LOGIN_ATTEMPTS = 5;
 
  constructor(name, email) {
    this.name = name;
    this.email = email;
    this.id = ++User.#count; // static 필드 접근
  }
 
  // static 메서드 — 인스턴스 없이 클래스로 직접 호출
  static getCount() {
    return User.#count;
  }
 
  static fromJSON(jsonString) {
    const { name, email } = JSON.parse(jsonString);
    return new User(name, email); // 팩토리 메서드
  }
 
  static validate(email) {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }
}
 
// 사용
const u1 = new User("영철", "yc@example.com");
const u2 = new User("영호", "yh@example.com");
User.getCount(); // 2
 
// 팩토리 메서드 — JSON에서 객체 생성
const u3 = User.fromJSON('{"name":"영수","email":"ys@example.com"}');
 
// 유효성 검사
User.validate("invalid-email"); // false
User.validate("yc@example.com"); // true

class Post {
  #_title = "";
  #_content = "";
  #isPublished = false;
  #publishedAt = null;
 
  constructor(title, content) {
    this.title = title;   // setter 호출
    this.content = content;
  }
 
  // getter — 계산된 값을 속성처럼 노출
  get wordCount() {
    return this.#_content.split(/\s+/).filter(Boolean).length;
  }
 
  get readingTime() {
    return Math.ceil(this.wordCount / 200); // 분당 200단어 기준
  }
 
  // getter + setter — 유효성 검사 포함
  get title() {
    return this.#_title;
  }
 
  set title(value) {
    const trimmed = value?.trim();
    if (!trimmed) throw new Error("제목은 비어있을 수 없습니다.");
    if (trimmed.length > 100) throw new Error("제목은 100자 이하여야 합니다.");
    this.#_title = trimmed;
  }
 
  get isPublished() {
    return this.#isPublished;
  }
 
  // setter 없음 — publish() 메서드를 통해서만 변경 (비즈니스 로직 보호)
  publish() {
    if (!this.#_title || !this.#_content) {
      throw new Error("제목과 내용이 있어야 발행할 수 있습니다.");
    }
    this.#isPublished = true;
    this.#publishedAt = new Date();
  }
}
 
const post = new Post("클로저 완전정복", "내용이 매우 길다...");
post.readingTime; // 계산된 값을 속성처럼 접근
post.title = ""; // Error: 제목은 비어있을 수 없습니다.
post.publish();
post.isPublished; // true

class BaseService {
  #baseUrl;
  #defaultHeaders;
 
  constructor(baseUrl) {
    this.#baseUrl = baseUrl;
    this.#defaultHeaders = { "Content-Type": "application/json" };
  }
 
  async request(method, endpoint, data = null) {
    const response = await fetch(`${this.#baseUrl}${endpoint}`, {
      method,
      headers: this.#defaultHeaders,
      body: data ? JSON.stringify(data) : null,
    });
 
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
 
    return response.json();
  }
 
  async get(endpoint) { return this.request("GET", endpoint); }
  async post(endpoint, data) { return this.request("POST", endpoint, data); }
  async put(endpoint, data) { return this.request("PUT", endpoint, data); }
  async delete(endpoint) { return this.request("DELETE", endpoint); }
}
 
class PostService extends BaseService {
  constructor() {
    super("https://api.youngsu.com"); // 부모 constructor 호출 (필수!)
  }
 
  async getPosts(page = 1) {
    return super.get(`/posts?page=${page}`); // 부모 메서드 호출
  }
 
  async createPost(data) {
    return super.post("/posts", data);
  }
 
  async getByAuthor(authorId) {
    return super.get(`/users/${authorId}/posts`);
  }
}
 
class AdminPostService extends PostService {
  async deletePost(postId) {
    return super.delete(`/posts/${postId}`);
  }
 
  async bulkDelete(postIds) {
    return super.post("/posts/bulk-delete", { ids: postIds });
  }
}
 
// 사용
const postService = new PostService();
const posts = await postService.getPosts(1);

// 영수네 커뮤니티 — 다양한 엔티티가 공통 기능을 조합
 
// 타임스탬프 믹스인
const Timestamped = (Base) =>
  class extends Base {
    createdAt = new Date();
    updatedAt = new Date();
 
    touch() {
      this.updatedAt = new Date();
      return this;
    }
  };
 
// 소프트 딜리트 믹스인
const SoftDeletable = (Base) =>
  class extends Base {
    #deletedAt = null;
 
    get isDeleted() {
      return this.#deletedAt !== null;
    }
 
    softDelete() {
      this.#deletedAt = new Date();
      return this;
    }
 
    restore() {
      this.#deletedAt = null;
      return this;
    }
  };
 
// 직렬화 믹스인
const Serializable = (Base) =>
  class extends Base {
    toJSON() {
      return JSON.parse(JSON.stringify(this));
    }
 
    static fromJSON(json) {
      return Object.assign(new this(), JSON.parse(json));
    }
  };
 
// 기반 클래스
class Entity {
  constructor(id) {
    this.id = id;
  }
}
 
// 믹스인 조합 — Post는 타임스탬프, 소프트 딜리트, 직렬화 기능을 모두 가짐
class Post extends Serializable(SoftDeletable(Timestamped(Entity))) {
  constructor(id, title, authorId) {
    super(id);
    this.title = title;
    this.authorId = authorId;
  }
}
 
const post = new Post(1, "클로저 완전정복", 42);
post.createdAt;     // Date (Timestamped)
post.isDeleted;     // false (SoftDeletable)
post.softDelete();  // 소프트 딜리트 (SoftDeletable)
post.touch();       // updatedAt 갱신 (Timestamped)
post.toJSON();      // JSON 직렬화 (Serializable)

// TypeScript에서의 클래스 활용
 
// interface — 구조(모양)만 정의, 런타임에 존재 안 함
interface Postable {
  id: number;
  title: string;
  publish(): void;
}
 
// abstract class — 일부 구현 포함 가능, new 불가, 런타임에 존재
abstract class BasePost {
  abstract validate(): boolean; // 서브클래스에서 반드시 구현
 
  publish() {
    if (!this.validate()) throw new Error("유효성 검사 실패");
    console.log("발행!");
  }
}
 
// 구체 클래스
class BlogPost extends BasePost implements Postable {
  constructor(
    public id: number,
    public title: string,
    private content: string
  ) {
    super();
  }
 
  validate(): boolean {
    return this.title.length > 0 && this.content.length > 0;
  }
}
 
// interface vs abstract class 선택 기준:
// interface: 구조만 강제할 때, 다중 구현 허용
// abstract class: 공통 구현(메서드 바디)을 제공하면서 일부는 서브클래스에 강제할 때

// 클로저 방식 — 관행적 private
const _data = new WeakMap();
class OldWay {
  constructor() { _data.set(this, { secret: 42 }); }
  getSecret() { return _data.get(this).secret; }
}
// 우회 가능: _data.get(instance).secret
 
// # 방식 — 언어 수준 강제
class NewWay {
  #secret = 42;
  getSecret() { return this.#secret; }
}
// 우회 불가: instance.#secret → SyntaxError (런타임도 아닌 파싱 단계에서 차단)

// 방법 1: 상속 (공통 기능이 긴밀히 연결될 때)
class BaseService {
  async request(method, url, data) { /* HTTP 처리 */ }
  log(message) { /* 로깅 */ }
}
class UserService extends BaseService { /* 유저 전용 */ }
class PostService extends BaseService { /* 게시글 전용 */ }
 
// 방법 2: 믹스인 (기능이 독립적일 때, 더 유연)
const Cacheable = (Base) => class extends Base {
  #cache = new Map();
  async cachedRequest(key, fn) {
    if (this.#cache.has(key)) return this.#cache.get(key);
    const result = await fn();
    this.#cache.set(key, result);
    return result;
  }
};
 
const Loggable = (Base) => class extends Base {
  log(level, message, context) { /* 로깅 */ }
};
 
class UserService extends Cacheable(Loggable(BaseService)) { }
class PostService extends Cacheable(Loggable(BaseService)) { }