如何在不访问包含范围内的内容的情况下安全地访问Javascript模块模式中的其他兄弟函数和变量？

JavaScript模块模式中安全访问兄弟函数和变量的方法

在JavaScript模块模式中，要安全地访问其他兄弟函数和变量而不暴露它们到全局范围，有几种常见的方法：

1. 使用IIFE（立即调用函数表达式）模式

const myModule = (function() {
  // 私有变量
  let privateVar = 'I am private';
  
  // 私有函数
  function privateFunction() {
    console.log('Private function called');
  }
  
  // 公有API
  return {
    publicMethod: function() {
      // 可以访问所有私有成员
      console.log(privateVar);
      privateFunction();
    },
    anotherPublicMethod: function() {
      // 也可以访问所有私有成员
      privateFunction();
    }
  };
})();

// 使用
myModule.publicMethod(); // 可以正常工作
// myModule.privateFunction(); // 会报错，无法访问

2. 使用揭示模块模式（Revealing Module Pattern）

const myModule = (function() {
  let privateCounter = 0;
  
  function privateIncrement() {
    privateCounter++;
  }
  
  function privateGetCount() {
    return privateCounter;
  }
  
  // 暴露公有方法
  return {
    increment: privateIncrement,
    getCount: privateGetCount
  };
})();

// 使用
myModule.increment();
console.log(myModule.getCount()); // 1
// myModule.privateCounter // 无法访问

3. 使用ES6模块（现代推荐方式）

// module.js
let privateVar = 'secret';

function privateFunction() {
  console.log('Private function');
}

export function publicFunction() {
  privateFunction();
  console.log(privateVar);
}

// main.js
import { publicFunction } from './module.js';

publicFunction(); // 可以正常工作
// privateFunction(); // 报错，无法访问

4. 使用WeakMap实现真正的私有变量（ES6+）

const MyModule = (function() {
  const privateProps = new WeakMap();
  
  class MyModule {
    constructor() {
      privateProps.set(this, {
        privateVar: 'I am really private',
        privateMethod: () => {
          console.log('Private method called');
        }
      });
    }
    
    publicMethod() {
      const props = privateProps.get(this);
      console.log(props.privateVar);
      props.privateMethod();
    }
  }
  
  return MyModule;
})();

const instance = new MyModule();
instance.publicMethod(); // 可以访问私有成员
// instance.privateVar // 无法访问