Prototype Pattern

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import copy

class Product:
    def __init__(self, name, tags):
        self.name = name
        self.tags = tags  # 리스트는 얕은 복사 시 공유됨

    def clone(self):
        return copy.copy(self)  # 얕은 복사

# 사용 예시
original = Product("Book", ["tech", "python"])
cloned = original.clone()
cloned.tags.append("ai")

print(original.tags)  # ['tech', 'python', 'ai'] - 얕은 복사의 특성
print(cloned.tags)    # 동일한 리스트 참조

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import copy

class Product:
    def __init__(self, name, tags):
        self.name = name
        self.tags = tags  # 리스트 구조 등 포함

    def clone(self):
        return copy.deepcopy(self)  # 깊은 복사

# 사용 예시
original = Product("Laptop", ["electronics", "computing"])
cloned = original.clone()
cloned.tags.append("portable")

print(original.tags)  # ['electronics', 'computing']
print(cloned.tags)    # ['electronics', 'computing', 'portable']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import copy

class PrototypeRegistry:
    def __init__(self):
        self._prototypes = {}

    def register(self, name, prototype):
        self._prototypes[name] = prototype

    def unregister(self, name):
        del self._prototypes[name]

    def clone(self, name, **attrs):
        prototype = self._prototypes.get(name)
        if not prototype:
            raise ValueError(f"Prototype '{name}' not found")
        cloned = copy.deepcopy(prototype)
        cloned.__dict__.update(attrs)  # 선택적 속성 변경
        return cloned

# 프로토타입 정의
class Button:
    def __init__(self, label, color):
        self.label = label
        self.color = color

    def __str__(self):
        return f"Button(label={self.label}, color={self.color})"

# 사용 예시
registry = PrototypeRegistry()
registry.register("submit", Button("Submit", "blue"))
registry.register("cancel", Button("Cancel", "gray"))

btn1 = registry.clone("submit", color="green")
btn2 = registry.clone("cancel")

print(btn1)  # Button(label=Submit, color=green)
print(btn2)  # Button(label=Cancel, color=gray)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class Report:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def to_builder(self):
        return ReportBuilder(self)

    def __str__(self):
        return f"Report(title={self.title}, author={self.author}, pages={self.pages})"

class ReportBuilder:
    def __init__(self, prototype=None):
        if prototype:
            self.title = prototype.title
            self.author = prototype.author
            self.pages = list(prototype.pages)
        else:
            self.title = ""
            self.author = ""
            self.pages = []

    def set_title(self, title):
        self.title = title
        return self

    def set_author(self, author):
        self.author = author
        return self

    def add_page(self, content):
        self.pages.append(content)
        return self

    def build(self):
        return Report(self.title, self.author, self.pages)

# 사용 예시
original = Report("ML Report", "Alice", ["Intro", "Data", "Model"])
draft = original.to_builder().set_title("ML Report (Draft)").add_page("Conclusion").build()

print(original)  # 원본 보고서
print(draft)     # 일부 수정된 복제본

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import pickle

class Document:
    def __init__(self, content, metadata):
        self.content = content
        self.metadata = metadata

    def deep_clone(self):
        return pickle.loads(pickle.dumps(self))

# 사용 예시
original_doc = Document("Text here", {"author": "Bob", "version": 1})
cloned_doc = original_doc.deep_clone()
cloned_doc.metadata["version"] = 2

print(original_doc.metadata)  # {'author': 'Bob', 'version': 1}
print(cloned_doc.metadata)    # {'author': 'Bob', 'version': 2}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import copy
from abc import ABC, abstractmethod

# Prototype Interface
class Shape(ABC):
    @abstractmethod
    def clone(self):
        pass

    @abstractmethod
    def draw(self):
        pass


# 구체적인 Prototype: 원
class Circle(Shape):
    def __init__(self, x, y, radius, color):
        self.x = x
        self.y = y
        self.radius = radius
        self.color = color

    def clone(self):
        return copy.deepcopy(self)

    def draw(self):
        print(f"[Circle] 위치: ({self.x}, {self.y}), 반지름: {self.radius}, 색상: {self.color}")


# 구체적인 Prototype: 사각형
class Rectangle(Shape):
    def __init__(self, x, y, width, height, color):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.color = color

    def clone(self):
        return copy.deepcopy(self)

    def draw(self):
        print(f"[Rectangle] 위치: ({self.x}, {self.y}), 크기: {self.width}x{self.height}, 색상: {self.color}")


# 클라이언트: 사용자 인터페이스 동작 시뮬레이션
def simulate_editor_clone():
    # 도형 객체 생성
    original_circle = Circle(100, 200, 50, "red")
    original_rectangle = Rectangle(50, 50, 150, 100, "blue")

    # 도형 복제 (Prototype 사용)
    cloned_circle = original_circle.clone()
    cloned_rectangle = original_rectangle.clone()

    # 복제된 도형의 속성 수정
    cloned_circle.x += 50
    cloned_circle.color = "green"

    cloned_rectangle.y += 30
    cloned_rectangle.color = "orange"

    # 결과 출력
    print("🎨 원본 도형:")
    original_circle.draw()
    original_rectangle.draw()

    print("\n🖨️ 복제된 도형:")
    cloned_circle.draw()
    cloned_rectangle.draw()


# 실행
simulate_editor_clone()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

import copy

# 상품 클래스 정의
class Product:
    def __init__(self, name, category, price, tax_rate, shipping_policy, return_policy):
        self.name = name
        self.category = category
        self.price = price
        self.tax_rate = tax_rate
        self.shipping_policy = shipping_policy
        self.return_policy = return_policy

    def clone(self):
        return copy.deepcopy(self)

    def set_details(self, name, price):
        self.name = name
        self.price = price

    def __str__(self):
        return (f"상품명: {self.name}, 카테고리: {self.category}, 가격: {self.price}, "
                f"세금: {self.tax_rate}, 배송: {self.shipping_policy}, 반품: {self.return_policy}")


# 상품 프로토타입 레지스트리
class ProductRegistry:
    def __init__(self):
        self._prototypes = {}

    def register_prototype(self, category, prototype: Product):
        self._prototypes[category] = prototype

    def create_product(self, category, name, price):
        if category not in self._prototypes:
            raise ValueError(f"카테고리 '{category}'에 대한 프로토타입이 등록되지 않았습니다.")
        product = self._prototypes[category].clone()
        product.set_details(name, price)
        return product


# 초기 설정: 시스템 부팅 시 카테고리별 프로토타입 등록
def initialize_registry():
    registry = ProductRegistry()

    # 카테고리별 공통 설정 등록
    registry.register_prototype(
        "전자제품",
        Product(
            name="Prototype-Electronics",
            category="전자제품",
            price=0,
            tax_rate="10%",
            shipping_policy="2일 이내 배송",
            return_policy="7일 이내 무료 반품"
        )
    )

    registry.register_prototype(
        "도서",
        Product(
            name="Prototype-Book",
            category="도서",
            price=0,
            tax_rate="5%",
            shipping_policy="3일 이내 배송",
            return_policy="반품 불가"
        )
    )

    return registry


# 클라이언트: 새 상품 생성 요청 시 워크플로우
def simulate_product_creation():
    registry = initialize_registry()

    # 새 상품 생성
    macbook = registry.create_product("전자제품", "MacBook Air M3", 1690000)
    book = registry.create_product("도서", "Clean Architecture", 35000)

    # 출력
    print("📦 신규 등록 상품:")
    print(macbook)
    print(book)


# 실행
simulate_product_creation()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

                    ┌─────────────────────┐
                    │   GameClient        │
                    │  (캐릭터 생성 요청)   │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │ CharacterFactory    │
                    │  (캐릭터 생성 관리자) │
                    └──────────┬──────────┘
                               │
                               ▼
            ┌─────────────────────────────────────────┐
            │        CharacterRegistry                │
            │     (캐릭터 프로토타입 레지스트리)          │
            ├─────────────────────────────────────────┤
            │ - warriorPrototype: WarriorCharacter    │
            │ - magePrototype: MageCharacter          │  
            │ - archerPrototype: ArcherCharacter      │
            │ - npcPrototype: NPCCharacter            │
            └──────────┬──────────────────────────────┘
                       │
                       ▼
            ┌─────────────────────┐
            │     Character       │
            │   (Abstract Base)   │
            ├─────────────────────┤
            │ + clone(): Character│
            │ + initialize()      │
            │ + render()          │
            └───────────┬─────────┘
                        △
                        │
          ┌─────────────┼───────────────┐
          │             │               │
┌─────────┴───────┐ ┌───┴─────────┐ ┌───┴───────────┐
│WarriorCharacter │ │MageCharacter│ │ArcherCharacter│
├─────────────────┤ ├─────────────┤ ├───────────────┤
│+ clone()        │ │+ clone()    │ │+ clone()      │
│+ swordAttack()  │ │+ castSpell()│ │+ bowAttack()  │
└─────────────────┘ └─────────────┘ └───────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// 캐릭터 프로토타입 인터페이스
public abstract class Character implements Cloneable {
    protected String name;
    protected int level;
    protected int hp, mp;
    protected Map<String, Integer> stats;
    protected List<Skill> skills;
    protected Equipment equipment;
    
    public abstract Character clone();
    public abstract void performSpecialAttack();
}

// 전사 캐릭터 구체 구현
public class WarriorCharacter extends Character {
    @Override
    public WarriorCharacter clone() {
        WarriorCharacter cloned = new WarriorCharacter();
        cloned.level = this.level;
        cloned.hp = this.hp;
        cloned.mp = this.mp;
        cloned.stats = new HashMap<>(this.stats);
        cloned.skills = new ArrayList<>(this.skills);
        cloned.equipment = this.equipment.deepCopy();
        return cloned;
    }
    
    @Override
    public void performSpecialAttack() {
        // 전사 고유의 특수 공격
    }
}

// 캐릭터 레지스트리
public class CharacterRegistry {
    private static final Map<String, Character> prototypes = new HashMap<>();
    
    static {
        // 기본 프로토타입들 초기화
        WarriorCharacter warrior = new WarriorCharacter();
        warrior.setLevel(1);
        warrior.setHp(100);
        warrior.getStats().put("strength", 15);
        warrior.getStats().put("dexterity", 10);
        prototypes.put("WARRIOR", warrior);
        
        MageCharacter mage = new MageCharacter();
        mage.setLevel(1);
        mage.setHp(60);
        mage.setMp(100);
        mage.getStats().put("intelligence", 15);
        mage.getStats().put("wisdom", 12);
        prototypes.put("MAGE", mage);
    }
    
    public static Character getCharacter(String type) {
        Character prototype = prototypes.get(type);
        return prototype != null ? prototype.clone() : null;
    }
}

// 캐릭터 팩토리
public class CharacterFactory {
    public Character createPlayerCharacter(String characterClass, String playerName) {
        Character character = CharacterRegistry.getCharacter(characterClass);
        character.setName(playerName);
        character.setLevel(1); // 새 플레이어는 1레벨부터 시작
        return character;
    }
    
    public List<Character> createNPCs(String npcType, int count) {
        List<Character> npcs = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            Character npc = CharacterRegistry.getCharacter(npcType);
            npc.setName("NPC_" + npcType + "_" + (i + 1));
            // NPC별 고유 설정 추가
            npcs.add(npc);
        }
        return npcs;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import copy

class PrototypeRegistry:
    def __init__(self):
        self._protos = {}

    def register(self, name, obj):
        self._protos[name] = obj

    def unregister(self, name):
        del self._protos[name]

    def clone(self, name, **attrs):
        proto = self._protos.get(name)
        if not proto:
            raise ValueError(f"No prototype registered: {name}")
        obj = copy.deepcopy(proto)
        obj.__dict__.update(attrs)
        return obj

# Concrete Prototype
class Car:
    def __init__(self, make, model, details):
        self.make = make
        self.model = model
        self.details = details  # dict

# registry 설정
reg = PrototypeRegistry()
reg.register("mustang", Car("Ford", "Mustang", {"color": "Red", "horsepower": 400}))

# clone 응용
new_car = reg.clone("mustang", details={"color": "Blue", "horsepower": 420})
print(vars(new_car))

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323

// 프로토타입 인터페이스 정의
class ProductPrototype {
    constructor() {
        if (this.constructor === ProductPrototype) {
            throw new Error("Abstract class cannot be instantiated");
        }
    }
    
    // 추상 메서드 - 하위 클래스에서 구현 필요
    clone() {
        throw new Error("Clone method must be implemented");
    }
}

// 전자제품 프로토타입 구현
class ElectronicsPrototype extends ProductPrototype {
    constructor() {
        super();
        // 전자제품 공통 속성 초기화
        this.category = "Electronics";
        this.warranty = "1 year";
        this.shippingWeight = 2.0;
        this.taxRate = 0.08;
        this.returnPolicy = "30-day return";
        this.certifications = ["CE", "FCC"];
        this.powerRequirements = "AC 100-240V";
    }
    
    // 깊은 복사 구현
    clone() {
        const cloned = new ElectronicsPrototype();
        
        // 기본 속성 복사
        cloned.category = this.category;
        cloned.warranty = this.warranty;
        cloned.shippingWeight = this.shippingWeight;
        cloned.taxRate = this.taxRate;
        cloned.returnPolicy = this.returnPolicy;
        cloned.powerRequirements = this.powerRequirements;
        
        // 배열의 깊은 복사
        cloned.certifications = […this.certifications];
        
        return cloned;
    }
    
    // 개별 상품 정보 설정 메서드
    setProductDetails(name, price, brand, model) {
        this.productName = name;
        this.price = price;
        this.brand = brand;
        this.model = model;
        this.productId = `ELEC_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        return this;
    }
    
    // 제품 정보 출력
    getProductInfo() {
        return {
            productId: this.productId,
            productName: this.productName,
            category: this.category,
            price: this.price,
            brand: this.brand,
            model: this.model,
            warranty: this.warranty,
            taxRate: this.taxRate,
            certifications: this.certifications
        };
    }
}

// 의류 프로토타입 구현
class ClothingPrototype extends ProductPrototype {
    constructor() {
        super();
        // 의류 공통 속성 초기화
        this.category = "Clothing";
        this.warranty = "No warranty";
        this.shippingWeight = 0.5;
        this.taxRate = 0.06;
        this.returnPolicy = "14-day return";
        this.careInstructions = ["Machine wash cold", "Do not bleach"];
        this.materials = [];
    }
    
    clone() {
        const cloned = new ClothingPrototype();
        
        cloned.category = this.category;
        cloned.warranty = this.warranty;
        cloned.shippingWeight = this.shippingWeight;
        cloned.taxRate = this.taxRate;
        cloned.returnPolicy = this.returnPolicy;
        
        // 배열의 깊은 복사
        cloned.careInstructions = […this.careInstructions];
        cloned.materials = […this.materials];
        
        return cloned;
    }
    
    setProductDetails(name, price, brand, size, color) {
        this.productName = name;
        this.price = price;
        this.brand = brand;
        this.size = size;
        this.color = color;
        this.productId = `CLOTH_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        return this;
    }
    
    getProductInfo() {
        return {
            productId: this.productId,
            productName: this.productName,
            category: this.category,
            price: this.price,
            brand: this.brand,
            size: this.size,
            color: this.color,
            careInstructions: this.careInstructions,
            materials: this.materials
        };
    }
}

// 프로토타입 레지스트리 구현
class ProductPrototypeRegistry {
    constructor() {
        this.prototypes = new Map();
        this.initializeDefaultPrototypes();
    }
    
    // 기본 프로토타입들 초기화
    initializeDefaultPrototypes() {
        this.registerPrototype("electronics", new ElectronicsPrototype());
        this.registerPrototype("clothing", new ClothingPrototype());
    }
    
    // 프로토타입 등록
    registerPrototype(key, prototype) {
        if (!(prototype instanceof ProductPrototype)) {
            throw new Error("Prototype must extend ProductPrototype");
        }
        this.prototypes.set(key, prototype);
        console.log(`Prototype '${key}' registered successfully`);
    }
    
    // 프로토타입 조회 및 복제
    getPrototype(key) {
        const prototype = this.prototypes.get(key);
        if (!prototype) {
            throw new Error(`Prototype '${key}' not found`);
        }
        return prototype.clone();
    }
    
    // 등록된 프로토타입 목록 조회
    getAvailablePrototypes() {
        return Array.from(this.prototypes.keys());
    }
    
    // 프로토타입 제거
    removePrototype(key) {
        const removed = this.prototypes.delete(key);
        if (removed) {
            console.log(`Prototype '${key}' removed successfully`);
        }
        return removed;
    }
}

// 상품 팩토리 클라이언트
class ProductFactory {
    constructor() {
        this.registry = new ProductPrototypeRegistry();
    }
    
    // 상품 생성 메서드
    createProduct(category, productDetails) {
        try {
            // 성능 측정 시작
            const startTime = performance.now();
            
            // 프로토타입 복제
            const product = this.registry.getPrototype(category);
            
            // 개별 상품 정보 설정
            if (category === "electronics") {
                product.setProductDetails(
                    productDetails.name,
                    productDetails.price,
                    productDetails.brand,
                    productDetails.model
                );
            } else if (category === "clothing") {
                product.setProductDetails(
                    productDetails.name,
                    productDetails.price,
                    productDetails.brand,
                    productDetails.size,
                    productDetails.color
                );
            }
            
            // 성능 측정 종료
            const endTime = performance.now();
            console.log(`Product created in ${(endTime - startTime).toFixed(2)}ms`);
            
            return product;
        } catch (error) {
            console.error("Error creating product:", error.message);
            return null;
        }
    }
    
    // 대량 상품 생성 (성능 테스트용)
    createBulkProducts(category, count = 1000) {
        const startTime = performance.now();
        const products = [];
        
        for (let i = 0; i < count; i++) {
            const productDetails = {
                name: `Product ${i}`,
                price: 100 + i,
                brand: `Brand ${i % 10}`,
                model: `Model ${i}`,
                size: ["S", "M", "L", "XL"][i % 4],
                color: ["Red", "Blue", "Green", "Black"][i % 4]
            };
            
            const product = this.createProduct(category, productDetails);
            if (product) {
                products.push(product);
            }
        }
        
        const endTime = performance.now();
        console.log(`Created ${products.length} products in ${(endTime - startTime).toFixed(2)}ms`);
        console.log(`Average time per product: ${((endTime - startTime) / count).toFixed(4)}ms`);
        
        return products;
    }
}

// 사용 예시 및 데모
function demonstratePrototypePattern() {
    console.log("=== 프로토타입 패턴 데모 시작 ===\n");
    
    // 팩토리 인스턴스 생성
    const factory = new ProductFactory();
    
    // 사용 가능한 프로토타입 확인
    console.log("사용 가능한 프로토타입:", factory.registry.getAvailablePrototypes());
    console.log();
    
    // 개별 상품 생성 예시
    console.log("1. 개별 상품 생성:");
    
    // 전자제품 생성
    const laptop = factory.createProduct("electronics", {
        name: "Gaming Laptop Pro",
        price: 1299.99,
        brand: "TechCorp",
        model: "GL-2024"
    });
    
    if (laptop) {
        console.log("전자제품 생성 완료:", laptop.getProductInfo());
    }
    
    // 의류 생성
    const tshirt = factory.createProduct("clothing", {
        name: "Cotton T-Shirt",
        price: 29.99,
        brand: "FashionCo",
        size: "M",
        color: "Blue"
    });
    
    if (tshirt) {
        console.log("의류 생성 완료:", tshirt.getProductInfo());
    }
    
    console.log("\n2. 복제된 객체의 독립성 테스트:");
    
    // 동일한 프로토타입에서 여러 객체 생성
    const phone1 = factory.createProduct("electronics", {
        name: "Smartphone X",
        price: 799.99,
        brand: "MobileTech",
        model: "SMX-2024"
    });
    
    const phone2 = factory.createProduct("electronics", {
        name: "Smartphone Y",
        price: 899.99,
        brand: "MobileTech",
        model: "SMY-2024"
    });
    
    // 객체 독립성 확인
    phone1.certifications.push("Custom Cert");
    
    console.log("Phone1 certifications:", phone1.certifications);
    console.log("Phone2 certifications:", phone2.certifications);
    console.log("Certifications are independent:", 
                phone1.certifications.length !== phone2.certifications.length);
    
    console.log("\n3. 성능 테스트 - 대량 객체 생성:");
    
    // 전자제품 1000개 생성
    factory.createBulkProducts("electronics", 1000);
    
    // 의류 1000개 생성  
    factory.createBulkProducts("clothing", 1000);
    
    console.log("\n=== 프로토타입 패턴 데모 완료 ===");
}

// 데모 실행
demonstratePrototypePattern();