闭包实现延迟加载资源管理器的核心是按需创建+状态缓存，通过闭包保存初始化状态和资源引用，首次调用get()时执行初始化并缓存实例，后续直接返回缓存值，支持同步/异步资源及多配置扩展。

用闭包实现延迟加载的资源管理器，核心是把资源的创建逻辑封装在闭包内，首次访问时才初始化，之后复用已创建的实例。关键在于“按需创建 + 状态缓存”。

用闭包保存初始化状态和资源引用

闭包能捕获外部函数作用域中的变量，适合用来记住资源是否已加载、以及加载后的实例。通常用一个私有变量（如 instance）缓存结果，再返回一个访问函数。

• 初始化逻辑只执行一次，后续调用直接返回缓存值
• 资源（如大型对象、第三方库、DOM 节点）不会在模块加载时就创建，节省内存和初始化开销
• 闭包确保 instance 和 initialized 不被外部篡改

基础实现：单例式延迟加载

以下是一个通用的延迟加载资源管理器模板：

const ResourceManager = (function() {
  let instance = null;
  let initialized = false;

  function init() {
    // 模拟耗时资源创建（如 new HeavyClass(), fetch config, 或 document.getElementById）
    console.log('正在初始化资源...');
    return {
      data: 'loaded-data',
      load: () => console.log('资源已就绪'),
      destroy: () => { console.log('释放资源'); instance = null; initialized = false; }
    };
  }

  return {
    get() {
      if (!initialized) {
        instance = init();
        initialized = true;
      }
      return instance;
    }
  };
})();

使用方式：ResourceManager.get().load() —— 第一次调用触发初始化，之后都返回同一实例。

立即学习“Java免费学习笔记（深入）”；

Alibabacloud Sdk Client Initialization For Java

在 Java 中初始化和管理阿里云 SDK客户端。包括单例模式、线程安全、endpoint 与 region 配置、VPC 终端节点、同步与异步等。

下载

支持异步资源（如动态 import 或 API 请求）

若资源加载是异步的（例如 import() 或 fetch），需用 Promise 缓存，并避免并发重复请求：

• 用 initPromise 缓存 Promise 实例，保证多次 get() 共享同一个异步任务
• 初始化完成后仍缓存最终值，后续同步返回
• 可加简单错误重试或 loading 状态（按需扩展）

const AsyncResourceManager = (function() {
  let instance = null;
  let initPromise = null;

  function loadResource() {
    return import('./HeavyModule.js') // 或 fetch('/api/config')
      .then(module => {
        instance = module.default || module;
        return instance;
      });
  }

  return {
    get() {
      if (instance) return Promise.resolve(instance);
      if (!initPromise) {
        initPromise = loadResource().catch(err => {
          initPromise = null;
          throw err;
        });
      }
      return initPromise;
    }
  };
})();

调用：AsyncResourceManager.get().then(res => res.doSomething())，首次触发加载，后续直接 resolve 已加载的模块。

进阶：带配置与多资源类型支持

可将闭包工厂化，接受配置参数，生成不同行为的管理器：

function createLazyLoader(createFn, options = {}) {
  const { cache = true } = options;
  let instance = null;
  let initPromise = null;

  return {
    get(...args) {
      if (instance && cache) return instance;
      if (initPromise) return initPromise;

      const result = createFn(...args);
      if (result instanceof Promise) {
        initPromise = result.catch(err => {
          initPromise = null;
          throw err;
        });
        return initPromise.then(val => {
          if (cache) instance = val;
          return val;
        });
      }

      if (cache) instance = result;
      return result;
    },
    clear() {
      instance = null;
      initPromise = null;
    }
  };
}

// 使用示例
const apiClient = createLazyLoader(() => fetch('/api').then(r => r.json()));
const chartLib = createLazyLoader(() => import('chart.js'));

这样既保持闭包封装性，又提升复用性和灵活性。