构造函数 - 在简单的命名空间中 - Javascript

Question

想在命名空间内定义一个函数构造函数。 到目前为止我定义构造函数的方式是一个没有NS的简单构造函数，并结合了原型继承。

代码看起来像：

 function mySuperObject() {
    var self = this;
    self.p1 = "";
    self.p2 = "jkejie";
    // and others
    }
 mySuperObject.prototype.func1 = function(){...}
 // and others

引入命名空间：

在阅读了很多文章后，我决定以一种非常简单的方式来定义命名空间，也许是最简单的。 基本上它只是定义一个指向对象 - 文字的变量，而内容是对象（上面的代码片段中的“mySuperObject”）。 构造函数如下：mySuperObjectInNS。

对象的代码：

var MYNAMESPACE = {

    //some variable outside the object
    file : "ConstructorInNamespace_obj.js: ",

    //Defining contructor function inside a namespace
    mySuperObjectInNS : function(propOne, propTwo){

        var self = this;
        self.objectName = "mySuperObject";
        self.propertyOne = propOne;
        self.propertyTwo = propTwo;

        self.doSomething = function(){
            console.log(file + " doSomething called - function of object");
        };

        ///many more functions and attributes
    }
}

MYNAMESPACE.mySuperObjectInNS.prototype.specialFunction = function(){
    console.log(file + " specialFunction called - prototypical inheritance defined in file of object, outside of namespace");
};

///many more functions and attributes

在另一个文件中，可以实例化对象，如下所示：

...
var objOne = new MYNAMESPACE.mySuperObjectInNS("param11", "40");
//following line works just fine
objOne.doSomething();
 ....

问题：

• 在我看来，这一切都是关于定义一个Object-Literal，我将遇到麻烦最新的我试图定义该对象的“私有”属性。 它是否正确？
• 那mySuperObjectInNS仍然是一个构造函数吗？ （对我来说，它似乎是别的东西，即使我可以从中实例化对象。
• 这是一个非常糟糕的命名空间方式还是有点好吗？

Answer 1

在我看来，这一切都是关于定义一个Object-Literal，我将遇到麻烦最新的我试图定义该对象的“私有”属性。 它是否正确？

“私有属性”与使用对象进行命名空间无关。 其实，回答这个问题本来的时候，我读到的“私人聚会”，因为这将是相关的。

有许多方法可以在JavaScript中执行私有属性和半私有属性，但它们与如何创建构造函数及其为对象提供的方法有关，而不是如何公开构造函数。 “命名空间”对象是关于如何公开构造函数的。

创建“私有”属性的一种常见模式是定义需要在构造函数中访问它们的方法，并在构造函数中创建“属性”局部变量（因此它们根本不是属性），如下所示：

function SuperObject() {
    var privateInformation;

    this.method = function() {
        // This can access `privateInformation`, which is completely
        // hidden from outside the constructor
    };
}

如果您在“命名空间”模式中或单独执行此操作，则无关紧要。

另一方面，私有函数会影响模式。 我将在下面展示。

提供私有函数的一个相当常见的变体是使用函数来创建对象，这也为您提供了创建私有函数的机会：

var TheNamespace = function() {
    function privateFunction() {
    }

    function SuperObject() {
        var privateInformation;

        this.method = function() {
            // This can access `privateInformation`, which is completely
            // hidden from outside the constructor
        };
    }

    SuperObject.prototype.otherMethod = function() {
        // Can't access `privateInformation`, but has the advantage
        // that the function is shared between instances
    };

    return {
        SuperObject: SuperObject
    };
}();

// usage
var s = new TheNamespace.SuperObject();

那mySuperObjectInNS仍然是一个构造函数吗？ （对我来说，它似乎是别的东西，即使我可以从中实例化对象。

是。 构造函数是期望您使用new任何函数。

这是一个非常糟糕的命名空间方式还是有点好吗？

将对象用作伪命名空间是常见的做法。 您还可以考虑各种异步模块定义 （AMD）技术，这些技术在很大程度上使“命名空间”对象变得非常不必要

---

你的评论：

你定义了一个自调用函数....它返回一个对象？

它不是一个自动调用函数，它是一个内联函数，但是，它是一个返回一个对象的函数。

（如果是这样，我认为缺少了parantheses）

不，我们不需要任何不存在的parens，因为你看到的其他地方的外部parens的唯一原因是告诉解析器word function启动表达而不是声明; 我们在上面不需要它，因为我们已经在赋值的右侧，所以遇到function时没有歧义。

由于您提出这种方式，它是一种更好的定义ns的方法吗？

“更好”是一个主观的术语。 它为您提供了一个范围，您可以在其中定义您询问的私有函数。

而我经常也看到了选项： var = {} | someNSName; var = {} | someNSName; 这是怎么回事？

如果你有几个文件会将东西添加到“命名空间”（这是常见的），那么你经常会在每个文件中看到这一点：

var TheNamespace = TheNamespace || {};

它的作用是声明变量， 如果之前没有声明它，并且如果它还没有， 则为它分配一个空对象。 在第一个加载的文件中，会发生这种情况：

1. 处理var并创建一个新变量TheNamespace ，其值为undefined 。

2. TheNameSpace = TheNameSpace || {} TheNameSpace = TheNameSpace || {}赋值：由于undefined是假的， 奇怪的是强大的|| 运算符导致新的{} ，它被分配给TheNamespace.

加载下一个文件时，会发生以下情况：

1. var是无操作，因为变量已经存在。

2. TheNameSpace = TheNameSpace || {} TheNameSpace = TheNameSpace || {}赋值：由于TheNamespace有一个非null对象引用，它是真实的，而且奇怪的是强大的|| 运算符导致对TheNamespace引用的对象的引用。

也就是说，它完全没有效果。

这是使用的，因此您可以按任何顺序加载文件，或单独加载一个文件。

这是一个例子：

thingy.js ：

var TheNamespace = TheNamespace || {};
TheNamespace.Nifty = function() {
    function privateFunction() {
    }

    function Nifty() {
        var privateInformation;

        this.method = function() {
            // Can access `privateInformation` here
        };
    }

    Nifty.prototype.otherMethod = function() {
        // ...
    };

    return Nifty;
}();

thingy.js ：

var TheNamespace = TheNamespace || {};
TheNamespace.Thingy = function() {
    function privateFunction() {
    }

    function Thingy() {
        var privateInformation;

        this.method = function() {
            // Can access `privateInformation` here
        };
    }

    Thingy.prototype.otherMethod = function() {
        // ...
    };

    return Thingy;
}();

该基本模式有很多变化，特别是如果一个文件可能会向TheNamespace添加多个内容。 这是一个支持这么简洁的做法：

var TheNamespace = function(exports) {
    function privateFunction() {
    }

    function Nifty() {
        var privateInformation;

        this.method = function() {
            // Can access `privateInformation` here
        };
    }

    Nifty.prototype.otherMethod = function() {
        // ...
    };

    exports.Nifty = Nifty;

    function Thingy() {
        var privateInformation;

        this.method = function() {
            // Can access `privateInformation` here
        };
    }

    Thingy.prototype.otherMethod = function() {
        // ...
    };

    exports.Thingy = Thingy;
}(TheNamespace || {});