Javascript - 在闭包中使用函数构造函数是个坏主意吗？

Question

我想知道在闭包中使用函数构造函数时是否存在任何内存或性能问题？

这是一个粗略的例子，我知道有很多不同的更好的方法来写这个，我只是想提供一个例子，每个构造函数现在都可以访问闭包中的变量(farmer、lastToSpeak 和 animals) .

// usage: myFarm = new Farm(["Cow","Goat"],"Old MacDonald");

function Farm(animalList, farmer){
    var animals = [],
        lastToSpeak = "";

    function Cow(){
        this.speak = function(){
            alert("I'm a Cow and I belong to "+farmer);
        }
        lastToSpeak = "A Cow";
    }
    function Sheep(){
        this.speak = function(){
            alert("I'm a Sheep and I belong to "+farmer);
        }
        lastToSpeak = "A Sheep";
    }
    function Goat(){
        this.speak = function(){
            alert("I'm a Goat and I belong to "+farmer);
        }
        lastToSpeak = "A Goat";
    }

    for(var i = 0; i < animalList.length; i++){
        switch(animalList[i]){
            case "Cow":
                animals.push(new Cow());
                break;
            case "Sheep":
                animals.push(new Sheep());
                break;
            case "Goat":
                animals.push(new Goat());
                break;
        }
    }

    this.allSpeak = function(){
        for(var i = 0; i < animals.length; i++){
            animals[i].speak();
        }
    }
}
myFarm = new Farm(["Cow","Goat"],"Old MacDonald");
myFarm.allSpeak();

我猜在这个例子中它没有什么区别，但是如果牛、绵羊和山羊更大更复杂并且我们正在创建很多农场，那么这种方法会有什么缺点吗？

每次创建农场时，是否都会将一组新的构造函数存储到内存中？

更新

所以我对 Kemal Dağ 所说的以及 Bergi 的评论感到满意。

如果我按照 Bergi 的建议更改代码以使用原型(prototype)并在农场中传递，这似乎是更好的方法吗？

function Farm(animalList, farmer){
    var animals = [],
        lastToSpeak = "";

    this.farmer = farmer;

    for(var i = 0; i < animalList.length; i++){
        switch(animalList[i]){
            case "Cow":
                animals.push(new this.Cow(this));
                break;
            case "Sheep":
                animals.push(new this.Sheep(this));
                break;
            case "Goat":
                animals.push(new this.Goat(this));
                break;
        }
    }

    this.allSpeak = function(){
        for(var i = 0; i < animals.length; i++){
            animals[i].speak();
        }
    }
}
Farm.prototype.Goat = function(farm){
    this.speak = function(){
        alert("I'm a Goat and I belong to "+farm.farmer);
    }
    farm.lastToSpeak = "A Goat";
}
Farm.prototype.Cow = function(farm){
    this.speak = function(){
        alert("I'm a Cow and I belong to "+farm.farmer);
    }
    farm.lastToSpeak = "A Cow";
}
Farm.prototype.Sheep = function(farm){
    this.speak = function(){
        alert("I'm a Sheep and I belong to "+farm.farmer);
    }
    farm.lastToSpeak = "A Sheep";
}

myFarm = new Farm(["Cow","Goat"],"Old MacDonald");
myFarm.allSpeak();

更新

我整理了一个 fiddle ，而不是向问题 here 添加另一个版本.我已经完全分离了我的动物构造函数并将 speakAll() 移动到原型(prototype)中。我想我真的在寻找一种解决方案，它允许我在我的实例之间共享变量，而无需向全局范围添加任何内容。我最终决定将一个对象传递给每个实例而不是构造函数，这意味着我不必在构造函数中将它们公开。谢谢大家。

Answer 1

在 javascript 中，每个函数本身都是一个对象，因此您的问题的答案是肯定的。每次创建 Farm 对象时，您也会创建其所有私有(private)方法，在您的情况下它们是:Cow、Sheep、Goat。

为防止这种情况，请在 Farm 对象的原型(prototype)中创建函数。这可以防止为这些函数重新分配内存，但它们会立即成为公共(public)函数。见:

Farm.prototype.Goat = function(farmer){
        this.speak = function(){
            alert("I'm a Goat and I belong to "+farmer);
        }
        this.lastToSpeak = "A Goat";
}

您必须决定私有(private)函数对您是否重要？那么原型(prototype)方法要好得多。

但是请记住，在 javascript 中使用原型(prototype)有点棘手，所以我不得不修改你的代码的某些方面，你可以看到一个工作示例 here.

在该示例中，您会发现 this.lastToSpeak 分配从根本上是错误的。由于您正在使用在 Farm 对象的原型(prototype)中创建的函数作为对象构造函数本身。然后 this 成为对 Goat 对象而不是 Farm 对象的引用，因此如果你想引用父 Farm 对象，你可能会将对父对象的引用传递给 Goat 构造函数。请记住，原型(prototype)继承与标准类继承完全不同，但您几乎可以模拟您想要的任何行为。