我认为问题的重点是理解new和Object之间的区别。创建方法。根据这个答案和这个视频，new关键字做了下面的事情:

创建新对象。 将新对象链接到构造函数(原型)。 使此变量指向新对象。 使用new对象执行构造函数，隐式执行返回this; 将构造函数函数名赋给新对象的属性构造函数。

对象。Create只执行第1和第2步!

在代码示例中提供的问题，这不是什么大问题，但在下一个例子中，它是:

var onlineUsers = [];
function SiteMember(name) {
    this.name = name;
    onlineUsers.push(name);
}
SiteMember.prototype.getName = function() {
    return this.name;
}
function Guest(name) {
    SiteMember.call(this, name);
}
Guest.prototype = new SiteMember();

var g = new Guest('James');
console.log(onlineUsers);

作为副作用的结果将是:

[ undefined, 'James' ]

因为盖斯特。prototype = new SiteMember(); 但是我们不需要执行父构造函数方法，我们只需要使方法getName在Guest中可用。 因此我们必须使用Object.create。 如果替换Guest。prototype = new SiteMember(); 来的客人。prototype = Object.create(sitember .prototype);结果是:

[ 'James' ]

对象。create在一些浏览器上还不是标准的，比如IE8, Opera v11.5, Konq 4.3都没有。你可以使用Douglas Crockford的Object版本。为这些浏览器创建，但这不包括在CMS的回答中使用的第二个“初始化对象”参数。

对于跨浏览器代码，同时进行对象初始化的一种方法是自定义Crockford的object .create。这里有一个方法:-

Object.build = function(o) {
   var initArgs = Array.prototype.slice.call(arguments,1)
   function F() {
      if((typeof o.init === 'function') && initArgs.length) {
         o.init.apply(this,initArgs)
      }
   }
   F.prototype = o
   return new F()
}

这维护了Crockford原型继承，也检查对象中的任何init方法，然后用参数运行它，比如说new man('John'，'Smith')。然后你的代码变成:-

MY_GLOBAL = {i: 1, nextId: function(){return this.i++}}  // For example

var userB = {
    init: function(nameParam) {
        this.id = MY_GLOBAL.nextId();
        this.name = nameParam;
    },
    sayHello: function() {
        console.log('Hello '+ this.name);
    }
};
var bob = Object.build(userB, 'Bob');  // Different from your code
bob.sayHello();

所以bob继承了sayHello方法，现在拥有自己的属性id=1和name=' bob '。当然，这些属性既可写又可枚举。这也是一种比ECMA Object简单得多的初始化方法。创建，特别是当您不关心可写、可枚举和可配置属性时。

对于没有init方法的初始化，可以使用以下Crockford mod

Object.gen = function(o) {
   var makeArgs = arguments 
   function F() {
      var prop, i=1, arg, val
      for(prop in o) {
         if(!o.hasOwnProperty(prop)) continue
         val = o[prop]
         arg = makeArgs[i++]
         if(typeof arg === 'undefined') break
         this[prop] = arg
      }
   }
   F.prototype = o
   return new F()
}

这将使用Object填充userB自己的属性，按照它们定义的顺序。在userB参数之后从左到右生成参数。它使用for(prop in o)循环，因此，根据ECMA标准，属性枚举的顺序不能保证与属性定义的顺序相同。然而，在(4)主要浏览器上测试的几个代码示例显示，如果使用hasOwnProperty过滤器，它们是相同的，有时甚至不使用。

MY_GLOBAL = {i: 1, nextId: function(){return this.i++}};  // For example

var userB = {
   name: null,
   id: null,
   sayHello: function() {
      console.log('Hello '+ this.name);
   }
}

var bob = Object.gen(userB, 'Bob', MY_GLOBAL.nextId());

我想说的是比Object简单一些。因为userB不需要init方法。此外，userB并不是特定的构造函数，但看起来像一个普通的单例对象。因此，使用这个方法，你可以从普通的普通对象构造和初始化。

有时不能使用NEW创建对象，但仍然可以调用create方法。

例如:如果你想定义一个自定义元素，它必须派生自HTMLElement。

proto = new HTMLElement  //fail :(
proto = Object.create( HTMLElement.prototype )  //OK :)
document.registerElement( "custom-element", { prototype: proto } )

new and Object.create serve different purposes. new is intended to create a new instance of an object type. Object.create is intended to simply create a new object and set its prototype. Why is this useful? To implement inheritance without accessing the __proto__ property. An object instance's prototype referred to as [[Prototype]] is an internal property of the virtual machine and is not intended to be directly accessed. The only reason it is actually possible to directly access [[Prototype]] as the __proto__ property is because it has always been a de-facto standard of every major virtual machine's implementation of ECMAScript, and at this point removing it would break a lot of existing code.

对于7ochem上面的回答，对象绝对不应该将它们的原型设置为new语句的结果，不仅因为没有必要多次调用相同的原型构造函数，而且因为如果在创建原型后修改了原型，同一类的两个实例可能会以不同的行为结束。这两个例子都是由于误解和破坏了原型继承链的预期行为而导致的糟糕代码。

当使用Object创建一个实例时，应该写入实例的原型，而不是访问__proto__。创建或随后使用Object。setPrototypeOf，用Object读取。getPrototypeOf或Object.isPrototypeOf。

Also, as the Mozilla documentation of Object.setPrototypeOf points out, it is a bad idea to modify the prototype of an object after it is created for performance reasons, in addition to the fact that modifying an object's prototype after it is created can cause undefined behavior if a given piece of code that accesses it can be executed before OR after the prototype is modified, unless that code is very careful to check the current prototype or not access any property that differs between the two.

Given const X = function (v) { this.v = v }; X.prototype.whatAmI = 'X'; X.prototype.getWhatIAm = () => this.whatAmI; X.prototype.getV = () => this.v; the following VM pseudo-code is equivalent to the statement const x0 = new X(1);: const x0 = {}; x0.[[Prototype]] = X.prototype; X.prototype.constructor.call(x0, 1); Note although the constructor can return any value, the new statement always ignores its return value and returns a reference to the newly created object. And the following pseudo-code is equivalent to the statement const x1 = Object.create(X.prototype);: const x0 = {}; x0.[[Prototype]] = X.prototype; As you can see, the only difference between the two is that Object.create does not execute the constructor, which can actually return any value but simply returns the new object reference this if not otherwise specified.

Now, if we wanted to create a subclass Y with the following definition: const Y = function(u) { this.u = u; } Y.prototype.whatAmI = 'Y'; Y.prototype.getU = () => this.u; Then we can make it inherit from X like this by writing to __proto__: Y.prototype.__proto__ = X.prototype; While the same thing could be accomplished without ever writing to __proto__ with: Y.prototype = Object.create(X.prototype); Y.prototype.constructor = Y; In the latter case, it is necessary to set the constructor property of the prototype so that the correct constructor is called by the new Y statement, otherwise new Y will call the function X. If the programmer does want new Y to call X, it would be more properly done in Y's constructor with X.call(this, u)

我认为问题的重点是理解new和Object之间的区别。创建方法。根据这个答案和这个视频，new关键字做了下面的事情:

创建新对象。 将新对象链接到构造函数(原型)。 使此变量指向新对象。 使用new对象执行构造函数，隐式执行返回this; 将构造函数函数名赋给新对象的属性构造函数。

对象。Create只执行第1和第2步!

在代码示例中提供的问题，这不是什么大问题，但在下一个例子中，它是:

var onlineUsers = [];
function SiteMember(name) {
    this.name = name;
    onlineUsers.push(name);
}
SiteMember.prototype.getName = function() {
    return this.name;
}
function Guest(name) {
    SiteMember.call(this, name);
}
Guest.prototype = new SiteMember();

var g = new Guest('James');
console.log(onlineUsers);

作为副作用的结果将是:

[ undefined, 'James' ]

因为盖斯特。prototype = new SiteMember(); 但是我们不需要执行父构造函数方法，我们只需要使方法getName在Guest中可用。 因此我们必须使用Object.create。 如果替换Guest。prototype = new SiteMember(); 来的客人。prototype = Object.create(sitember .prototype);结果是:

[ 'James' ]

你必须创建一个自定义的Object.create()函数。它解决了Crockfords的问题，也调用了init函数。

这是可行的:

var userBPrototype = {
    init: function(nameParam) {
        this.name = nameParam;
    },
    sayHello: function() {
        console.log('Hello '+ this.name);
    }
};


function UserB(name) {
    function F() {};
    F.prototype = userBPrototype;
    var f = new F;
    f.init(name);
    return f;
}

var bob = UserB('bob');
bob.sayHello();

这里UserB类似于Object。创造，但要适应我们的需要。

如果你愿意，也可以拨打:

var bob = new UserB('bob');