JavaScript原型模式2024：前端开发者掌握对象克隆与深拷贝的完整指南

📊 SEO元描述：2024年最新JavaScript原型模式教程，详解对象克隆实现、深拷贝vs浅拷贝、原型链应用。包含完整实战案例，适合前端开发者掌握创建型设计模式。

核心关键词：JavaScript原型模式2024、对象克隆实现、深拷贝浅拷贝、原型链应用、JavaScript设计模式、对象复制技术

长尾关键词：JavaScript原型模式怎么实现、深拷贝和浅拷贝区别、JavaScript对象克隆最佳实践、原型链设计模式、前端对象复制优化

---

📚 JavaScript原型模式学习目标与核心收获

通过本节JavaScript原型模式完整指南，你将系统性掌握：

• ✅ 原型模式核心概念：深入理解原型模式的定义、特点和JavaScript原型链机制
• ✅ 对象克隆技术精通：掌握浅拷贝、深拷贝的实现方法和性能优化
• ✅ 原型链应用实战：学会利用JavaScript原型链实现继承和对象扩展
• ✅ 克隆策略选择：理解不同场景下的克隆策略选择和最佳实践
• ✅ 性能优化技巧：掌握大对象克隆的性能优化和内存管理
• ✅ 实战项目应用：在真实项目中正确应用原型模式解决实际问题

🎯 适合人群

• 前端开发工程师希望深入理解JavaScript对象机制和克隆技术
• JavaScript高级开发者需要掌握原型链和面向对象编程高级技巧
• 性能优化专家关注对象操作的性能和内存优化
• 架构师想要提升JavaScript应用的设计和架构能力

---

🌟 什么是原型模式？为什么原型模式如此重要？

原型模式是什么？这是创建型设计模式中与JavaScript语言特性最为契合的模式。原型模式（Prototype Pattern）是指通过复制现有对象来创建新对象，而不是通过实例化类来创建的设计模式，也是JavaScript面向对象编程的核心机制。

原型模式的核心价值

• 🎯 性能优化：避免重复的初始化过程，通过克隆快速创建对象
• 🔧 动态创建：在运行时动态创建对象，支持灵活的对象构建
• 💡 状态保持：保持对象的当前状态，创建具有相同状态的新对象
• 📚 原型链利用：充分利用JavaScript的原型链机制实现继承
• 🚀 内存效率：通过原型共享方法，减少内存占用

💡 设计模式建议：原型模式在JavaScript中有着天然的优势，通过Object.create()、原型链、以及现代的克隆技术，可以实现高效的对象创建和管理。

对象克隆实现：从浅拷贝到深拷贝

对象克隆是原型模式的核心技术，包括浅拷贝和深拷贝两种主要方式。

// 🎉 完整的对象克隆实现

// 基础克隆工具类
class ObjectCloner {
    constructor() {
        this.cloneCache = new WeakMap();
        this.performanceMetrics = {
            cloneCount: 0,
            totalTime: 0,
            averageTime: 0
        };
    }
    
    // 浅拷贝实现
    shallowClone(obj) {
        const startTime = performance.now();
        
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        
        let cloned;
        
        if (obj instanceof Date) {
            cloned = new Date(obj.getTime());
        } else if (obj instanceof Array) {
            cloned = [...obj];
        } else if (obj instanceof RegExp) {
            cloned = new RegExp(obj.source, obj.flags);
        } else if (obj instanceof Map) {
            cloned = new Map(obj);
        } else if (obj instanceof Set) {
            cloned = new Set(obj);
        } else {
            cloned = { ...obj };
        }
        
        this.updateMetrics(startTime);
        return cloned;
    }
    
    // 深拷贝实现
    deepClone(obj, cache = new WeakMap()) {
        const startTime = performance.now();
        
        // 处理基本类型和null
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        
        // 检查循环引用
        if (cache.has(obj)) {
            return cache.get(obj);
        }
        
        let cloned;
        
        // 处理不同类型的对象
        if (obj instanceof Date) {
            cloned = new Date(obj.getTime());
        } else if (obj instanceof RegExp) {
            cloned = new RegExp(obj.source, obj.flags);
        } else if (obj instanceof Map) {
            cloned = new Map();
            cache.set(obj, cloned);
            for (const [key, value] of obj) {
                cloned.set(this.deepClone(key, cache), this.deepClone(value, cache));
            }
        } else if (obj instanceof Set) {
            cloned = new Set();
            cache.set(obj, cloned);
            for (const value of obj) {
                cloned.add(this.deepClone(value, cache));
            }
        } else if (obj instanceof Array) {
            cloned = [];
            cache.set(obj, cloned);
            for (let i = 0; i < obj.length; i++) {
                cloned[i] = this.deepClone(obj[i], cache);
            }
        } else if (obj instanceof Error) {
            cloned = new Error(obj.message);
            cloned.name = obj.name;
            cloned.stack = obj.stack;
        } else if (typeof obj === 'function') {
            // 函数克隆（注意：这是一个复杂的话题）
            cloned = obj;
        } else {
            // 普通对象
            cloned = Object.create(Object.getPrototypeOf(obj));
            cache.set(obj, cloned);
            
            // 复制所有属性（包括不可枚举属性）
            const descriptors = Object.getOwnPropertyDescriptors(obj);
            for (const key in descriptors) {
                const descriptor = descriptors[key];
                if (descriptor.value !== undefined) {
                    descriptor.value = this.deepClone(descriptor.value, cache);
                }
                Object.defineProperty(cloned, key, descriptor);
            }
        }
        
        this.updateMetrics(startTime);
        return cloned;
    }
    
    // 高性能深拷贝（使用结构化克隆算法）
    structuredClone(obj) {
        const startTime = performance.now();
        
        try {
            // 使用浏览器原生的结构化克隆
            if (typeof structuredClone !== 'undefined') {
                const cloned = structuredClone(obj);
                this.updateMetrics(startTime);
                return cloned;
            }
            
            // 降级到MessageChannel方式
            return new Promise((resolve, reject) => {
                const channel = new MessageChannel();
                channel.port1.onmessage = (e) => {
                    this.updateMetrics(startTime);
                    resolve(e.data);
                };
                channel.port1.onmessageerror = reject;
                channel.port2.postMessage(obj);
            });
            
        } catch (error) {
            console.warn('Structured clone failed, falling back to deep clone:', error);
            return this.deepClone(obj);
        }
    }
    
    // JSON方式深拷贝（快速但有限制）
    jsonClone(obj) {
        const startTime = performance.now();
        
        try {
            const cloned = JSON.parse(JSON.stringify(obj));
            this.updateMetrics(startTime);
            return cloned;
        } catch (error) {
            console.error('JSON clone failed:', error);
            throw new Error('Object contains non-serializable properties');
        }
    }
    
    // 智能克隆（根据对象特征选择最佳策略）
    smartClone(obj, options = {}) {
        const { deep = true, preservePrototype = true, handleCircular = true } = options;
        
        if (!deep) {
            return this.shallowClone(obj);
        }
        
        // 检查对象复杂度
        const complexity = this.analyzeComplexity(obj);
        
        if (complexity.hasCircularRef && !handleCircular) {
            throw new Error('Circular reference detected');
        }
        
        if (complexity.isSimple && !preservePrototype) {
            return this.jsonClone(obj);
        }
        
        if (complexity.isLarge && typeof structuredClone !== 'undefined') {
            return this.structuredClone(obj);
        }
        
        return this.deepClone(obj);
    }
    
    // 分析对象复杂度
    analyzeComplexity(obj, visited = new WeakSet()) {
        const analysis = {
            depth: 0,
            nodeCount: 0,
            hasCircularRef: false,
            hasFunctions: false,
            hasSpecialObjects: false,
            isSimple: true,
            isLarge: false
        };
        
        this.analyzeObject(obj, analysis, visited, 0);
        
        analysis.isSimple = !analysis.hasFunctions && 
                           !analysis.hasSpecialObjects && 
                           !analysis.hasCircularRef &&
                           analysis.depth < 5;
        
        analysis.isLarge = analysis.nodeCount > 1000;
        
        return analysis;
    }
    
    analyzeObject(obj, analysis, visited, depth) {
        if (obj === null || typeof obj !== 'object') {
            return;
        }
        
        if (visited.has(obj)) {
            analysis.hasCircularRef = true;
            return;
        }
        
        visited.add(obj);
        analysis.nodeCount++;
        analysis.depth = Math.max(analysis.depth, depth);
        
        if (typeof obj === 'function') {
            analysis.hasFunctions = true;
        }
        
        if (obj instanceof Date || obj instanceof RegExp || 
            obj instanceof Map || obj instanceof Set) {
            analysis.hasSpecialObjects = true;
        }
        
        if (obj instanceof Array) {
            for (const item of obj) {
                this.analyzeObject(item, analysis, visited, depth + 1);
            }
        } else {
            for (const key in obj) {
                if (obj.hasOwnProperty(key)) {
                    this.analyzeObject(obj[key], analysis, visited, depth + 1);
                }
            }
        }
        
        visited.delete(obj);
    }
    
    // 更新性能指标
    updateMetrics(startTime) {
        const duration = performance.now() - startTime;
        this.performanceMetrics.cloneCount++;
        this.performanceMetrics.totalTime += duration;
        this.performanceMetrics.averageTime = 
            this.performanceMetrics.totalTime / this.performanceMetrics.cloneCount;
    }
    
    // 获取性能报告
    getPerformanceReport() {
        return {
            ...this.performanceMetrics,
            efficiency: this.calculateEfficiency()
        };
    }
    
    calculateEfficiency() {
        // 基于平均克隆时间计算效率
        const baselineTime = 1; // 1ms基准
        return Math.max(0, 100 - (this.performanceMetrics.averageTime / baselineTime) * 100);
    }
    
    // 重置性能指标
    resetMetrics() {
        this.performanceMetrics = {
            cloneCount: 0,
            totalTime: 0,
            averageTime: 0
        };
    }
}

// 原型对象基类
class Prototype {
    constructor() {
        this.id = Math.random().toString(36).substr(2, 9);
        this.created = new Date();
        this.cloner = new ObjectCloner();
    }
    
    // 克隆方法
    clone(deep = true) {
        if (deep) {
            return this.cloner.deepClone(this);
        } else {
            return this.cloner.shallowClone(this);
        }
    }
    
    // 智能克隆
    smartClone(options) {
        return this.cloner.smartClone(this, options);
    }
    
    // 获取克隆信息
    getCloneInfo() {
        return {
            id: this.id,
            created: this.created,
            type: this.constructor.name
        };
    }
}

// 具体原型类示例
class UserProfile extends Prototype {
    constructor(data = {}) {
        super();
        this.name = data.name || '';
        this.email = data.email || '';
        this.avatar = data.avatar || '';
        this.preferences = data.preferences || {
            theme: 'light',
            language: 'en',
            notifications: true
        };
        this.friends = data.friends || [];
        this.metadata = data.metadata || new Map();
        this.tags = data.tags || new Set();
    }
    
    // 添加朋友
    addFriend(friend) {
        this.friends.push(friend);
        return this;
    }
    
    // 设置偏好
    setPreference(key, value) {
        this.preferences[key] = value;
        return this;
    }
    
    // 添加元数据
    addMetadata(key, value) {
        this.metadata.set(key, value);
        return this;
    }
    
    // 添加标签
    addTag(tag) {
        this.tags.add(tag);
        return this;
    }
    
    // 创建副本（保持某些属性独立）
    createCopy(options = {}) {
        const copy = this.clone(true);
        
        if (options.newId) {
            copy.id = Math.random().toString(36).substr(2, 9);
        }
        
        if (options.clearFriends) {
            copy.friends = [];
        }
        
        if (options.resetPreferences) {
            copy.preferences = {
                theme: 'light',
                language: 'en',
                notifications: true
            };
        }
        
        return copy;
    }
    
    // 序列化
    toJSON() {
        return {
            id: this.id,
            name: this.name,
            email: this.email,
            avatar: this.avatar,
            preferences: this.preferences,
            friends: this.friends,
            metadata: Object.fromEntries(this.metadata),
            tags: Array.from(this.tags),
            created: this.created
        };
    }
    
    // 从JSON恢复
    static fromJSON(json) {
        const profile = new UserProfile(json);
        profile.id = json.id;
        profile.created = new Date(json.created);
        profile.metadata = new Map(Object.entries(json.metadata || {}));
        profile.tags = new Set(json.tags || []);
        return profile;
    }
}

// 使用示例
console.log('=== 原型模式测试 ===');

const cloner = new ObjectCloner();

// 测试不同类型的克隆
const testData = {
    name: 'John Doe',
    age: 30,
    hobbies: ['reading', 'coding', 'gaming'],
    address: {
        street: '123 Main St',
        city: 'New York',
        coordinates: { lat: 40.7128, lng: -74.0060 }
    },
    metadata: new Map([['role', 'developer'], ['level', 'senior']]),
    tags: new Set(['javascript', 'react', 'node']),
    created: new Date(),
    pattern: /^[a-z]+$/i
};

// 浅拷贝测试
console.log('=== 浅拷贝测试 ===');
const shallowCopy = cloner.shallowClone(testData);
console.log('Original === Shallow copy:', testData === shallowCopy); // false
console.log('Address === Shallow address:', testData.address === shallowCopy.address); // true

// 深拷贝测试
console.log('=== 深拷贝测试 ===');
const deepCopy = cloner.deepClone(testData);
console.log('Original === Deep copy:', testData === deepCopy); // false
console.log('Address === Deep address:', testData.address === deepCopy.address); // false
console.log('Deep copy metadata:', deepCopy.metadata);
console.log('Deep copy tags:', deepCopy.tags);

// 循环引用测试
console.log('=== 循环引用测试 ===');
const circularObj = { name: 'circular' };
circularObj.self = circularObj;

const circularCopy = cloner.deepClone(circularObj);
console.log('Circular copy self reference:', circularCopy.self === circularCopy); // true

// 智能克隆测试
console.log('=== 智能克隆测试 ===');
const complexity = cloner.analyzeComplexity(testData);
console.log('Object complexity analysis:', complexity);

const smartCopy = cloner.smartClone(testData, {
    deep: true,
    preservePrototype: true,
    handleCircular: true
});
console.log('Smart clone result:', smartCopy);

// UserProfile原型测试
console.log('=== UserProfile原型测试 ===');
const originalProfile = new UserProfile({
    name: 'Alice Johnson',
    email: 'alice@example.com',
    avatar: 'https://example.com/avatar.jpg'
});

originalProfile
    .addFriend({ name: 'Bob', id: 'bob123' })
    .addFriend({ name: 'Charlie', id: 'charlie456' })
    .setPreference('theme', 'dark')
    .addMetadata('department', 'Engineering')
    .addTag('frontend')
    .addTag('react');

console.log('Original profile:', originalProfile.toJSON());

// 创建克隆
const clonedProfile = originalProfile.clone(true);
console.log('Cloned profile ID:', clonedProfile.id);
console.log('Same friends array:', originalProfile.friends === clonedProfile.friends); // false

// 创建定制副本
const customCopy = originalProfile.createCopy({
    newId: true,
    clearFriends: true,
    resetPreferences: false
});

console.log('Custom copy friends:', customCopy.friends.length); // 0
console.log('Custom copy theme:', customCopy.preferences.theme); // 'dark'

// 性能测试
console.log('=== 性能测试 ===');
const largeObject = {
    data: Array.from({ length: 1000 }, (_, i) => ({
        id: i,
        name: `Item ${i}`,
        values: Array.from({ length: 10 }, (_, j) => j * i)
    }))
};

console.time('Deep Clone Large Object');
const largeClone = cloner.deepClone(largeObject);
console.timeEnd('Deep Clone Large Object');

console.time('JSON Clone Large Object');
const jsonClone = cloner.jsonClone(largeObject);
console.timeEnd('JSON Clone Large Object');

console.log('Performance report:', cloner.getPerformanceReport());

对象克隆的核心技术

• 浅拷贝：只复制对象的第一层属性，嵌套对象仍然共享引用
• 深拷贝：递归复制所有层级的属性，创建完全独立的对象
• 结构化克隆：使用浏览器原生API，支持更多数据类型
• 智能克隆：根据对象特征自动选择最佳克隆策略

深拷贝 vs 浅拷贝：选择合适的克隆策略

什么时候使用深拷贝？什么时候使用浅拷贝？

深拷贝和浅拷贝的选择取决于具体的使用场景和性能要求：

// 🎉 克隆策略选择器

class CloneStrategySelector {
    constructor() {
        this.strategies = new Map();
        this.setupDefaultStrategies();
    }
    
    setupDefaultStrategies() {
        // 浅拷贝策略
        this.strategies.set('shallow', {
            name: 'Shallow Clone',
            description: 'Copy only first level properties',
            suitable: (obj, context) => {
                return context.performance === 'high' && 
                       context.independence === 'low' &&
                       this.getObjectDepth(obj) <= 2;
            },
            clone: (obj) => ({ ...obj })
        });
        
        // 深拷贝策略
        this.strategies.set('deep', {
            name: 'Deep Clone',
            description: 'Recursively copy all properties',
            suitable: (obj, context) => {
                return context.independence === 'high' ||
                       this.hasNestedObjects(obj);
            },
            clone: (obj) => this.deepClone(obj)
        });
        
        // JSON策略
        this.strategies.set('json', {
            name: 'JSON Clone',
            description: 'Fast clone using JSON serialization',
            suitable: (obj, context) => {
                return context.performance === 'high' &&
                       this.isJSONSerializable(obj);
            },
            clone: (obj) => JSON.parse(JSON.stringify(obj))
        });
        
        // 结构化克隆策略
        this.strategies.set('structured', {
            name: 'Structured Clone',
            description: 'Browser native structured cloning',
            suitable: (obj, context) => {
                return typeof structuredClone !== 'undefined' &&
                       this.hasComplexTypes(obj);
            },
            clone: (obj) => structuredClone(obj)
        });
    }
    
    // 选择最佳克隆策略
    selectStrategy(obj, context = {}) {
        const defaultContext = {
            performance: 'medium', // 'high', 'medium', 'low'
            independence: 'medium', // 'high', 'medium', 'low'
            preserveTypes: true,
            handleCircular: true
        };
        
        const finalContext = { ...defaultContext, ...context };
        
        // 评估所有策略
        const suitableStrategies = [];
        
        for (const [name, strategy] of this.strategies) {
            if (strategy.suitable(obj, finalContext)) {
                suitableStrategies.push({
                    name,
                    strategy,
                    score: this.calculateScore(obj, strategy, finalContext)
                });
            }
        }
        
        // 按分数排序，选择最佳策略
        suitableStrategies.sort((a, b) => b.score - a.score);
        
        return suitableStrategies.length > 0 ? 
               suitableStrategies[0] : 
               { name: 'deep', strategy: this.strategies.get('deep'), score: 0 };
    }
    
    // 计算策略分数
    calculateScore(obj, strategy, context) {
        let score = 0;
        
        // 性能权重
        if (context.performance === 'high' && strategy.name === 'json') {
            score += 30;
        } else if (context.performance === 'high' && strategy.name === 'shallow') {
            score += 25;
        }
        
        // 独立性权重
        if (context.independence === 'high' && strategy.name === 'deep') {
            score += 25;
        }
        
        // 类型保持权重
        if (context.preserveTypes && strategy.name === 'structured') {
            score += 20;
        }
        
        // 对象复杂度权重
        const complexity = this.analyzeObjectComplexity(obj);
        if (complexity.isSimple && strategy.name === 'json') {
            score += 15;
        } else if (complexity.isComplex && strategy.name === 'deep') {
            score += 15;
        }
        
        return score;
    }
    
    // 分析对象复杂度
    analyzeObjectComplexity(obj) {
        return {
            depth: this.getObjectDepth(obj),
            hasNestedObjects: this.hasNestedObjects(obj),
            hasComplexTypes: this.hasComplexTypes(obj),
            isJSONSerializable: this.isJSONSerializable(obj),
            isSimple: this.getObjectDepth(obj) <= 2 && this.isJSONSerializable(obj),
            isComplex: this.getObjectDepth(obj) > 3 || this.hasComplexTypes(obj)
        };
    }
    
    // 获取对象深度
    getObjectDepth(obj, visited = new WeakSet()) {
        if (obj === null || typeof obj !== 'object' || visited.has(obj)) {
            return 0;
        }
        
        visited.add(obj);
        let maxDepth = 0;
        
        for (const key in obj) {
            if (obj.hasOwnProperty(key)) {
                const depth = this.getObjectDepth(obj[key], visited);
                maxDepth = Math.max(maxDepth, depth);
            }
        }
        
        visited.delete(obj);
        return maxDepth + 1;
    }
    
    // 检查是否有嵌套对象
    hasNestedObjects(obj) {
        if (typeof obj !== 'object' || obj === null) {
            return false;
        }
        
        for (const key in obj) {
            if (obj.hasOwnProperty(key) && typeof obj[key] === 'object' && obj[key] !== null) {
                return true;
            }
        }
        
        return false;
    }
    
    // 检查是否有复杂类型
    hasComplexTypes(obj) {
        if (typeof obj !== 'object' || obj === null) {
            return false;
        }
        
        if (obj instanceof Date || obj instanceof RegExp || 
            obj instanceof Map || obj instanceof Set ||
            obj instanceof ArrayBuffer) {
            return true;
        }
        
        for (const key in obj) {
            if (obj.hasOwnProperty(key) && this.hasComplexTypes(obj[key])) {
                return true;
            }
        }
        
        return false;
    }
    
    // 检查是否可JSON序列化
    isJSONSerializable(obj) {
        try {
            JSON.stringify(obj);
            return true;
        } catch {
            return false;
        }
    }
    
    // 深拷贝实现
    deepClone(obj, cache = new WeakMap()) {
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        
        if (cache.has(obj)) {
            return cache.get(obj);
        }
        
        let cloned;
        
        if (obj instanceof Date) {
            cloned = new Date(obj.getTime());
        } else if (obj instanceof RegExp) {
            cloned = new RegExp(obj.source, obj.flags);
        } else if (obj instanceof Array) {
            cloned = [];
            cache.set(obj, cloned);
            for (let i = 0; i < obj.length; i++) {
                cloned[i] = this.deepClone(obj[i], cache);
            }
        } else {
            cloned = {};
            cache.set(obj, cloned);
            for (const key in obj) {
                if (obj.hasOwnProperty(key)) {
                    cloned[key] = this.deepClone(obj[key], cache);
                }
            }
        }
        
        return cloned;
    }
    
    // 执行克隆
    clone(obj, context) {
        const { strategy } = this.selectStrategy(obj, context);
        return strategy.clone(obj);
    }
    
    // 获取策略建议
    getRecommendation(obj, context) {
        const selected = this.selectStrategy(obj, context);
        const complexity = this.analyzeObjectComplexity(obj);
        
        return {
            recommended: selected.name,
            strategy: selected.strategy.name,
            description: selected.strategy.description,
            score: selected.score,
            complexity,
            alternatives: this.getAlternatives(obj, context)
        };
    }
    
    getAlternatives(obj, context) {
        const alternatives = [];
        
        for (const [name, strategy] of this.strategies) {
            if (strategy.suitable(obj, context)) {
                alternatives.push({
                    name,
                    description: strategy.description,
                    score: this.calculateScore(obj, strategy, context)
                });
            }
        }
        
        return alternatives.sort((a, b) => b.score - a.score);
    }
}

// 原型注册表
class PrototypeRegistry {
    constructor() {
        this.prototypes = new Map();
        this.cloneSelector = new CloneStrategySelector();
    }
    
    // 注册原型
    register(name, prototype) {
        this.prototypes.set(name, prototype);
        return this;
    }
    
    // 获取原型
    get(name) {
        return this.prototypes.get(name);
    }
    
    // 克隆原型
    clone(name, context) {
        const prototype = this.prototypes.get(name);
        if (!prototype) {
            throw new Error(`Prototype '${name}' not found`);
        }
        
        return this.cloneSelector.clone(prototype, context);
    }
    
    // 批量克隆
    cloneBatch(names, context) {
        const results = {};
        
        names.forEach(name => {
            try {
                results[name] = this.clone(name, context);
            } catch (error) {
                results[name] = { error: error.message };
            }
        });
        
        return results;
    }
    
    // 获取所有原型名称
    getPrototypeNames() {
        return Array.from(this.prototypes.keys());
    }
    
    // 清空注册表
    clear() {
        this.prototypes.clear();
        return this;
    }
}

// 使用示例
console.log('=== 克隆策略选择测试 ===');

const strategySelector = new CloneStrategySelector();

// 测试不同类型的对象
const simpleObj = { name: 'John', age: 30 };
const complexObj = {
    name: 'Complex',
    data: new Map([['key', 'value']]),
    date: new Date(),
    nested: { deep: { very: { deep: 'value' } } }
};

// 获取推荐策略
const simpleRecommendation = strategySelector.getRecommendation(simpleObj, {
    performance: 'high',
    independence: 'medium'
});

console.log('Simple object recommendation:', simpleRecommendation);

const complexRecommendation = strategySelector.getRecommendation(complexObj, {
    performance: 'medium',
    independence: 'high',
    preserveTypes: true
});

console.log('Complex object recommendation:', complexRecommendation);

// 原型注册表测试
console.log('=== 原型注册表测试 ===');

const registry = new PrototypeRegistry();

// 注册原型
registry
    .register('user', {
        name: '',
        email: '',
        preferences: { theme: 'light' },
        created: new Date()
    })
    .register('product', {
        id: '',
        name: '',
        price: 0,
        categories: [],
        metadata: new Map()
    });

// 克隆原型
const userClone = registry.clone('user', {
    performance: 'high',
    independence: 'high'
});

console.log('User clone:', userClone);

// 批量克隆
const batchClones = registry.cloneBatch(['user', 'product'], {
    performance: 'medium'
});

console.log('Batch clones:', batchClones);
console.log('Available prototypes:', registry.getPrototypeNames());

克隆策略选择指南：

• 🎯 浅拷贝适用场景：性能要求高、对象层级简单、不需要完全独立
• 🎯 深拷贝适用场景：需要完全独立的对象、有嵌套结构、状态隔离重要
• 🎯 JSON克隆适用场景：对象可序列化、性能要求高、不包含特殊类型
• 🎯 结构化克隆适用场景：包含复杂类型、需要保持类型信息、浏览器支持

💼 实际应用：在React/Vue等框架中，状态管理经常需要对象克隆；在游戏开发中，角色模板的复制；在表单处理中，默认值的复制等场景都会用到原型模式。

---

📚 JavaScript原型模式学习总结与下一步规划

✅ 本节核心收获回顾

通过本节JavaScript原型模式完整指南的学习，你已经掌握：

1. 原型模式核心概念：深入理解了原型模式的定义、特点和JavaScript原型链机制
2. 对象克隆技术精通：掌握了浅拷贝、深拷贝的实现方法和性能优化
3. 原型链应用实战：学会了利用JavaScript原型链实现继承和对象扩展
4. 克隆策略选择：理解了不同场景下的克隆策略选择和最佳实践
5. 性能优化技巧：掌握了大对象克隆的性能优化和内存管理

🎯 原型模式下一步

1. 结构型模式学习：学习装饰器模式、适配器模式等结构型设计模式
2. 函数式编程结合：探索原型模式与函数式编程的结合应用
3. 框架源码分析：研究React、Vue等框架中的原型模式应用
4. 性能优化深入：学习更高级的对象克隆和内存优化技术

🔗 相关学习资源

• JavaScript原型链深入：《JavaScript高级程序设计》原型链章节
• 设计模式实践：《JavaScript设计模式与开发实践》
• 性能优化指南：《高性能JavaScript》对象操作优化
• 现代JavaScript特性：ES6+中的对象操作新特性

💪 实践建议

1. 性能基准测试：对比不同克隆方法的性能差异
2. 内存使用分析：使用开发者工具分析克隆操作的内存影响
3. 实际项目应用：在项目中识别和应用原型模式的场景
4. 代码重构：重构现有的对象复制代码，应用最佳实践

---

🔍 常见问题FAQ

Q1: 深拷贝和浅拷贝的性能差异有多大？

A: 深拷贝的性能开销通常是浅拷贝的5-10倍，具体取决于对象的复杂度。对于简单对象，差异较小；对于深层嵌套对象，差异显著。建议根据实际需求选择合适的策略。

Q2: 如何处理循环引用的对象克隆？

A: 使用WeakMap或WeakSet来跟踪已访问的对象，避免无限递归。现代浏览器的structuredClone API也能自动处理循环引用。

Q3: JSON.parse(JSON.stringify())有什么限制？

A: 无法处理函数、undefined、Symbol、Date对象会变成字符串、RegExp会变成空对象、循环引用会报错。只适用于纯数据对象的克隆。

Q4: 什么时候应该使用原型模式？

A: 当需要创建大量相似对象、对象创建成本高、需要保持对象状态、或者需要在运行时动态创建对象时，应该考虑使用原型模式。

Q5: 如何在原型模式中处理私有属性？

A: JavaScript的私有属性（#private）无法被克隆，需要提供专门的克隆方法。可以使用Symbol或WeakMap来实现可克隆的私有状态。

---

🛠️ 原型模式工具使用指南

常见问题解决方案

大对象克隆优化

// 问题：大对象克隆性能问题
// 解决：分批克隆和异步处理

class AsyncCloner {
    async cloneLargeObject(obj, batchSize = 1000) {
        const result = {};
        const keys = Object.keys(obj);
        
        for (let i = 0; i < keys.length; i += batchSize) {
            const batch = keys.slice(i, i + batchSize);
            
            await new Promise(resolve => {
                setTimeout(() => {
                    batch.forEach(key => {
                        result[key] = this.deepClone(obj[key]);
                    });
                    resolve();
                }, 0);
            });
        }
        
        return result;
    }
}

类型安全的克隆

// 问题：克隆后类型信息丢失
// 解决：保持原型链和构造函数信息

class TypeSafeCloner {
    clone(obj) {
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        
        // 保持原型链
        const cloned = Object.create(Object.getPrototypeOf(obj));
        
        // 复制所有属性描述符
        const descriptors = Object.getOwnPropertyDescriptors(obj);
        Object.defineProperties(cloned, descriptors);
        
        return cloned;
    }
}

---

"掌握原型模式，让你的JavaScript对象操作更加高效和灵活。每一次正确的克隆选择，都是对性能和内存的优化！"