装饰器模式（Decorator Pattern）：利用高阶函数或 Proxy 动态增强对象功能 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

欢迎来到本次关于“装饰器模式”的专题讲座。今天，我们将深入探讨装饰器模式在现代JavaScript开发中的应用，特别是如何利用高阶函数（Higher-Order Functions, HOFs）和ES6 Proxy这两种强大的语言特性来动态增强对象功能。

装饰器模式是一种结构型设计模式，它允许在不修改原有对象结构的情况下，向对象添加新的行为或责任。这种模式的核心思想是“包装”：一个装饰器将一个对象包裹起来，并在其上添加额外的功能，同时保持原有的接口不变。这种方式提供了一种比继承更灵活的替代方案，因为它可以在运行时动态地组合功能，避免了继承体系的僵化和“类爆炸”的问题。

1. 装饰器模式的本质：功能增强与职责分离

在软件设计中，我们经常面临这样的需求：一个对象需要具备多种可选的功能，或者在特定条件下需要改变其行为。如果采用传统的继承方式，可能会导致以下问题：

类爆炸（Class Explosion）：为每个功能组合创建新的子类，导致类的数量急剧增加，维护困难。
僵硬的继承链：一旦确定了继承关系，就很难在运行时改变对象的行为。
违背单一职责原则：基类可能会因为需要支持多种扩展而变得臃肿，承担了过多的责任。

装饰器模式正是为了解决这些问题而生。它的核心思想可以概括为：

开放/封闭原则（Open/Closed Principle）：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着我们应该在不修改现有代码的基础上添加新功能。
动态组合：功能可以在运行时根据需要动态地添加到对象上，而不是在编译时通过继承固定。
透明性：装饰后的对象与原始对象拥有相同的接口，使用者无需关心是否被装饰。

我们来看一个经典的比喻：咖啡店的咖啡。一杯基础咖啡（Concrete Component）可以加上牛奶（Concrete Decorator）、糖（Concrete Decorator）或其他配料。每加一种配料，咖啡的成本和描述都会改变，但它仍然是“咖啡”。

// 1. 抽象组件 (Component) - 定义了被装饰对象和装饰器共同的接口
class Coffee {
    cost() {
        throw new Error("Abstract method 'cost' must be implemented.");
    }
    description() {
        throw new Error("Abstract method 'description' must be implemented.");
    }
}

// 2. 具体组件 (Concrete Component) - 原始对象
class SimpleCoffee extends Coffee {
    cost() {
        return 5;
    }
    description() {
        return "Simple Coffee";
    }
}

// 3. 抽象装饰器 (Decorator) - 维持一个指向组件对象的引用，并实现组件接口
class CoffeeDecorator extends Coffee {
    constructor(coffee) {
        super();
        this.decoratedCoffee = coffee;
    }

    cost() {
        return this.decoratedCoffee.cost(); // 默认行为是委托给被装饰对象
    }

    description() {
        return this.decoratedCoffee.description(); // 默认行为是委托给被装饰对象
    }
}

// 4. 具体装饰器 (Concrete Decorator) - 向组件添加额外的职责
class MilkDecorator extends CoffeeDecorator {
    constructor(coffee) {
        super(coffee);
    }

    cost() {
        return super.cost() + 2; // 添加牛奶的成本
    }

    description() {
        return super.description() + ", with Milk"; // 添加牛奶的描述
    }
}

class SugarDecorator extends CoffeeDecorator {
    constructor(coffee) {
        super(coffee);
    }

    cost() {
        return super.cost() + 1; // 添加糖的成本
    }

    description() {
        return super.description() + ", with Sugar"; // 添加糖的描述
    }
}

class CaramelDecorator extends CoffeeDecorator {
    constructor(coffee) {
        super(coffee);
    }

    cost() {
        return super.cost() + 3;
    }

    description() {
        return super.description() + ", with Caramel";
    }
}

// 使用示例
let myCoffee = new SimpleCoffee();
console.log(`Cost: ${myCoffee.cost()}, Description: ${myCoffee.description()}`);
// 输出: Cost: 5, Description: Simple Coffee

myCoffee = new MilkDecorator(myCoffee);
console.log(`Cost: ${myCoffee.cost()}, Description: ${myCoffee.description()}`);
// 输出: Cost: 7, Description: Simple Coffee, with Milk

myCoffee = new SugarDecorator(myCoffee);
console.log(`Cost: ${myCoffee.cost()}, Description: ${myCoffee.description()}`);
// 输出: Cost: 8, Description: Simple Coffee, with Milk, with Sugar

myCoffee = new CaramelDecorator(myCoffee);
console.log(`Cost: ${myCoffee.cost()}, Description: ${myCoffee.description()}`);
// 输出: Cost: 11, Description: Simple Coffee, with Milk, with Sugar, with Caramel

// 也可以直接创建一个带牛奶和焦糖的咖啡
let fancyCoffee = new CaramelDecorator(new MilkDecorator(new SimpleCoffee()));
console.log(`Cost: ${fancyCoffee.cost()}, Description: ${fancyCoffee.description()}`);
// 输出: Cost: 10, Description: Simple Coffee, with Milk, with Caramel

上述代码展示了传统面向对象语言中装饰器模式的实现方式。它依赖于类和继承来构建装饰器链。然而，在JavaScript这个多范式语言中，特别是ES6及以后，我们拥有更灵活、更函数式的实现方式。

2. 利用高阶函数（Higher-Order Functions）实现函数装饰器

在JavaScript中，函数是“一等公民”。这意味着函数可以像其他任何值一样被赋值给变量、作为参数传递、或者作为另一个函数的返回值。这种特性为实现函数装饰器提供了天然的土壤，我们称之为高阶函数（HOF）。

高阶函数 是指：

接受一个或多个函数作为参数。
返回一个函数。

当一个高阶函数接受一个函数作为参数并返回一个增强了其功能的新函数时，它就扮演了“函数装饰器”的角色。这种模式在函数式编程中非常常见。

2.1 基础函数装饰器示例：日志记录

假设我们有一个重要的函数，我们希望在每次调用它时都能记录其输入参数和返回值，而无需修改函数本身的逻辑。

/**
 * 日志记录装饰器
 * @param {Function} func 要装饰的函数
 * @returns {Function} 装饰后的函数
 */
function logDecorator(func) {
    return function(...args) {
        console.log(`[LOG] Calling function: ${func.name || 'anonymous'}`);
        console.log(`[LOG] Arguments: ${JSON.stringify(args)}`);
        try {
            const result = func(...args);
            console.log(`[LOG] Function ${func.name || 'anonymous'} returned: ${JSON.stringify(result)}`);
            return result;
        } catch (error) {
            console.error(`[LOG] Function ${func.name || 'anonymous'} threw an error: ${error.message}`);
            throw error; // 重新抛出错误
        }
    };
}

// 原始函数
function add(a, b) {
    return a + b;
}

function multiply(a, b) {
    return a * b;
}

// 装饰函数
const loggedAdd = logDecorator(add);
const loggedMultiply = logDecorator(multiply);

// 调用装饰后的函数
console.log("--- Calling loggedAdd ---");
console.log(`Result: ${loggedAdd(2, 3)}`);
// 预期输出:
// [LOG] Calling function: add
// [LOG] Arguments: [2,3]
// [LOG] Function add returned: 5
// Result: 5

console.log("n--- Calling loggedMultiply ---");
console.log(`Result: ${loggedMultiply(4, 5)}`);
// 预期输出:
// [LOG] Calling function: multiply
// [LOG] Arguments: [4,5]
// [LOG] Function multiply returned: 20
// Result: 20

// 验证错误处理
function divide(a, b) {
    if (b === 0) {
        throw new Error("Cannot divide by zero.");
    }
    return a / b;
}
const loggedDivide = logDecorator(divide);
console.log("n--- Calling loggedDivide with error ---");
try {
    loggedDivide(10, 0);
} catch (e) {
    console.error(`Caught error outside decorator: ${e.message}`);
}
// 预期输出:
// [LOG] Calling function: divide
// [LOG] Arguments: [10,0]
// [LOG] Function divide threw an error: Cannot divide by zero.
// Caught error outside decorator: Cannot divide by zero.

2.2 性能测量装饰器

另一个常见的需求是测量函数执行所需的时间。

/**
 * 性能测量装饰器
 * @param {Function} func 要装饰的函数
 * @returns {Function} 装饰后的函数
 */
function timingDecorator(func) {
    return function(...args) {
        const start = performance.now(); // 记录开始时间
        try {
            const result = func(...args);
            const end = performance.now(); // 记录结束时间
            console.log(`[TIME] Function ${func.name || 'anonymous'} executed in ${end - start} ms.`);
            return result;
        } catch (error) {
            const end = performance.now();
            console.error(`[TIME] Function ${func.name || 'anonymous'} failed after ${end - start} ms with error: ${error.message}`);
            throw error;
        }
    };
}

// 原始函数
function calculateExpensiveResult(n) {
    let sum = 0;
    for (let i = 0; i < n; i++) {
        sum += Math.sqrt(i) * Math.log(i + 1);
    }
    return sum;
}

// 装饰函数
const timedCalculate = timingDecorator(calculateExpensiveResult);

// 调用装饰后的函数
console.log("n--- Calling timedCalculate ---");
console.log(`Result: ${timedCalculate(1000000)}`);
// 预期输出:
// [TIME] Function calculateExpensiveResult executed in X ms.
// Result: Y

2.3 防抖（Debounce）装饰器

防抖是一种优化技术，用于限制函数在一定时间段内被调用的频率。当事件被触发时，函数不会立即执行，而是等待一段时间。如果在等待期间事件再次被触发，则重新开始计时。

/**
 * 防抖装饰器
 * @param {Function} func 要装饰的函数
 * @param {number} delay 延迟时间（毫秒）
 * @returns {Function} 装饰后的函数
 */
function debounce(func, delay) {
    let timeoutId;
    return function(...args) {
        const context = this; // 保存函数执行时的上下文
        clearTimeout(timeoutId); // 清除之前的定时器
        timeoutId = setTimeout(() => {
            func.apply(context, args); // 在延迟后执行原始函数
        }, delay);
    };
}

// 原始函数
function searchInput(query) {
    console.log(`Searching for: ${query}`);
}

// 装饰函数
const debouncedSearch = debounce(searchInput, 500);

// 模拟用户输入
console.log("n--- Calling debouncedSearch ---");
debouncedSearch("apple"); // 0ms
debouncedSearch("app");   // 100ms
debouncedSearch("appl");  // 200ms
debouncedSearch("apple"); // 300ms
// 预期输出: 只有最后一次调用在500ms后执行
// Searching for: apple (在约 800ms 时)

2.4 节流（Throttle）装饰器

节流是另一种优化技术，它确保函数在指定时间间隔内只执行一次。无论事件触发频率多高，函数都会以固定的速率执行。

/**
 * 节流装饰器
 * @param {Function} func 要装饰的函数
 * @param {number} interval 间隔时间（毫秒）
 * @returns {Function} 装饰后的函数
 */
function throttle(func, interval) {
    let timeoutId;
    let lastArgs;
    let lastContext;
    let lastExecutionTime = 0;

    return function(...args) {
        lastArgs = args;
        lastContext = this;
        const now = Date.now();

        if (now - lastExecutionTime > interval) {
            // 如果距离上次执行时间超过间隔，则立即执行
            func.apply(lastContext, lastArgs);
            lastExecutionTime = now;
        } else {
            // 否则，设置一个定时器，在间隔结束后执行
            clearTimeout(timeoutId);
            timeoutId = setTimeout(() => {
                if (Date.now() - lastExecutionTime > interval) {
                    func.apply(lastContext, lastArgs);
                    lastExecutionTime = Date.now();
                }
            }, interval - (now - lastExecutionTime));
        }
    };
}

// 原始函数
function handleScroll(event) {
    console.log(`Scroll event at ${Date.now() % 10000}: ${event}`);
}

// 装饰函数
const throttledScroll = throttle(handleScroll, 1000); // 每秒最多执行一次

// 模拟频繁滚动
console.log("n--- Calling throttledScroll ---");
// 假设这些调用发生在很短的时间内
for (let i = 0; i < 10; i++) {
    setTimeout(() => throttledScroll(`Scroll ${i + 1}`), i * 100);
}
// 预期输出:
// Scroll event at X: Scroll 1 (立即执行)
// Scroll event at Y: Scroll N (在约 1000ms 后执行一次)
// ... (每秒执行一次，直到所有待处理的调用都执行完毕)

2.5 记忆化（Memoization）装饰器

记忆化是一种优化技术，用于缓存函数的计算结果。如果函数在相同的输入下被多次调用，它会直接返回之前缓存的结果，而不是重新计算。

/**
 * 记忆化装饰器
 * @param {Function} func 要装饰的函数
 * @returns {Function} 装饰后的函数
 */
function memoize(func) {
    const cache = new Map(); // 使用Map来存储缓存结果

    return function(...args) {
        const key = JSON.stringify(args); // 将参数序列化为缓存键
        if (cache.has(key)) {
            console.log(`[MEMO] Returning cached result for ${func.name || 'anonymous'}(${key})`);
            return cache.get(key);
        }

        console.log(`[MEMO] Calculating result for ${func.name || 'anonymous'}(${key})`);
        const result = func(...args);
        cache.set(key, result); // 缓存结果
        return result;
    };
}

// 原始函数 (模拟耗时计算)
function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// 装饰函数
const memoizedFibonacci = memoize(fibonacci);

// 调用装饰后的函数
console.log("n--- Calling memoizedFibonacci ---");
console.log(`Fib(5): ${memoizedFibonacci(5)}`);
console.log(`Fib(8): ${memoizedFibonacci(8)}`);
console.log(`Fib(5): ${memoizedFibonacci(5)}`); // 第二次调用，应该从缓存中获取
console.log(`Fib(3): ${memoizedFibonacci(3)}`);
console.log(`Fib(8): ${memoizedFibonacci(8)}`); // 第二次调用，应该从缓存中获取
// 预期输出:
// [MEMO] Calculating result for fibonacci([5])
// ... (一系列递归计算和缓存)
// Fib(5): 5
// [MEMO] Calculating result for fibonacci([8])
// ...
// Fib(8): 21
// [MEMO] Returning cached result for fibonacci([5])
// Fib(5): 5
// [MEMO] Calculating result for fibonacci([3])
// ...
// Fib(3): 2
// [MEMO] Returning cached result for fibonacci([8])
// Fib(8): 21

2.6 HOF装饰器的优势与局限性

优势:

简洁与函数式风格：利用JavaScript函数作为一等公民的特性，实现方式非常简洁，符合函数式编程范式。
高复用性：装饰器本身是纯函数，可以方便地应用于任何兼容的函数。
可组合性：多个HFO装饰器可以像管道一样串联起来，形成更复杂的功能。
无副作用：通常不会修改原始函数，而是返回一个新函数，符合不可变性原则。

局限性:

仅限于函数：HFO装饰器主要用于增强函数的功能。它们不能直接用于装饰对象的属性访问、设置或实例化等行为。
上下文丢失问题：在某些情况下，如果装饰器内部不正确地处理this上下文（例如在返回的匿名函数中使用箭头函数或显式bind/apply/call），可能会导致原始函数的this指向不正确。

3. 利用ES6 Proxy动态增强对象功能

高阶函数在装饰函数方面表现出色，但当我们需要对一个对象的多种操作（如属性访问、属性设置、方法调用、删除属性等）进行拦截和增强时，高阶函数就显得力不从心了。这时，ES6引入的Proxy（代理）对象就成为了理想的解决方案。

Proxy 对象用于创建一个对象的代理，从而允许你拦截并自定义对该对象的各种基本操作（例如属性查找、赋值、枚举、函数调用等）。它提供了一种在不修改目标对象本身的情况下，对其行为进行“元编程”的能力。

一个Proxy对象由两个主要部分组成：

target (目标对象)：被代理的实际对象。
handler (处理程序对象)：一个包含各种“陷阱”（trap）方法的对象，这些方法定义了在对target进行操作时要执行的自定义行为。

3.1 基础Proxy装饰器示例：属性访问日志

我们可以用Proxy来记录每次对对象属性的访问。

/**
 * 属性访问日志装饰器
 * @param {Object} target 要装饰的目标对象
 * @returns {Proxy} 装饰后的代理对象
 */
function createPropertyAccessLogger(target) {
    return new Proxy(target, {
        get(obj, prop, receiver) {
            console.log(`[PROXY-LOG] Accessing property: ${String(prop)}`);
            // 默认行为：返回属性值
            return Reflect.get(obj, prop, receiver);
        },
        set(obj, prop, value, receiver) {
            console.log(`[PROXY-LOG] Setting property: ${String(prop)} to value: ${JSON.stringify(value)}`);
            // 默认行为：设置属性值
            return Reflect.set(obj, prop, value, receiver);
        },
        apply(obj, thisArg, argumentsList) {
            // 如果目标是一个函数，则拦截其调用
            console.log(`[PROXY-LOG] Calling method: ${obj.name || 'anonymous'} with args: ${JSON.stringify(argumentsList)}`);
            return Reflect.apply(obj, thisArg, argumentsList);
        }
    });
}

// 原始对象
const user = {
    name: "Alice",
    age: 30,
    greet() {
        return `Hello, my name is ${this.name}.`;
    }
};

// 装饰对象
const loggedUser = createPropertyAccessLogger(user);

// 访问属性
console.log("n--- Accessing loggedUser properties ---");
console.log(`User name: ${loggedUser.name}`); // 触发 get trap
loggedUser.age = 31; // 触发 set trap
console.log(`User age: ${loggedUser.age}`); // 触发 get trap

// 调用方法
console.log(`Greeting: ${loggedUser.greet()}`); // 触发 get trap (获取 greet 方法)，然后触发 apply trap (调用 greet 方法)

// 添加新属性
loggedUser.city = "New York"; // 触发 set trap
console.log(`User city: ${loggedUser.city}`);

3.2 验证装饰器

Proxy可以用来实现强大的验证逻辑，确保对象属性始终处于有效状态。

/**
 * 验证装饰器
 * @param {Object} target 要装饰的目标对象
 * @param {Object} schema 验证规则
 * @returns {Proxy} 装饰后的代理对象
 */
function createValidator(target, schema) {
    return new Proxy(target, {
        set(obj, prop, value, receiver) {
            if (schema[prop]) {
                const validationRule = schema[prop];
                if (validationRule.type && typeof value !== validationRule.type) {
                    throw new TypeError(`Property "${String(prop)}" must be of type "${validationRule.type}". Received "${typeof value}".`);
                }
                if (validationRule.min !== undefined && value < validationRule.min) {
                    throw new RangeError(`Property "${String(prop)}" must be at least ${validationRule.min}.`);
                }
                if (validationRule.max !== undefined && value > validationRule.max) {
                    throw new RangeError(`Property "${String(prop)}" must be at most ${validationRule.max}.`);
                }
                if (validationRule.validate && !validationRule.validate(value)) {
                    throw new Error(`Validation failed for property "${String(prop)}".`);
                }
            }
            return Reflect.set(obj, prop, value, receiver);
        }
    });
}

// 原始对象
const config = {
    port: 8080,
    timeout: 5000,
    env: "development"
};

// 验证规则
const configSchema = {
    port: { type: 'number', min: 1024, max: 65535 },
    timeout: { type: 'number', min: 1000 },
    env: { type: 'string', validate: (val) => ['development', 'production', 'test'].includes(val) }
};

// 装饰对象
const validatedConfig = createValidator(config, configSchema);

console.log("n--- Testing validatedConfig ---");
try {
    validatedConfig.port = 3000; // 有效
    console.log(`Port updated to: ${validatedConfig.port}`);

    // validatedConfig.port = 80; // 无效，抛出 RangeError
    // console.log(`Port updated to: ${validatedConfig.port}`);

    // validatedConfig.timeout = 500; // 无效，抛出 RangeError
    // console.log(`Timeout updated to: ${validatedConfig.timeout}`);

    validatedConfig.env = "production"; // 有效
    console.log(`Environment updated to: ${validatedConfig.env}`);

    // validatedConfig.env = "staging"; // 无效，抛出 Error
    // console.log(`Environment updated to: ${validatedConfig.env}`);

    validatedConfig.port = "invalid"; // 无效，抛出 TypeError
    console.log(`Port updated to: ${validatedConfig.port}`);

} catch (e) {
    console.error(`Validation Error: ${e.message}`);
}

3.3 访问控制/权限管理装饰器

Proxy可以用来实现细粒度的访问控制，根据用户角色或其他条件限制对对象属性或方法的访问。

/**
 * 访问控制装饰器
 * @param {Object} target 要装饰的目标对象
 * @param {Object} permissions 权限映射 { propertyName: ['role1', 'role2'] }
 * @param {string} currentUserRole 当前用户角色
 * @returns {Proxy} 装饰后的代理对象
 */
function createAccessController(target, permissions, currentUserRole) {
    return new Proxy(target, {
        get(obj, prop, receiver) {
            if (permissions[prop] && !permissions[prop].includes(currentUserRole)) {
                throw new Error(`Access Denied: User "${currentUserRole}" cannot read property "${String(prop)}".`);
            }
            return Reflect.get(obj, prop, receiver);
        },
        set(obj, prop, value, receiver) {
            // 假设写入权限和读取权限一致，或者可以定义独立的写入权限
            if (permissions[prop] && !permissions[prop].includes(currentUserRole)) {
                throw new Error(`Access Denied: User "${currentUserRole}" cannot write property "${String(prop)}".`);
            }
            return Reflect.set(obj, prop, value, receiver);
        },
        deleteProperty(obj, prop) {
            if (permissions[prop] && !permissions[prop].includes(currentUserRole)) {
                throw new Error(`Access Denied: User "${currentUserRole}" cannot delete property "${String(prop)}".`);
            }
            return Reflect.deleteProperty(obj, prop);
        }
    });
}

// 原始对象
const secretData = {
    personalInfo: "SSN: XXX-XX-XXXX",
    salary: 100000,
    department: "Engineering",
    projectName: "Project Alpha"
};

// 权限规则
const dataPermissions = {
    personalInfo: ['admin'],
    salary: ['admin', 'manager'],
    department: ['admin', 'manager', 'employee'],
    projectName: ['admin', 'manager', 'employee']
};

console.log("n--- Testing Access Control ---");

// 以普通员工身份访问
try {
    const employeeData = createAccessController(secretData, dataPermissions, 'employee');
    console.log(`Employee can see department: ${employeeData.department}`);
    console.log(`Employee can see project name: ${employeeData.projectName}`);
    // console.log(`Employee tries to see salary: ${employeeData.salary}`); // 抛出错误
} catch (e) {
    console.error(`Employee Access Error: ${e.message}`);
}

// 以经理身份访问
try {
    const managerData = createAccessController(secretData, dataPermissions, 'manager');
    console.log(`Manager can see department: ${managerData.department}`);
    console.log(`Manager can see salary: ${managerData.salary}`);
    // managerData.salary = 120000; // 假设允许经理修改工资
    // console.log(`Manager updated salary to: ${managerData.salary}`);
    // console.log(`Manager tries to see personal info: ${managerData.personalInfo}`); // 抛出错误
} catch (e) {
    console.error(`Manager Access Error: ${e.message}`);
}

// 以管理员身份访问
try {
    const adminData = createAccessController(secretData, dataPermissions, 'admin');
    console.log(`Admin can see personal info: ${adminData.personalInfo}`);
    console.log(`Admin can see salary: ${adminData.salary}`);
    adminData.salary = 150000;
    console.log(`Admin updated salary to: ${adminData.salary}`);
    delete adminData.personalInfo; // 假设允许管理员删除
    console.log("Admin deleted personalInfo.");
    console.log(`Admin tries to see personal info after deletion: ${adminData.personalInfo}`); // undefined
} catch (e) {
    console.error(`Admin Access Error: ${e.message}`);
}

3.4 只读（Read-Only）装饰器

Proxy可以轻松地将一个对象转换为只读状态，防止对其属性进行修改或删除。

/**
 * 只读装饰器
 * @param {Object} target 要装饰的目标对象
 * @returns {Proxy} 装饰后的代理对象
 */
function createReadOnlyProxy(target) {
    return new Proxy(target, {
        set(obj, prop, value) {
            throw new Error(`Cannot set property "${String(prop)}": Object is read-only.`);
        },
        deleteProperty(obj, prop) {
            throw new Error(`Cannot delete property "${String(prop)}": Object is read-only.`);
        },
        // 阻止扩展属性
        preventExtensions(obj) {
            return false; // 总是返回false，表示不能阻止扩展
        },
        // 阻止配置属性
        defineProperty(obj, prop, descriptor) {
            throw new Error(`Cannot define property "${String(prop)}": Object is read-only.`);
        }
    });
}

// 原始对象
const immutableSettings = {
    API_KEY: "abc123xyz",
    DEBUG_MODE: false,
    VERSION: "1.0.0"
};

// 装饰对象
const readOnlySettings = createReadOnlyProxy(immutableSettings);

console.log("n--- Testing Read-Only Proxy ---");
console.log(`API Key: ${readOnlySettings.API_KEY}`);
console.log(`Debug Mode: ${readOnlySettings.DEBUG_MODE}`);

try {
    readOnlySettings.DEBUG_MODE = true; // 尝试修改，抛出错误
} catch (e) {
    console.error(`Read-Only Error: ${e.message}`);
}

try {
    readOnlySettings.NEW_PROP = "value"; // 尝试添加新属性，抛出错误
} catch (e) {
    console.error(`Read-Only Error: ${e.message}`);
}

try {
    delete readOnlySettings.VERSION; // 尝试删除属性，抛出错误
} catch (e) {
    console.error(`Read-Only Error: ${e.message}`);
}

3.5 Proxy装饰器的优势与局限性

优势:

全面拦截：Proxy能够拦截几乎所有对目标对象的基本操作，包括属性的读取、设置、删除，方法的调用，迭代，甚至对象自身的反射操作（如Object.keys）。
细粒度控制：可以针对不同的属性或方法定义不同的拦截逻辑。
真正的对象装饰：能够对整个对象进行功能增强，而不仅仅是函数。
元编程能力：提供了一种强大的元编程能力，可以在运行时改变对象的底层行为。

局限性:

性能开销：与直接操作原始对象相比，Proxy会有一定的性能开销。虽然现代JavaScript引擎已经对此进行了优化，但在对性能要求极高的场景中仍需谨慎。
调试复杂性：当一个对象被多层Proxy包裹时，调试起来可能会比较复杂，因为调用栈会变得更深，且真实的错误源可能被隐藏在代理层之后。
this上下文问题：在使用Proxy代理方法时，需要确保this上下文正确地指向原始对象，通常通过Reflect.apply或Function.prototype.apply来处理。
兼容性：ES6 Proxy在旧版浏览器中可能不被支持（尽管现在主流浏览器支持度已很高）。

3.6 HOFs与Proxies的比较

特性	高阶函数 (HOFs)	ES6 Proxy
目标	增强函数的功能	增强对象的各种操作（属性、方法、原型等）
拦截范围	仅限于函数调用	几乎所有对象操作（get, set, apply, delete等）
实现方式	返回一个新函数，在新函数中调用原函数	返回一个代理对象，通过陷阱方法拦截操作
灵活性	在函数层面非常灵活和可组合	在对象层面非常灵活，可以实现细粒度控制
性能	通常开销较小	存在一定开销，但通常可接受
调试	相对直接，调用栈清晰	可能增加调试复杂性，调用栈更深
应用场景	日志、计时、缓存、防抖、节流、权限校验等函数操作	验证、访问控制、ORM、数据绑定、对象虚拟化等
组合方式	函数链式调用 `decorator1(decorator2(func))`	嵌套代理 `new Proxy(new Proxy(target, h1), h2)`

4. 结合 HOFs 和 Proxies：更强大的装饰器模式

在实际开发中，我们可能会遇到需要同时装饰对象的方法和属性的情况。这时，我们可以将高阶函数和Proxy结合起来使用。例如，我们可以创建一个Proxy来拦截对象的方法调用，并在Proxy的apply陷阱中，使用高阶函数来装饰被调用的方法。

// 重新定义一个通用的日志记录装饰器（用于函数）
function methodLogger(func) {
    if (typeof func !== 'function') {
        return func; // 如果不是函数，直接返回，不做处理
    }
    return function(...args) {
        console.log(`[Method-LOG] Calling method: ${func.name || 'anonymous'} with args: ${JSON.stringify(args)}`);
        const result = func.apply(this, args); // 确保正确的this上下文
        console.log(`[Method-LOG] Method ${func.name || 'anonymous'} returned: ${JSON.stringify(result)}`);
        return result;
    };
}

/**
 * 混合装饰器：使用Proxy拦截对象操作，并使用HOF装饰其中的方法
 * @param {Object} target 目标对象
 * @param {Function[]} methodDecorators 应用于方法的HOF装饰器数组
 * @returns {Proxy} 装饰后的代理对象
 */
function createHybridDecorator(target, methodDecorators = []) {
    // 创建一个临时的对象来存储装饰后的方法，避免直接修改原始target
    const decoratedMethods = {};

    for (const key in target) {
        if (typeof target[key] === 'function') {
            let decoratedFunc = target[key];
            for (const decorator of methodDecorators) {
                decoratedFunc = decorator(decoratedFunc);
            }
            decoratedMethods[key] = decoratedFunc;
        }
    }

    return new Proxy(target, {
        get(obj, prop, receiver) {
            // 如果是方法，返回预先装饰好的方法
            if (typeof obj[prop] === 'function' && decoratedMethods[prop]) {
                // 绑定this上下文到原始对象，确保方法内部的this指向正确
                return decoratedMethods[prop].bind(receiver);
            }
            // 否则，执行默认的属性获取行为
            return Reflect.get(obj, prop, receiver);
        },
        set(obj, prop, value, receiver) {
            console.log(`[Hybrid-PROXY] Setting property: ${String(prop)} to value: ${JSON.stringify(value)}`);
            return Reflect.set(obj, prop, value, receiver);
        },
        // 也可以在这里添加其他Proxy陷阱来装饰非方法属性的行为
        // 例如，可以像之前的验证装饰器一样，在这里对属性设置进行验证
    });
}

// 原始对象
const service = {
    data: "initial data",
    process(input) {
        console.log(`Processing input: ${input}`);
        return `Processed: ${input} - ${this.data}`;
    },
    getData() {
        return this.data;
    },
    // 一个非方法属性
    config: { version: 1 }
};

// 使用混合装饰器，为所有方法添加日志
const decoratedService = createHybridDecorator(service, [methodLogger, timingDecorator]);

console.log("n--- Testing Hybrid Decorator ---");
console.log(`Result from process: ${decoratedService.process("test message")}`);
console.log(`Result from getData: ${decoratedService.getData()}`);

decoratedService.data = "new data"; // 触发Proxy的set陷阱
console.log(`Updated data: ${decoratedService.data}`); // 触发Proxy的get陷阱

decoratedService.config.version = 2; // 注意：这里只会触发对config属性的get，不会拦截config内部属性的修改
console.log(`Config version: ${decoratedService.config.version}`);

这个例子展示了如何通过Proxy的get陷阱来拦截方法的访问，并返回一个已经被高阶函数装饰过的新方法。这样，我们既能利用Proxy对整个对象操作的全面控制，又能利用HOFs对特定函数行为的精细增强。

5. 装饰器在现代 JavaScript 生态中的体现

装饰器模式不仅停留在理论层面，它在现代JavaScript框架和库中有着广泛的应用和各种变体。

TypeScript/Babel 装饰器（Stage 2/3 Proposal）：这是一种语法糖，允许你以 @decoratorName 的形式直接在类、方法、属性或参数上应用装饰器。它们在编译时（通过Babel或TypeScript）被转换为高阶函数或Proxy类似的逻辑。
```
// 假设 @logMethod 和 @measure 是预定义的装饰器
class MyClass {
    @logMethod
    @measure
    myMethod(arg1: string, arg2: number) {
        console.log(`Executing myMethod with ${arg1}, ${arg2}`);
        return arg1 + arg2;
    }
}
```
这种语法糖极大地提升了装饰器模式的可读性和易用性，使得开发者可以声明式地增强类成员的功能。

React 高阶组件 (Higher-Order Components, HOCs)：HOC是React中重用组件逻辑的一种高级技术。它是一个函数，接受一个组件作为参数，并返回一个增强了功能的新组件。这本质上就是函数装饰器模式在React组件层面的应用。

function withLogging(WrappedComponent) {
    return class extends React.Component {
        componentDidMount() {
            console.log(`Component ${WrappedComponent.name} mounted.`);
        }
        render() {
            return <WrappedComponent {...this.props} />;
        }
    };
}

class MyComponent extends React.Component { /* ... */ }
const LoggedMyComponent = withLogging(MyComponent); // 或者使用ES7装饰器语法 @withLogging

Vue Mixins / Composition API：Vue的混入（Mixins）和组合式API（Composition API）也提供了类似装饰器模式的功能，用于在组件之间共享和重用逻辑。虽然不是严格意义上的装饰器，但它们都致力于在不修改原始代码的情况下增强组件功能。

NestJS 装饰器：NestJS 是一个基于TypeScript的Node.js框架，它大量使用了ECMAScript装饰器来实现依赖注入、路由、守卫、管道等核心功能。例如：

@Controller('cats')
export class CatsController {
    constructor(private catsService: CatsService) {}

    @Get()
    findAll(): string {
        return this.catsService.findAll();
    }

    @Post()
    @UseGuards(AuthGuard) // 路由守卫装饰器
    create(@Body() createCatDto: CreateCatDto): string {
        return 'This action adds a new cat';
    }
}

这些装饰器在运行时被NestJS框架解析，并执行相应的逻辑，如注册路由、检查权限等。

6. 最佳实践与注意事项

虽然装饰器模式非常强大，但在使用时也需要注意一些最佳实践和潜在问题：

保持装饰器的单一职责：一个装饰器应该只负责添加一项特定的功能。如果一个装饰器变得过于复杂，它可能包含了多个职责，这会降低其复用性。
链式调用与顺序：多个装饰器可以链式调用。重要的是要理解它们的执行顺序。通常，最内层的装饰器最先执行其增强逻辑，而最外层的装饰器最后执行。
避免过度装饰：过度使用装饰器，特别是多层嵌套的Proxy，可能会使代码难以理解和调试。在选择是否使用装饰器时，要权衡其带来的灵活性和可能增加的复杂性。
this上下文的处理：在使用高阶函数装饰类方法或Proxy拦截方法调用时，务必确保this上下文被正确地保留并传递给原始函数或方法。Function.prototype.apply、Function.prototype.call或Reflect.apply是处理此问题的常用方法。
性能考量：虽然现代JavaScript引擎对Proxy进行了大量优化，但在极端性能敏感的场景下，仍需注意其可能带来的额外开销。对于高频调用的函数，HOF通常比Proxy更轻量。
可测试性：装饰器应该易于测试。通常，你可以独立测试装饰器本身，然后测试被装饰的原始对象，最后测试装饰器与原始对象组合后的行为。
错误处理：装饰器应该能够优雅地处理原始函数或对象操作可能抛出的错误，并决定是重新抛出、捕获处理还是转换错误。
TypeScript/ES 装饰器提案的稳定性：虽然 @ 语法糖在Babel和TypeScript中广泛使用，但它在ECMAScript标准中仍处于提案阶段（Stage 2/3），这意味着其规范可能仍然会发生变化。在生产环境中使用时，应考虑其稳定性。