JS原型方法仅执行一次的三种方法

本文深入探讨了在 JavaScript 中实现原型方法只调用一次的几种策略，并分析了它们的优缺点。首先，介绍了通过闭包封装方法，利用标志位控制执行次数的方式。其次，阐述了使用 `Object.defineProperty` 拦截调用，以及利用 Proxy 实现方法拦截的方法。重点介绍了一种直接且有效的方法：原型方法在首次执行后，将自身替换为一个返回缓存结果或无操作的新函数，从而确保该方法在整个原型链上只执行一次。文章还讨论了这种方法对现有和未来实例的影响，并提供了其他替代策略，如实例级别标志、高阶函数/装饰器模式，以满足不同的应用场景需求，帮助开发者根据实际情况选择最合适的方案。

最直接的方法是让原型方法在首次执行后将自身替换为一个返回缓存结果或无操作的新函数，从而确保该方法在整个原型链上只执行一次；2. 这种方式通过修改原型上的方法引用实现，影响所有实例，后续创建的实例将无法执行原始逻辑，因此适用于全局一次性任务而非实例独立初始化；3. 其他替代策略包括：使用实例级别标志控制单个实例的方法执行次数、利用高阶函数once实现函数级单次执行、或通过Proxy拦截方法调用以实现更灵活的控制。

要在JavaScript中让一个原型方法只能被调用一次，最直接且有效的方法，就是在该方法首次执行完毕后，立即将其自身在原型链上的引用替换为一个无操作（noop）或只返回缓存结果的新函数。这就像给方法设置了一个一次性的通行证，用过即作废，后续的调用会发现通行证已经变了。

解决方案

实现原型方法只能被调用一次，通常我们会利用JavaScript中函数作为“一等公民”的特性，让方法在执行后“自毁”或“自替换”。这是一种巧妙的元编程技巧，它直接修改了原型对象上的方法引用。

核心思路是这样的：当原型方法第一次被调用时，它会执行其预期的逻辑，然后，它会负责将 MyClass.prototype.myMethod 这个引用，从指向它自己（原始方法）变为指向一个新的、简化的函数。这个新的函数可以什么都不做，或者返回第一次执行时缓存的结果。

function ResourceLoader() {
    this.loadedData = null; // 用于缓存首次加载的数据
}

// 假设这是一个耗时且只需要执行一次的资源加载方法
ResourceLoader.prototype.loadResource = function() {
    console.log("首次加载资源中...");
    // 模拟异步或耗时操作
    const data = {
        timestamp: new Date().toISOString(),
        content: "这是从服务器获取的宝贵数据。"
    };
    this.loadedData = data; // 缓存数据到实例上

    // 关键一步：在首次执行后，将原型上的 loadResource 方法替换掉
    // 这样，无论是当前实例还是未来创建的新实例，再次调用 loadResource 时，
    // 都会执行这个被替换后的函数，而不是原始的加载逻辑。
    ResourceLoader.prototype.loadResource = function() {
        console.log("loadResource 方法已被替换，直接返回缓存数据。");
        // 注意：这里返回的是调用该方法的实例的 this.loadedData
        // 如果原始方法是设置全局状态，这里可能直接返回那个全局状态
        return this.loadedData;
    };

    return data;
};

// 实际使用示例：
const loader1 = new ResourceLoader();
console.log("--- 第一次调用 loader1.loadResource ---");
const data1 = loader1.loadResource(); // 第一次调用，执行加载逻辑并替换方法
console.log("加载到的数据:", data1.content);

console.log("\n--- 再次调用 loader1.loadResource ---");
const data1_again = loader1.loadResource(); // 第二次调用，执行的是被替换后的方法
console.log("再次获取的数据:", data1_again.content);

console.log("\n--- 创建新实例 loader2 并调用 ---");
const loader2 = new ResourceLoader(); // 创建一个新实例
const data2 = loader2.loadResource(); // 新实例调用，但原型方法已被替换，所以不会执行原始加载逻辑
console.log("新实例获取的数据:", data2 ? data2.content : "无数据（因为原始逻辑未执行）");
// 注意：此时 loader2.loadedData 仍为 null，因为原始的赋值逻辑没有在 loader2 上执行。
// 这引出了一个重要的思考：这种替换会影响所有实例，需要注意数据作用域。

这种方法非常直接，它修改了原型链上的共享引用，所以其影响是全局性的，会作用于所有当前及未来通过该原型创建的实例。

这种“一次性”调用对现有和未来实例有何影响？

在我看来，这是一个非常关键的问题，因为原型方法的动态替换并非没有副作用。当一个原型方法被首次调用并随后替换自身时，其影响会立即扩散到所有使用该原型的对象。

具体来说：

1. 对已存在的实例的影响： 如果一个实例（比如 loader1）在原型方法被替换前就已经存在，并且它通过 loader1.loadResource() 这样的方式调用方法，那么第一次调用会触发替换。从第二次调用开始，loader1.loadResource() 将会指向被替换后的新函数。 然而，如果你的代码提前缓存了对原始方法的引用，例如 const originalFunc = loader1.loadResource; 那么 originalFunc() 仍然会调用原始方法，因为它持有的是一个直接的函数引用，而非通过原型链查找。但在绝大多数正常的使用场景中，我们都是通过 instance.method() 来调用，所以这种影响是可控的。

2. 对未来创建的实例的影响： 这是最需要注意的地方。一旦 ResourceLoader.prototype.loadResource 被替换，所有在替换操作之后创建的 ResourceLoader 实例（例如上面的 loader2），它们在查找 loadResource 方法时，将直接找到并使用那个已经被替换掉的新函数。这意味着，这些新实例将永远不会执行原始的 loadResource 逻辑。

   这带来一个重要的设计考量：如果原始方法的功能是设置实例特有的状态（如 this.loadedData = data），那么后续创建的实例将不会拥有这些状态，因为原始的设置逻辑在它们身上从未运行。这种模式更适合用于执行那些一次性、全局性或与特定实例状态无关的初始化任务，比如连接到单一数据库、加载应用范围的配置、或者执行一个只需计算一次的共享算法。如果每个实例都需要独立的“一次性”初始化，那么这种直接替换原型方法的方式就不太合适了，你需要考虑在实例层面管理状态（如使用一个实例属性作为标志）。

除了原型方法自替换，还有哪些实现“只执行一次”的策略？

虽然原型方法自替换很直接，但在实际开发中，我们还有其他一些同样能实现“只执行一次”效果的策略，它们各有侧重，适用于不同的场景。

1. 实例级别标志 (Instance Flag)： 这是最常见也最直观的方法，尤其当你希望“一次性”的限制是针对每个实例而非整个原型时。你可以在实例上维护一个布尔标志，在方法内部检查这个标志。

   function ServiceProcessor() {
       this._isProcessed = false; // 实例级别的标志
   }
   
   ServiceProcessor.prototype.processData = function() {
       if (this._isProcessed) {
           console.log("processData 已被此实例调用过，不再重复执行。");
           return;
       }
       console.log("首次为此实例处理数据...");
       // 实际的数据处理逻辑
       this._isProcessed = true; // 设置标志，表示已执行
   };
   
   const sp1 = new ServiceProcessor();
   sp1.processData(); // 第一次调用，执行
   sp1.processData(); // 第二次调用，不执行
   
   const sp2 = new ServiceProcessor();
   sp2.processData(); // 新实例，第一次调用，执行

   这种方式的优点是清晰、每个实例独立，缺点是每个实例都需要维护一个额外的标志属性。

2. 高阶函数/装饰器 (Higher-Order Function/Decorator Pattern)： 你可以创建一个通用的函数，它接收一个函数作为参数，并返回一个新的函数。这个新函数会确保原始函数只执行一次。这种模式提供了很好的代码复用性。

   function once(fn) {
       let hasBeenCalled = false;
       let result;
       return function(...args) {
           if (!hasBeenCalled) {
               hasBeenCalled = true;
               // 使用 apply 或 call 确保 this 上下文正确
               result = fn.apply(this, args);
           }
           return result;
       };
   }
   
   // 应用到原型方法
   function Initializer() { /* ... */ }
   
   Initializer.prototype.setupApplication = once(function() {
       console.log("应用初始化中，只执行一次...");
       // 实际的初始化逻辑
       this.isAppReady = true; // 设置实例状态
       return "App Initialized!";
   });
   
   const app1 = new Initializer();
   console.log(app1.setupApplication()); // 执行一次
   console.log(app1.setupApplication()); // 不执行，返回上次结果
   
   const app2 = new Initializer(); // 新实例
   console.log(app2.setupApplication()); // 再次执行一次 (因为 once 函数为每个被装饰的方法创建了独立的闭包)

   once 函数在这里创建了一个闭包，为每个被装饰的 setupApplication 方法实例维护了自己的 hasBeenCalled 状态。这意味着，如果你把 once 应用到原型方法上，每个实例调用这个方法时，它都会独立地执行一次。如果你想让原型方法在整个应用生命周期中只执行一次（不区分实例），那么 once 函数的 hasBeenCalled 状态需要放在一个更全局的作用域，或者使用前面提到的原型方法自替换。

3. 使用 Proxy (代理)： 虽然对于“只执行一次”这种简单需求来说有点重量级，但 Proxy 允许你拦截对象上的操作（包括方法调用）。你可以创建一个代理，在方法被调用时检查并控制其执行次数。这提供了极大的灵

今天关于《JS原型方法仅执行一次的三种方法》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于高阶函数,实例,原型方法,只执行一次,方法自替换的内容请关注golang学习网公众号！