在选择使用这四种模式之一而不是其他模式时，引擎盖下是否有任何重要/微妙/显着差异？并且，当通过 Object.create()“实例化”时，它们之间有什么区别吗？对比 new运算符(operator)？

1) CoffeeScript 的模式在翻译“类”定义时使用:

Animal = (function() {

  function Animal(name) {
    this.name = name;
  }

  Animal.prototype.move = function(meters) {
    return alert(this.name + (" moved " + meters + "m."));
  };

  return Animal;

})();

var DifferentAnimal = function(name){

    var self = this;

    self.name = name;

    self.move = function(meters){
        return alert(this.name + (" moved " + meters + "m."));
    };

}

var DifferentAnimalWithClosure = function(name){

    var name = name;

    var move = function(meters){

    };

    return {name:name, move:move};

}

var OneMoreAnimal= ClassThatAlreadyExists.extend({

    name:'',
    move:function(){}

});

最佳答案

需要明确的是:JS 不知道类，只知道对象和自定义的、自定义的构造函数，但这不是重点。
简而言之，回答您的问题:是的，您在此处发布的创建新对象的各种方法之间存在一些小的甚至一些相当大的差异。

咖啡脚本:
这实际上是创建自己的构造函数的最清晰和传统的方法，但它已经“优化”了，因为它已经准备好使用(可选)闭包变量。
基本上，这段代码的作用是使用 IIFE，将构造函数定义和 proptotype 方法赋值包装在它们自己的私有(private)范围内，返回对新构造函数的引用。它只是干净、简单的 JS，与您自己编写的内容没有什么不同。

昏死:
现在这让我有点困惑，因为至少对我来说，你提供的代码片段看起来像是模块模式的一部分，或者是一个强大的构造函数。但是由于您没有使用 strict mode ，省略 new仍然会导致危险的情况，因为整个函数都会遇到创建 DifferentAnimal 的新实例的麻烦。 ，然后构造第二个对象字面量，分配 DifferentAnimal 的所有属性对于那个次要对象，我会说你错过了一些东西。因为，说实话，省略了最后一个 return {};在这里声明，可能根本没有区别。另外:正如您所看到的，您在本质上是一个构造函数中声明了一个方法( move )。这意味着每个实例都将被分配自己的函数对象 move ，而不是从原型(prototype)中获取它。
简而言之:再仔细看看你从哪里得到这个片段，并仔细检查这是否是完整版本，因为如果是，我只能看到反对这一点的论据。

使用在构造函数中定义的变量很简单:一个闭包，假设你的属性有一个不同的初始状态，由一些参数决定，传递给该构造函数:

function MyConstructor(param)
{
     var paramInit = param/2;//or something
     this.p = paramInit;//this property can change later on, so:
     this.reInit = function()
     {//this method HAS to be inside constructor, every instance needs its own method
         this.p = paramInit;//var paramInit can't, it's local to this scope
     };
}
var foo = new MyConstructor(10);
console.log(foo.p);//5
foo.p = 'hi';
console.log(foo.p);//hi
foo.reInit();
console.log(foo.p);//5
console.log(foo.paramInit);//undefined, not available outside object: it's a pseudo-private property

function Animal(name)
{
    this.name = name;
}
Animal.prototype.eat= function()
{
    console.log(this.name + ' is eating');
};

var Animal = Object.extend({name:'',eat:function()
{
    console.log(this.name + ' is eating');
}});

//fictional example, old:
var createSomething = (function()
{
    var internalMethod = function()
    {//method for new object
        console.log(this.myProperty || '');
    };
    return function(basedOn)
    {
        var prop, returnVal= {};
        returnVal.myProperty = new Date();
        returnVal.getCreated = internalMethod;//<--shared by all instances, thx to closure
        if (!basedOn || !(basedOn instanceof Object))
        {//no argument, or argument is not an object:
            return returnVal;
        }
        for (prop in basedOn)
        {//extend instance, passed as argument
            if (basedOn.hasOwnProperty(prop) && prop !== '_extends')
            {
                returnVal[prop] = basedOn[prop];
            }
        }
        returnVal._extends = basedOn;//<-- ref as sort-of-prototype
        return returnVal;
    };
}());

var createSomething = Object.create(someObject, {getCreated:function()
{
    console.log(this.myProperty);
},
myProperty:new Date()});

关于javascript - JavaScript 中 "class"定义的这三种模式有什么区别？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13789559/