摘要：所有的對象都含有一個隱藏的鏈接，用以指向在對象生成過程中所使用的構造函數對象的對象。如果能獲知對象的構造函數，也就能夠知道該對象的原型繼承情況了，于是便可以了解這個對象的一部分操作。嗯，不懂，先暫時理解為獲取構造函數吧弄懂回來補充

由于函數也是值，所以可以作為對象的屬性。把函數放在對象內部有兩個主要理由，第一個理由是把許多相關函數放在一組。把許多函數組合到單個對象中，有助于組織和理解大型程序。人類不希望去嘗試理解一個擁有數百個甚至數千個函數的系統，如果一個系統只有數十個軟件組成部分，那我們理解起來會容易很多。例如，在一個游戲程序中，我們會很自然地為玩家、地貌、物理屬性、消息傳遞、裝備、圖像等分別創建出子系統，每個都是一個很大的對象。

將函數作為屬性的第二個理由是讓程序從面向過程轉向面向對象。例如，我們不一定要將函數看作對形狀執行操作，將函數存儲為形狀的屬性。將函數放在對象的內部，可以讓人們專注于這些函數，讓函數扮演對象行為的角色。

        var firstGirlfriend = {
            // 屬性
            sex:"woman",
            behaviorA:function () {return ("漂亮")},
            behaviorB:function () {return ("前凸后翹")},
            skill:{first:"做家務",second:"按摩",thirdly:"PAPAPA"}
            // 方法
            behaviorC:function () {
                return ("我會："+this.skill.first+" | "+this.skill.second+" | ")
            },
            test:function () {return this;}
        };
        alert(firstGirlfriend.behaviorC())                 // "我會：做家務 | 按摩 |　"
        alert(firstGirlfriend.test()===firstGirlfriend)    // true

在最外層代碼中，this引用的是全局對象。

在函數內，this引用根據函數調用方式不同而有所不同。

接收方對象：通過點運算符或中括號運算符調用對象的方法時，在運算符左側所指定的對象。

var obj = {
    x:3,
    doit:function () {alert("method is called."+this.x);}
};
obj.doit();            // 對象obj時接收方對象。doit是方法
obj["doit"]();         // 同上

回到咱們的"妹子"那兒，我想知道妹子有有什么技能，所以我用一個方法（behaviorC()）讓她自己說出來，這時誰是接收方呢？沒錯，是妹子firstGirlfriend，妹子自己說自己會什么嘛，當然是她自己了，test()也證明了

方法中，this.skill.first，先確定this引用的對象，然后讀取屬性值，最后成為全局函數alert的傳入值，被彈出。

好了大概知道this是什么我們就要繼續了。

        var GirlfriendPlant = function (s) {
            return {
                sex:s,
                behaviorA:function () {return ("漂亮")},
                behaviorB:function () {return ("前凸后翹")},
                skill:{first:"做家務",second:"按摩",thirdly:"PAPAPA"},
                // 方法
                behaviorC:function () {
                    return ("我會："+this.skill.first+" | "+this.skill.second+" |　")
                },
                test:function () {return this;}
            };
        };
           
        var girl_a = GirlfriendPlant("woman");
        var girl_b = GirlfriendPlant("man");
        alert(girl_a.behaviorB());            // "前凸后翹"
        alert(girl_b.sex+" | "+girl_b.behaviorC("man | 我會：做家務 | 按摩 |　"));  // :)

瞧，是不是不用一個一個的寫啦？而且我還高度定制了一些"功能"，比如......咳咳，我是異性戀，但是男生力氣大做家務也快不是？
但是！還是有不足的地方，每個妹子出生就自帶這些技能和屬性了，可是有些妹子是不愿學習某些技能的，比如一些方法，一些屬性也不想表露出來，怎么辦？

這段代碼看上去沒問題，卻有一個嚴重缺陷，每次創建一個對象，都另行創建了額外的屬性、方法。在創建多個對象時，會浪費大量的內存來保存這些函數方法的冗余副本，這是很糟糕的事情，因為內存資源是有限的。當腳本耗盡內存就會崩潰。但是，我們還有一個方法來解決它們！

        // 工廠設置制造車間，protoMGP對象代表一個技能屬性坑齊全但是未命名未定制的妹子
        var protoMGP = {
            sex:undefined,
            behaviorA:function () {return ("漂亮")},
            behaviorB:function () {return ("前凸后翹")},
            skill:{first:undefined,second:undefined,thirdly:undefined},
            // 方法
            behaviorC:function () {
                alert("我會："+this.skill.first+" | "+this.skill.second+" | "+this.skill.thirdly);
            }
        };
        // 工廠參數輸入車間
        var middleGirlPlant = function (sex,f,s,t) {
            // 獲得車間制造的妹子（對象），注意獲得的只是粗胚，為設置參數，但已經留好坑了
            var girlObj = Object.create(protoMGP);        
            // 開始定制妹子                
            girlObj.sex = sex;                            
            girlObj.skill.first = f;
            girlObj.skill.second = s;
            girlObj.skill.thirdly = t;
            // 返回定制好的妹子（對象）
            return girlObj;
        };  
        //現在開始制造妹子
        
        var gA = middleGirlPlant("woman","洗衣","做飯","LOL");
        console.log(gA.skill.first+" | "+gA.skill.second+" | "+gA.skill.thirdly);
        // "洗衣 | 做飯 | LOL"
        
        var gB = middleGirlPlant("man","Java","C","JavaScript");
        console.log(gB.skill.first+" | "+gB.skill.second+" | "+gB.skill.thirdly);            
        // "Java | C | JavaScript"

看，我們的妹子不但滿足自定義屬性方法，并且這些屬性方法并不保存在每個妹子對象上，而是在她們的工廠中，只要需要隨時可以調用它們。（好吧這里實在抽象不起來了）

JavaScript中的每個函數對象都自動包含一個prototype屬性，prototype是函數兩個預定義屬性中的第二個，第一個length。只要函數一經定義，它的prototype屬性就會被初始化為一個全新對象。（這個全新對象有自己的一個屬性，叫做constructor）。

        // 創建構造函數highGirlfactory
        function highGirlfactory(s) {
            this.sex = s;
            var test = "哇哈哈，我有女朋友啦！！！！";
            return test;
        };
        // 構造函數的prototype(原型)
        highGirlfactory.prototype.behaviorA = function (a,b,c) {
            this.first = a;
            this.second = b;
            this.thirdly = c;
        };
        // 構造函數的prototype(原型)
        highGirlfactory.prototype.behaviorB = function () {
            console.log("我會："+this.first+this.second+this.thirdly);
        };

        // GirlA對象
        var GirlA = new highGirlfactory("woman");
        GirlA.behaviorA("Ax","Ay","Az");
        GirlA.behaviorB();                        // "我會：AxAyAz"
        // GirlB對象
        var GirlB = new highGirlfactory("woman");
        GirlB.sex = "SEX";
        console.log(GirlB.sex)                    // "SEX"
        // ---
        var Test = highGirlfactory();
        alert(Test);                              // "哇哈哈，我有女朋友啦！！！！"
        // 原型鏈
        alert(highGirlfactory.prototype.constructor===highGirlfactory)    // true
        alert(GirlA.__proto__===highGirlfactory.prototype)                // true

就不廢話了.....當你使用new操作符，就無需明確鏈接（Object.create）原型，也無需返回新創建的對象。當你在函數調用之前加上了new時，會發生什么？引自《JavaScript程序設計》《JavaScript編程全解》

調用構造函數new表達式的值是（被生成的）對象的引用。通過new表達式調用的構造函數內的this引用，引用了（被新生成的）對象。

這里先抄點板書，所有的函數（對象）都支持一種成為原型鏈的功能。使用原型鏈有兩個前提：

滿足上面后，便有了我們的原型鏈。其中對象對屬性的讀取（以及對方法的調用）是按照以下順序查找的：

對象自身的屬性

隱式鏈接所引用的對象（構造函數prototype對象）的屬性

上面的對象的隱式鏈接所引用的對象的屬性

反復按第三項的規則查找直至全部查找完畢，終點是Object.prototype對象。

關于Object.prototype我理解不是很深，到時也會在研究一下。

對于原型鏈（_proto_）這個玩意兒，他就是那個神秘的隱式鏈接，在new生成的新對象中，里面的_proto_引用的對象就是原型對象。

GirlA.__proto__===highGirlfactory.prototype

構造函數的prototype引用的對象里還有一個constructor屬性，這個東東引用的是構造函數，沒錯就是自己找自己。書中是這么寫的：

highGirlfactory.prototype.constructor===highGirlfactory

可以通過使用對象的constructor屬性來從對象處獲取其構造函數。如果能獲知對象的構造函數，也就能夠知道該對象的原型繼承情況了，于是便可以了解這個對象的一部分操作。

constructor屬性不是對象的之前屬性，而是通過原型鏈查找到的屬性。
嗯，不懂~，先暫時理解為獲取構造函數吧（弄懂回來補充）