new Object()、Object.create()、{}三种对象创建方式的区别

new Object():

　　new运算符创建一个用户定义的对象类型的实例或者具有构造函数的内置对象的实例。new关键字会进行：

　　　　1、创建一个空的JavaScript对象（{}）

　　　　2、链接该对象（设置该对象的构造函数）到另一个对象

　　　　3、将1中新创建的对象作为this的上下文

　　　　4、如果该函数没有返回对象，就会返回this

当你执行
var o = new Foo();

实际上执行了
var o = new Object();
o.__proto__ = Foo.prototype;
Foo.call(o);

　　desc：

　　　　1、通过编写函数来定义对象类型

　　　　2、通过new来创建对象实例

　　创建一个对象类型，需要创建一个指定其名称和属性的函数；对象的属性可以指向其它对象

　　当代码  new Foo(...)  执行的时候

　　　　1、一个继承自Foo.prototype的新对象被创建

　　　　2、使用指定的参数调用构造函数Foo，并将this绑定到新创建的对象。new Foo等同于Foo()，也就是没有指定参数列表，Foo不带任何参数调用的情况

　　　　3、由构造函数返回的对象就是new表达式的结果。如果构造函数没有显式返回一个对象，就是用步骤一创建的对象。（一般情况下，构造函数不返回值，但是用户可以选择主动返回对象，来覆盖正常的对象创建步骤）

　　如果没有使用new运算符，构造函数会像其它的常规函数一样被调用，并不会创建一个对象。这种情况下，this的指向也是不一样的。

Object.create()：

　　创建一个新对象，使用现有的对象来提供新创建的对象的__proto__

const person = {
  isHuman: false,
  printIntroduction: function () {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
  }
};

const me = Object.create(person);

me.name = "Matthew"; // "name" 这个属性只被写在me上, 没有被写在"person"上
me.isHuman = true; // 继承的属性可被重写

me.printIntroduction();
// expected output: "My name is Matthew. Am I human? true"

　　语法：Object.create(proto, [propertiesObject])

　　　　proto：新创建对象的原型对象

　　　　propertiesObject：可选的，如果没有指定为undefined，要添加到新创建对象的可枚举属性（即自身定义的属性，而不是其原型链上的枚举属性）对象的属性描述符以及相应的属性名称。这些属性相对应Object.definedProperties()的第二个参数

　　返回值：一个新对象带着指定的原型对象和属性

　　例外：如果propertiesObject参数是null或者是非原始包装对象，就会抛出一个TypeError异常。

// Shape - 父类(superclass)
function Shape() {
  this.x = 0;
  this.y = 0;
}

// 父类的方法
Shape.prototype.move = function(x, y) {
  this.x += x;
  this.y += y;
  console.info('Shape moved.');
};

// Rectangle - 子类(subclass)
function Rectangle() {
  Shape.call(this); // call super constructor.
}

// 子类续承父类
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log('Is rect an instance of Rectangle?',rect instanceof Rectangle); // true
console.log('Is rect an instance of Shape?',rect instanceof Shape); // true
rect.move(1, 1); // Outputs, 'Shape moved.'

　　如果要是希望能够继承多个对象，就可以使用混入的方式：

function MyClass() {
     SuperClass.call(this);
     OtherSuperClass.call(this);
}

// 继承一个类
MyClass.prototype = Object.create(SuperClass.prototype);
// 混合其它
Object.assign(MyClass.prototype, OtherSuperClass.prototype);
// 重新指定constructor
MyClass.prototype.constructor = MyClass;

MyClass.prototype.myMethod = function() {
     // do a thing
};

　　使用Object.create的propertiesObject参数

var o;

// 创建一个原型为null的空对象
o = Object.create(null);


o = {};
// 以字面量方式创建的空对象就相当于:
o = Object.create(Object.prototype);


o = Object.create(Object.prototype, {
  // foo会成为所创建对象的数据属性
  foo: { 
    writable:true,
    configurable:true,
    value: "hello" 
  },
  // bar会成为所创建对象的访问器属性
  bar: {
    configurable: false,
    get: function() { return 10 },
    set: function(value) {
      console.log("Setting `o.bar` to", value);
    }
  }
});


function Constructor(){}
o = new Constructor();
// 上面的一句就相当于:
o = Object.create(Constructor.prototype);
// 当然,如果在Constructor函数中有一些初始化代码,Object.create不能执行那些代码


// 创建一个以另一个空对象为原型,且拥有一个属性p的对象
o = Object.create({}, { p: { value: 42 } })

// 省略了的属性特性默认为false,所以属性p是不可写,不可枚举,不可配置的:
o.p = 24
o.p
//42

o.q = 12
for (var prop in o) {
   console.log(prop)
}
//"q"

delete o.p
//false

//创建一个可写的,可枚举的,可配置的属性p
o2 = Object.create({}, {
  p: {
    value: 42, 
    writable: true,
    enumerable: true,
    configurable: true 
  } 
});

{}:

　　是JavaScript对象字面量创建的形式，其本质和new Object() 并无区别，默认都是继承了Object对象上的prototype