弄懂js原型链-对象创建

创建对象几种方法

第一种方式：字面量

     var o1 = {name: 'o1'};
     var o2 = new Object({name: 'o2'});

第二种方式：构造函数

     var M = function (name) { this.name = name; };
     var o3 = new M('o3');

第三种方式：Object.create

     var p = {name: 'p'};
     var o4 = Object.create(p);

     M.prototype.say = function () {
         console.log('say hi');
     };
     var o5 = new M('o5');

new 运算符的工作原理

var new2 = function (func) {
//生成一个新对象  继承自构造函数的原型对象 
       var o = Object.create(func.prototype);
//  执行构造函数  转移上下文
       var k = func.call(o);
       if (typeof k === 'object') {
           return k;
       } else {
           return o;
       }
   };

var o4 = Object.create(p) 是通过原型链来链接的 o4.__proto__ === p ===》true
o4其实是一个空对象，并没有name这个属性，他是通过原型链来链接到p 找到name属性，所以和上面三个不同

原型，构造函数，实例，原型链

1. 对象就是实例 函数的实例都是对象，对象就有__proto__属性 获取它的原型对象 函数的原型对象是function的原型 也就是说 M 是function的实例
   M.__proto__.constructor=== Function ===>true

M.__proto__ === Function.prototype ===>true

1. new 运算符操作的函数 就是构造函数 构造函数可以可以根据prototype 获取它的实例的原型对象
   o3.__proto__=== M.prototype ==>true
2. 任何函数都可以是构造函数，只要用 new 去操作它 ，没有就是普通函数 函数才有prototype 对象没有
   原型对象可以通过constructor获取对应的构造函数

M.prototype.constructor === M ==>true
o3 instanceof M ==> true
o3.__proto__.constructor ===M ==>true

1. Object 既是一个对象 也是一个构造函数 Object.prototype 获得原型链的顶端
   o3.__proto__.__proto__===Object.prototype ===》true

2. 原型链的作用 ，可以给共同原型链对象添加方法，其他对象都可以获得这个方法
   M.prototype.say = function () {

         console.log('say hi');
     };

   o3.say() say hi

o5.say() say hi
o3对象会通过 .__proto__.__proto__去找它的原型链对象是否有这个方法如果有则执行 都没有就报错

instanceof的原理

1. 实例 instanceof 构造函数 就是判断实例.__proto__ === 构造函数.prototype 两边得到都是原型对象 看它是否是同一个引用
2. instanceof Object ==>true

o3.__proto__ ===M.prototype ==>true
M.prototype._proto_ ===Object.prototype ==>true
o3.__proto__.__proto__ ===Object.prototype ==>true

1. new运算符

//new 运算符的工作原理
      var new2 = function (func) {
   //生成一个新对象  继承自构造函数的原型对象 
          var o = Object.create(func.prototype);
   //  执行构造函数  转移上下文
          var k = func.call(o);
          //判断构造函数返回的是不是一个对象
          if (typeof k === 'object') {
              return k;
          } else {
              return o;
          }

验证 new2 是否和 new 一个效果

o6 = new2(M);
M {name: undefined}
o6.__proto__=== M.prototype
true
o6.__proto__.constructor ===M
true
o6 instanceof M
true