如何在Javascript模块模式中使用私有函数/变量？

Question

I'm reading this article about the Javascript Module Pattern and came across a snippet which claims you can preserve private variables/functions across module files and access them from each other:

var MODULE = (function (my) {
    var _private = my._private = my._private || {},
        _seal = my._seal = my._seal || function () {
            delete my._private;
            delete my._seal;
            delete my._unseal;
        },
        _unseal = my._unseal = my._unseal || function () {
            my._private = _private;
            my._seal = _seal;
            my._unseal = _unseal;
        };

        // permanent access to _private, _seal, and _unseal

    return my;
}(MODULE || {}));

I'm a little confused as to how I go about implementing this, but I think most of that confusion is from not understanding quite how this works; how does it enable other scripts already loaded to utilize those internal values? And how do I add functions and variables within this 'private' space?

My end goal is to provide a sort of 'abstract' function variable that must be overridden in sub-modules, but still needs referenced in the base module's file. Admittedly I haven't played with this much but that's mostly because I'm trying to wrap my head around how the actual implementation works.

I was thinking of something like the following but it doesn't seem to work as it can't access the internal functions:

    // Preserve state of private variables/functions across modules
    var _private = my._private = my._private || {},
        _seal = my._seal = my._seal || function () {
            delete my._private;
            delete my._seal;
            delete my._unseal;
        },
        _unseal = my._unseal = my._unseal || function () {
            my._private = _private;
            my._seal = _seal;
            my._unseal = _unseal;
        };

    my._private._unseal();

    my._private.bindEvents = function () {
        alert("This function should be re-declared in your sub-module.");
    };

    my._private._seal();

Thanks in advance.

Answer 1

My end goal is to provide a sort of 'abstract' function variable that must be overridden in sub-modules, but still needs referenced in the base module's file. Admittedly I haven't played with this much but that's mostly because I'm trying to wrap my head around how the actual implementation works.

First of all, move forward. JavaScript isn't a traditional object-oriented programming language.

In JavaScript, if you want to do something if it's defined , you would do this:

// Look at entire prototype chain for a function
if("doStuff" in obj) {
     obj.doStuff();
}

// Or just check if the own object has the whole function
if(obj.hasOwnProperty("doStuff")) {
     obj.doStuff();
}

As of the thing of private or any visibility on JavaScript, everything you may find around the net is just a trick because currently JavaScript has no access modifiers.

Anyway, your sample adds _seal and _private properties to my which usually is called exports , and defines that adding properties to the object set to these top-level properties are private or sealed by convention. So, yes, it's just a convention: don't access such properties that are part of the object set to _private from outside of the module...

BTW, my two cents here is that you should avoid this and use JavaScript as is and deal with the fact that there're no access modifiers.

In the mean time, ECMA-Script 2015 and above have defined a new way to declare properties on which the property name are unique identifiers known as symbols . If you don't own the symbol, you can't access the whole property:

let sampleSymbol = Symbol("sample symbol");
let sampleSymbol2 = Symbol("sample symbol 2");

var obj = {
    // Defines the property with a symbol during object
    // declaration
    [sampleSymbol]: "hello world"
};

// Defines the property using regular property declaration syntax
// once the object has been already built
obj[sampleSymbol2] = "goodbye!";

Now export this object using module pattern and other modules won't be able to access the whole property in an easy way, which in turn works well to simulate property access private modifier.

The worst part is you can still get a given object symbols using Object.getOwnPropertySymbols function, but symbols aren't part of an iterator like Array.prototype.forEach(...) , for..in , Object.keys(...) , or for..of , so you should go for it.