디자인 패턴 in 자바스크립트

const Singleton = (function() {
    let instance; // 클로저에 의해 은닉된 인스턴스

    function init() {
        // 싱글톤 객체의 실제 생성 로직
        const privateRandomNumber = Math.random(); // 단 한 번만 생성
        console.log(`새로운 인스턴스 생성됨: ${privateRandomNumber}`);

        return {
            getPublicNumber: function() {
                return privateRandomNumber;
            },
            publicMethod: function() {
                console.log("싱글톤 공개 메서드 호출");
            }
        };
    }

    return {
        getInstance: function() {
            if (!instance) { // 인스턴스가 없으면 새로 생성
                instance = init();
            }
            return instance; // 이미 존재하면 기존 인스턴스 반환
        }
    };
})();

const singletonA = Singleton.getInstance();
const singletonB = Singleton.getInstance();

console.log(singletonA.getPublicNumber()); // 동일한 숫자 출력
console.log(singletonB.getPublicNumber()); // 동일한 숫자 출력

console.log(singletonA === singletonB); // 결과: true (동일한 인스턴스)

singletonA.publicMethod();

// 팩토리 함수
function createCharacter(type, name) {
    if (type === 'Warrior') {
        return {
            name: name,
            attack: function() {
                console.log(`${this.name}이(가) 검으로 공격합니다!`);
            }
        };
    } else if (type === 'Mage') {
        return {
            name: name,
            attack: function() {
                console.log(`${this.name}이(가) 마법으로 공격합니다!`);
            },
            castSpell: function() {
                console.log(`${this.name}이(가) 마법을 시전합니다!`);
            }
        };
    } else {
        throw new Error("알 수 없는 캐릭터 타입입니다.");
    }
}

const warrior = createCharacter('Warrior', '아서');
const mage = createCharacter('Mage', '멀린');

warrior.attack(); // 결과: 아서이(가) 검으로 공격합니다!
mage.attack();    // 결과: 멀린이(가) 마법으로 공격합니다!
mage.castSpell(); // 결과: 멀린이(가) 마법을 시전합니다!

// 간단한 이벤트 발행자 (Subject) 구현
class EventPublisher {
    constructor() {
        this.observers = []; // 구독자 목록
    }

    // 구독자 추가
    subscribe(observer) {
        this.observers.push(observer);
        console.log(`새로운 구독자 추가됨: ${observer.name}`);
    }

    // 구독자 제거
    unsubscribe(observer) {
        this.observers = this.observers.filter(obs => obs !== observer);
        console.log(`구독자 제거됨: ${observer.name}`);
    }

    // 모든 구독자에게 알림
    notify(data) {
        console.log("이벤트 발생! 모든 구독자에게 알림...");
        this.observers.forEach(observer => observer.update(data));
    }
}

// 구독자 (Observer) 구현
class EmailSender {
    constructor(name) {
        this.name = name;
    }
    update(data) {
        console.log(`${this.name}: 이메일 전송 - ${data.message}`);
    }
}

class Logger {
    constructor(name) {
        this.name = name;
    }
    update(data) {
        console.log(`${this.name}: 로그 기록 - ${data.message} (발생 시간: ${new Date().toLocaleTimeString()})`);
    }
}

const newsPublisher = new EventPublisher();

const emailService = new EmailSender("이메일 서비스");
const loggerService = new Logger("로깅 서비스");
const analyticsService = new Logger("분석 서비스"); // Logger를 재사용

newsPublisher.subscribe(emailService);
newsPublisher.subscribe(loggerService);
newsPublisher.subscribe(analyticsService);

newsPublisher.notify({ message: "새로운 기사가 발행되었습니다!" });

newsPublisher.unsubscribe(loggerService); // 로깅 서비스 구독 해제

newsPublisher.notify({ message: "특별 할인 이벤트 시작!" });

const publisherForPractice = new EventPublisher();
let callsForPractice = 0;
const observerForPractice = {
    name: "횟수 관찰자",
    update() { callsForPractice += 1; }
};
publisherForPractice.subscribe(observerForPractice);
publisherForPractice.subscribe(observerForPractice);
publisherForPractice.notify({ message: "첫 알림" });
console.log("첫 누적", callsForPractice);
publisherForPractice.unsubscribe(observerForPractice);
publisherForPractice.notify({ message: "둘째 알림" });
console.log("둘째 누적", callsForPractice);

const ShoppingCart = (function() {
    let items = []; // private 변수 (클로저에 의해 외부 접근 불가)

    function findItem(name) { // private 함수
        return items.find(item => item.name === name);
    }

    return { // public API
        addItem: function(name, price, quantity) {
            const existingItem = findItem(name);
            if (existingItem) {
                existingItem.quantity += quantity;
            } else {
                items.push({ name, price, quantity });
            }
            console.log(`${name} ${quantity}개 추가됨.`);
        },
        removeItem: function(name) {
            items = items.filter(item => item.name !== name);
            console.log(`${name} 제거됨.`);
        },
        getTotal: function() {
            return items.reduce((total, item) => total + (item.price * item.quantity), 0);
        },
        getCartItems: function() {
            return [...items]; // 배열만 얕게 복사하므로 품목 객체는 공유됨; 깊은 불변성은 아님
        }
    };
})();

ShoppingCart.addItem("사과", 1000, 2);
ShoppingCart.addItem("바나나", 1500, 1);
ShoppingCart.addItem("사과", 1000, 3); // 사과 2 + 3 = 5개 됨

console.log("장바구니 총액:", ShoppingCart.getTotal()); // 결과: 6500 (1000 × 5 + 1500)
console.log("장바구니 품목:", ShoppingCart.getCartItems());

// console.log(ShoppingCart.items); // undefined (접근 불가)
// console.log(ShoppingCart.findItem); // undefined (접근 불가)

const exposedItemsForPattern = ShoppingCart.getCartItems();
exposedItemsForPattern[0].quantity = 1;
console.log("바뀐 총액", ShoppingCart.getTotal());
exposedItemsForPattern.push({ name: "배", price: 2000, quantity: 1 });
console.log("내부 품목 수", ShoppingCart.getCartItems().length);