为什么我要设置Manager.prototype？(Why do I set Manager.prototype?)

 我看到有人在JavaScript中使用“Java”。 :) 
 
 关于JavaScript你应该了解的几件事： 
 
 
 
 在JavaScript中，数组不像其他语言那样工作。 它们更像是字典，然后用C或Java称为数组; 它们没有更高的内存效率或更快; 没有预先分配; 在低级实现中没有任何缺陷等。 JavaScript数组只是一个方便（但有用！）的结构，用于保存命令命令数据。 
 
 
 可以使用new Array(length)表达式或简单的文字表达式[]创建new Array(length) 。 通常，您需要使用数组文字[] 。 
 
 
 使用new Array(length)并没有真正做任何有用的事情; 它设置了数组的初始length属性，但基本上就是这样。 所有元素都undefined 。 没有其他约束或边界检查。 你可以在通过调用var a = new Array(5)创建的数组上执行a[100] = 'whatever' ，并且解释器不会瞄准。 
 
 
 JavaScript使用原型继承，这与C ++和Java等语言中使用的经典继承模型有很大不同。 
 
 
 考虑到这些要点，让我们检查以下代码块： 
 
function SongDatabase() {
    this.songs = new Array();
    this.loadSongs = function () {
        // etc.
    };

    this.saveSongs = function () {
        // etc.
    };

    var _Constructor_ = function () {
        var mySong = new Song();
        this.songs = new Array(mySong);
    };
    _Constructor_();
}
 
 这段代码可能没有按照您的想法进行。 
 
 
 
 通过初始化SongDatabase()函数内的SongDatabase方法，您可以为songDatabase每个实例创建新的方法函数。 当你处理几十个实例时，这可能不是什么大问题，但是如果你要处理数百个实例，那么所需的额外内存可能会成为一个问题。 你想在这里使用prototype模式（见下文）。 
 
 
 你的_Constructor_函数没有做任何事情。 var mySong = new Song()在_Constructor_函数的本地创建一个新的mySong对象，并且不能在其外部访问 。 当_Constructor_调用返回时，它的mySong变量被垃圾收集（就像任何其他局部变量一样）。 
 
 
 _Constructor_是一个私有函数，而不是一个方法 ; 我不完全确定在这种情况下会引用什么。 您最终可能会在全局对象上创建一个歌曲属性（但我想测试它是否确定）。 
 
 
 正如我之前提到的，当您使用new运算符调用Array()时，它会使用一个可选参数来设置数组的初始length 。 在这种情况下，解释器会尝试将mySong强制转换为数字（ mySong 不会添加到数组中！）; 当失败时，它将返回一个length = 0的新数组。 
 
 
 相反，你SongDatabase()好像这样编写SongDatabase() ： 
 
function SongDatabase() {
    this.songs = [];
    // etc.
}

SongDatabase.prototype.loadSongs = function () {
    // load songs into `this.songs`
};

SongDatabase.prototype.saveSongs = function () {
    // save songs loaded into `this.songs`
};
 
 原型模式可能看起来很奇怪，但它可能是处理用例的最佳方式。 您仍然可以直接访问那些songs数组（可能重要也可能不重要），通过将loadSongs和saveSongs函数附加到SongDatabase的原型，您可以确保共享这些函数。 

I see someone's taking the "Java" in JavaScript too literally. :)
 
A couple things you should know about JavaScript:
 
 
 
In JavaScript, arrays don't work like they do in other languages. They're a lot more like dictionaries then what you would call an array in C or Java; they're not significantly more memory efficient, or faster; no preallocation is done; there's no offeset, etc, in the low-level implementation. JavaScript arrays are little more than a convenient (but useful!) structure for holding order-imperative data.
 
 
Arrays can be created using the new Array(length) expression, or the simple literal expression, []. Generally, you'll want to use the array literal, [].
 
 
Using new Array(length) doesn't really do anything useful; it sets the initial length property of the array, but that's basically it. All elements remain undefined. There are no additional constraints or bounds checking. You can do a[100] = 'whatever' on an array created by calling var a = new Array(5) and the interpreter won't bat an eye.
 
 
JavaScript uses prototypal inheritance which is significantly different then the classical inheritance model used in languages like C++ and Java.
 
 
With these points in mind, lets examine the following code block:
 
function SongDatabase() {
    this.songs = new Array();
    this.loadSongs = function () {
        // etc.
    };

    this.saveSongs = function () {
        // etc.
    };

    var _Constructor_ = function () {
        var mySong = new Song();
        this.songs = new Array(mySong);
    };
    _Constructor_();
}
 
This block of code is probably not doing what you think it's doing.
 
 
 
By initializing the SongDatabase methods inside the SongDatabase() function you're creating new method functions for every instance of songDatabase. This may not be a big deal when you're dealing with a couple of dozen of instances, but if you're dealing with hundreds, the extra memory required can become a problem. You'll want to use the prototype pattern here, instead (see below).
 
 
Your _Constructor_ function isn't doing anything. var mySong = new Song() creates a new mySong object local to the _Constructor_ function and not accessible outside of it. When the _Constructor_ invocation returns, it's mySong variable is garbage collected (like any other local variable would be).
 
 
_Constructor_ is a private function and not a method; I'm not entirely sure what this in that context will reference. You may end up creating a songs property on the global object (but I'd want to test that to be sure).
 
 
As I mentioned earlier, when you call Array() with the new operator, it takes an optional argument that sets the initial length of the array. In this case, the interpreter will try to coerce mySong into a number (mySong is not added to the array!); when that fails it will simply return a new array with length = 0.
 
 
Instead, you're better off writing SongDatabase() like so:
 
function SongDatabase() {
    this.songs = [];
    // etc.
}

SongDatabase.prototype.loadSongs = function () {
    // load songs into `this.songs`
};

SongDatabase.prototype.saveSongs = function () {
    // save songs loaded into `this.songs`
};
 
The prototypal pattern may look strange, but its probably the best way to handle your use case. You'll still have direct access to then songs array (which may or may not be important), and by attaching the loadSongs and saveSongs functions to SongDatabase's prototype you ensure that those functions are shared.