首先原型鏈?zhǔn)侵傅氖菍ο鬄閱挝?
閉包呢,是以函數(shù)為單位.
我說的相似之處是,
他們都能有自己獨(dú)立的倉庫,或者世界.

原型鏈

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這個實(shí)例對象,可以訪問他上面所有原型鏈上的方法和屬性.
本篇里我想象成,他擁有多個世界的鑰匙.

函數(shù)

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();

這么寫感覺挺蠢的,重點(diǎn)是,函數(shù)也能擁有很多個世界.

我們不嵌套多層,就看看兩層結(jié)構(gòu)

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這樣的方式去訪問操作.
  因?yàn)閇[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;
        }
      })();

跟原型鏈,對象的操作數(shù)據(jù)方式相比,
利用函數(shù)執(zhí)行,感覺很別扭,這種別扭可能來自,操作不是很方便
但好處是,數(shù)據(jù)保護(hù)可以做的很好,
并且如果預(yù)留出的接口足夠豐富,齊全,也應(yīng)該是比較好用的.

問題是,兩者最佳適用情景是什么的問題?
這個肯定跟經(jīng)驗(yàn)有關(guān),或者跟什么設(shè)計模式有關(guān)?
我們看一下jQuery源碼就會發(fā)現(xiàn),
實(shí)際上jq是兩者結(jié)合.
先形成一個閉包,又生成一個實(shí)例.

或者,函數(shù)生成的世界,概念更接近"環(huán)境"這個概念.
而原型鏈代表的世界,概念更接近一種"庫"的概念.

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

回頭重看這一篇寫的,
感覺寫的挺蠢的,
不過令人感覺挺搞笑的是,
上面寫的函數(shù)閉包返回對象的形式.
乍一看,完全就是構(gòu)造函數(shù),就差一個new了.

我想也許,能寫成閉包形式的,都能改成構(gòu)造函數(shù)的形式返回對象,
能寫成構(gòu)造好書返回對象形式的,都能寫成閉包.

兩者的區(qū)別?
構(gòu)造函數(shù)的形式,返回的是對象,所以語義化更好?
更容易擴(kuò)展?和維護(hù)?