首先原型链是指的是对象为单位,
闭包呢,是以函数为单位.
我说的相似之处是,
他们都能有自己独立的仓库,或者世界.

原型链

Person.prototype.isRich = 'very rich';
function Person () {
       this.sex = 'male';
    }
    var person = new Person()
    Father.prototype = person;
    function Father () {
       this.age = 18
    }
    var father = new Father();
    Son.prototype = father;
    function Son () {
       this.name = 'mike';
    }
    var son = new Son();

son这个实例对象,可以访问他上面所有原型链上的方法和属性.
本篇里我想象成,他拥有多个世界的钥匙.

函数

var fun = (function() {
        var sex = 'male';
        function person() {
          var name = 'mike';
          function father() {
            var age = '18';
            return function son() {
              return {
                sex,
                name,
                age
              }
            }
          }
          return father();
        }
        return person();
      })();
      var a = fun();

这么写感觉挺蠢的,重点是,函数也能拥有很多个世界.

我们不嵌套多层,就看看两层结构

var fun = (function () {
        var obj = {
          name:'mike',
          age : 18,
          sex : 'male',
          handle : function () {
          console.log(123);
          }
        }
        var fun = function () {
            console.log(obj);
            return obj;
        }
        return fun;
      })();
  返回的fun上面,肯定是拥有访问上一个世界的钥匙,
  问题是无法像对象一样,通过fun.name,fun.obj这样的方式去访问操作.
  因为[[scope]]属性是无法被访问的.
  也就是说,如果想要操作obj,必须要在fun定义的时候,定义好怎么操作.
        


      Person.prototype.obj = {
        name:'mike',
        age : 18,
        sex : 'male',
        handle : function () {
            console.log(123);
        }
      }
      function Person () {};
      
      var person = new Person();

var fun = (function () {
        var obj = {
          name:'mike',
          age : 18,
          sex : 'male',
          handle : function () {
          console.log(123);
          }
        }
        var getName = function () {
            return obj.name;
        }
        var getAge = function () {
            return obj.age;
        }
        var getSex = function () {
            return obj.sex;
        }
        var getHandle = function () {
            return obj.handle;
        }
        var objFun = {
          getName,
          getAge,
          getSex,
          getHandle
        };
        
        return function () {
            return objFun;
        }
      })();

跟原型链,对象的操作数据方式相比,
利用函数执行,感觉很别扭,这种别扭可能来自,操作不是很方便
但好处是,数据保护可以做的很好,
并且如果预留出的接口足够丰富,齐全,也应该是比较好用的.

问题是,两者最佳适用情景是什么的问题?
这个肯定跟经验有关,或者跟什么设计模式有关?
我们看一下jQuery源码就会发现,
实际上jq是两者结合.
先形成一个闭包,又生成一个实例.

或者,函数生成的世界,概念更接近"环境"这个概念.
而原型链代表的世界,概念更接近一种"库"的概念.

===========================================

回头重看这一篇写的,
感觉写的挺蠢的,
不过令人感觉挺搞笑的是,
上面写的函数闭包返回对象的形式.
乍一看,完全就是构造函数,就差一个new了.

我想也许,能写成闭包形式的,都能改成构造函数的形式返回对象,
能写成构造好书返回对象形式的,都能写成闭包.

两者的区别?
构造函数的形式,返回的是对象,所以语义化更好?
更容易扩展?和维护?