使用Prototype的优点，还是直接在构造函数中定义方法？

Question

使用Prototype的优点，还是直接在构造函数中定义方法？我想知道使用这些方法是否比其他方法有什么好处，我该走哪条路呢？构造方法：var Class = function () {     this.calc = function (a, b) {         return a + b;     };};原型方法：var Class = function () {};Class.prototype.calc = function (a, b) {     return a + b;};我不喜欢这样，使用Prototype，方法定义与类分离，我不知道是否有任何特定的原因，我应该在第一种方法中使用它。此外，使用函数文字来定义“类”比使用函数定义更有好处：var Class = function () {};VSfunction Class () {};谢谢!

Answer 1

通过原型链继承的方法可以对所有实例进行普遍更改，例如：

function Class () {}Class.prototype.calc = function (a, b) {
    return a + b;}// Create 2 instances:var ins1 = new Class(),
    ins2 = new Class();// Test the calc method:console.log(ins1.calc(1,1), ins2.calc(1,1));// -> 2, 2
    // Change the prototype methodClass.prototype.calc = function () {
    var args = Array.prototype.slice.apply(arguments),
        res = 0, c;

    while (c = args.shift())
        res += c;

    return res; }// Test the calc method:console.log(ins1.calc(1,1,1), ins2.calc(1,1,1));// -> 3, 3

注意如何更改应用于两个实例的方法？这是因为ins1和ins2分享同样的calc()功能。为了使用在构造过程中创建的公共方法来完成这个任务，您必须将新方法分配给每个已经创建的实例，这是一个很尴尬的任务。这是因为ins1和ins2会有自己的，单独创造的calc()职能。

在构造函数中创建方法的另一个副作用是性能较差。每次运行构造函数时，都必须创建每个方法。原型链上的方法只创建一次，然后由每个实例“继承”。另一方面，公共方法可以访问“私有”变量，这在继承的方法中是不可能的。

至于你function Class() {}VSvar Class = function () {}问题是，前者在执行前被“吊起”到当前范围的顶部。对于后者，变量声明是悬挂的，而不是赋值。例如：

// Error, fn is called before the function is assigned!fn();var fn = function () { alert("test!"); } 
// Works as expected: the fn2 declaration is hoisted above the callfn2();function fn2() { alert("test!"); }

Answer 2

原型法的优点是效率高。有一个calc()函数对象在所有Class对象(我指的是通过调用Class(构造函数)另一种方法(在构造函数中分配方法)为每个Class对象时，使用更多的内存并占用更多的处理时间。Class构造函数但是，这种方法确实有一个优点：calc()方法可以访问构造函数中的局部变量，您可以利用这些变量：

function Class() {
    var calcCallCount = 0;

    this.calc = function (a, b) {
        ++calcCallCount;
        alert("Calc called " + calcCallCount + " times");
        return a + b;
    };};

关于var Class = function() {...}对决function Class() {...}我通常更喜欢后者，因为它意味着函数有一个名称，这在调试时很有用。另一个不同之处是后一版本(a功能声明)是悬挂的，这意味着它在定义它的范围内的任何地方都可用，而不仅仅是在定义之后。然而，有些人更喜欢使用前者(a函数表达式)到处都是。