JavaScript Revealing Module Pattern访问权限疑问解答

Hey there! Welcome to your first question here—no worries about any rules, you’re doing great. Let’s break down your questions step by step using the code you shared.

Why can’t we access internal members, but can access the returned object? #

First, let’s talk about the Immediately Invoked Function Expression (IIFE) at the core of your code:

var namesCollection = (function() {
  // ... internal code ...
})();

This function runs the moment it’s defined, and it creates its own private scope. Any variables or functions declared inside this function (like objects, addObject, removeObject) are only accessible inside this function by default. They’re "private" because JavaScript’s scoping rules mean things defined inside a function can’t be seen from outside unless explicitly exposed.

The magic here comes from closures and the returned object:

return {
  addName: addObject,
  removeName: removeObject,
  getNames: getObjects
};

This object gets assigned to namesCollection, which lives in the outer scope (the context where you defined namesCollection). When you call namesCollection.addName("Bob"), you’re actually invoking the private addObject function from inside the IIFE—closures let these returned methods keep access to the private objects array even after the IIFE has finished running.

But since objects or addObject aren’t included in the returned object, there’s no way to reference them directly from outside the IIFE. They’re locked in that private scope, so namesCollection.objects or namesCollection.addObject would both return undefined.

Why is the returned object considered public? #

Public members are those that can be accessed and used from outside the module’s private code. Since the returned object is assigned to namesCollection (a variable in the outer scope), any code that has access to namesCollection can call its methods (addName, removeName, getNames).

Think of it like a black box: you don’t need to know what’s happening inside the IIFE (how objects is managed, how addObject works) to use the public methods. You just interact with the exposed interface—the returned object—and that’s exactly what makes those methods public.

For example, this won’t work outside the IIFE:

console.log(namesCollection.objects); // undefined—can’t access private array
console.log(namesCollection.addObject); // undefined—can’t access private function

But this works perfectly:

namesCollection.addName("Charlie"); // Calls the public method, which uses the private `addObject` function under the hood

The Revealing Module Pattern is all about keeping implementation details hidden while exposing a clean, usable public interface for other code to interact with.

内容的提问来源于stack exchange，提问作者Duncan