Question

1）我想构建一组相关的函数，这些函数都封装在一个名为“stuff”的对象中。我希望能够在创建此对象时运行代码，并使其具有私有变量和函数以及公共属性和方法。只会有其中一个对象。

2）同样封装在内容中，我想要用于创建多个附加对象的构造函数。我希望这些对象具有私有和公共项目，并且能够从内容中访问公共和私有项目。我还希望在创建这些对象时运行代码。

我认为我已经完成了所有这些，但我的问题是这种模式是否有意义，是否有任何隐藏的危险或更好的方法。（它似乎有效。） - 谢谢你。

    // encapsulate all of this into an object named stuff
    stuff = new function () {

        // reference to this
        var _this = this;

        // code, private variable, and functions
        var a, b, c;
        function f1() { }

        // public property, method
        this.prop1 = a + f1(b);
        this.meth1 = function (x) { return f1(this.prop1); }

        // public constructor like function
        this.Obj = function() {

            // code, private variable, and functions
            var d, e, f;
            function f2() { return a + d + f1() + _this.prop1 + _this.meth1(); }

            // public properties and methods
            this.prop2 = _this.prop1 + f2(17);
            this.prop3 = f1(this.prop2);
            this.meth2 = function () { return a + f1() + _this.prop1 + this.prop3 };
        }

    };

    // Usage:
    stuff.prop1 = 7;            // accessing stuff
    stuff.meth1(45);

    obj1 = new stuff.Obj();     // creating Obj's
    obj2 = new stuff.Obj();

    obj1.prop2 = obj2.meth2();  // using Obj's

Answer 1

没关系。它基本上是标准显示模块模式的变体。但是，您通常不会使用new function() { ... }，因为它会创建一个不必要的原型并将其插入stuff和Object.prototype之间。由于您不会将该原型用于任何事情，因此这是不必要的。只有中级JavaScript知识，这对许多人来说也很困惑。

更标准的方法是在没有new的情况下使用内联调用的函数。这也意味着您不需要_this变量（如果您愿意，可以使用它）（我已经标记了已更改的各种行）：< / p>

// encapsulate all of this into an object named stuff
var stuff = (function() {
    var stuff = {};      // <=== Could be called _this if you like, but the
                         // same name within and without is reasonable given
                         // it's a singleton anyway

    // code, private variable, and functions
    var a, b, c;

    function f1() {}

    // public property, method
    stuff.prop1 = a + f1(b);
    stuff.meth1 = function(x) {
        return f1(stuff.prop1);
        // **     ^^^^^
    };

    // public constructor like function
    stuff.Obj = function() {

        // code, private variable, and functions
        var d, e, f;

        function f2() {
            return a + d + f1() + stuff.prop1 + stuff.meth1();
            // **                 ^^^^^         ^^^^^
        }

        // public properties and methods
        this.prop2 = stuff.prop1 + f2(17);
        // **        ^^^^^
        this.prop3 = f1(this.prop2);
        this.meth2 = function() {
            return a + f1() + stuff.prop1 + this.prop3
            // **             ^^^^^
        };
    };

    return stuff; // <===
})();

// Usage:
stuff.prop1 = 7; // accessing stuff
stuff.meth1(45);

obj1 = new stuff.Obj(); // creating Obj's
obj2 = new stuff.Obj();

obj1.prop2 = obj2.meth2(); // using Obj's

我还在外部var前添加了stuff以避免The Horror of Implicit Globals。

嵌套类中的JavaScript变量作用域 - 构造函数中的构造函数

1 个答案: