一、函數對象(Function)和普通對象(Object)

• 由function定義或Function實例化的對象為函數對象，包括Function和Object

function Person1 (name) {
    this.name = name;
}
var Person2 = function(name) {
    this.name = name;
};
var Person3 = new Function('name', 'this.name = name');
...
typeof Person1 // function
typeof Person2 // function
typeof Person3 // function
typeof Object // function
typeof Function // function
...
// 所有的函數對象都是`Function`的實例對象
Person1 instanceof Function  // true
Object instanceof Function   // true
Function instanceof Function // true
Person1.__proto__ === Function.prototype  // true
Object.__proto__ === Function.prototype   // true
Function.__proto__ === Function.prototype // true

• 普通對象則是由函數對象(除Function外)實例化(new)的對象或字面量{}創建的對象

  // 實例化模式
  var p1 = new Person1('Franchen');
  var p2 = new Person2('Franchen');
  var p3 = new Person3('Franchen');
  var obj1 = new Object();
  // 字面量模式
  var obj2 = { name: 'Franchen' };
...
typeof p1 // object
typeof p2 // object
typeof p3 // object
typeof obj1 // object
typeof obj2 // object
...
// 注意：由Function實例化的對象是函數對象
var fun = new Function();
typeof fun // function

• 函數對象和普通對象的差別：函數對象含有原型對象屬性prototype和原型鏈屬性__proto__，而普通對象只有__proto__屬性
• 每個函數對象都有個prototype屬性，這個屬性指向函數的原型對象，原型對象(除Object.prototype外)是普通對象（Object）的實例

Object.prototype // Object原型對象
Function.prototype // Function原型對象
Person.prototype // Person原型對象
...
typeof Object.prototype // object
typeof Function.prototype // object
typeof Person.prototype // object
...
// 原型對象類型
Person.prototype instanceof Object // true
Function.prototype instanceof Object // true
Person.prototype.__proto__ === Object.prototype // true
Function.prototype.__proto__ === Object.prototype // true
// Object的原型對象類型為null
Object.prototype.__proto__ === null // true

二、原型鏈（__proto__）

1. 每個對象都有__proto__屬性，可以通過該屬性判斷對象類型及查找原型屬性方法。

function Person(){}
Person.prototype.value = 'ok'
...
var p1 = new Person();
p1.__proto__ === Person.prototype // true
p1.__proto__.value // ok
p1.value // ok

2. 原型屬性方法的繼承、隱藏、覆蓋

// 接上例
...
// 繼承原型屬性方法
// p1的value屬性繼承Person的原型對象的value屬性
p1.value // ok
...
// 隱藏原型屬性方法
// 當實例對象的自身的屬性、方法名字
// 和原型的屬性、方法名字一致時，
// 原型的屬性、方法被隱藏（原理見對象屬性方法的查找方式）
// 可通過訪問原型鏈訪問被隱藏的原型屬性方法
p1.value = 'p1'
p1.value // p1
p1.__proto__.value // ok
...
// 覆蓋原型屬性方法
// 注意：通過覆蓋原型屬性和方法會影響父類原型對象、
// 所有已實例化的子類，以及未來實例化的子類
var p2 = new Person();
p2.__proto__.value = 'p2'
p2.value               // p2（p2無自身屬性value時）
p2.__proto__.value     // p2
p1.value               // p2（p1無自身屬性value時）
p1.__proto__.value     // p2
Person.prototype.value // p2
var p3 = new Person();
p3.value               // p2（p3無自身屬性value時）

3. 原型鏈終點是Object.prototype.__proto__

Object.prototype.__proto__ === null

4. 對象屬性或方法的查找方式：沿著原型鏈往上找，直到找到或到Object.prototype.__proto__停止

var O = {},
var F = function(){};
Object.prototype.a = 'value a';
Function.prototype.b = 'value b';
...
// 自身 --> O.__proto__(Object.prototype) --> 找到
console.log(O.a)    // value a
// 自身 --> O.__proto__(Object.prototype) --> O.__proto__.__proto__(null) --> 未找到
console.log(O.b)    // undefined
// 自身 --> F.__proto__(Function.prototype) --> F.__proto__.__proto__(Object.prototype) --> 找到
console.log(F.a)      // value a
// 自身 --> F.__proto__(Function.prototype) --> 找到
console.log(F.b)      // value b

三、構造函數（constructor）

1. 構造函數默認首字母大寫
2. 構造函數并沒有顯示返回任何東西。new 操作符會自動創建給定的類型并返回他們，當調用構造函數時，new會自動創建this對象，且類型就是構造函數類型。
3. 可以在構造函數中顯示調用return。如果返回的值是一個對象，它會代替新創建的對象實例返回。如果返回的值是一個基本類型，它會被忽略，新創建的實例會被返回。
4. 創建對象的三種模式：構造模式、工廠模式、字面量模式

// 構造模式
function Person1(name) {
     this.name = name;
}
// 工廠模式：return對象
function Person2(name) {
     var obj = new Object();
     obj.name = name;
     return obj;
}
// 字面量模式
function Person3(name) {
     return {
       name: name
     };
}
// 忽略return基本類型，返回對象
function Person4(name) {
     this.name = name;
     return name;
}
...
var p1 = new Person1('Franchen'); // Person {name: 'Franchen'}
var p2 = new Person2('Franchen'); // Object {name: 'Franchen'}
var p3 = new Person3('Franchen'); // Object {name: 'Franchen'}
var p4 = new Person4('Franchen'); // Person {name: 'Franchen'}
...
// 原型對象的構造函數是Function
Person1.constructor === Function // true
// 原型對象的原型的構造函數是其自身
Person1.prototype.constructor === Person1 // true

5. 公有屬性、方法，私有屬性、方法，靜態屬性、方法，原型屬性、方法理解

function Person(name) {
     // 私有屬性
     var six = 'male';
     // 私有方法
     function say(word) { console.log(word); }
     // 公有屬性
     this.nickname = name;
     // 公有方法
     this.aboutMe = function(){
       say('Nickname: ' + this.nickname + ', Six: ' + six); 
     };
}
// 靜態屬性
Person.age = 20;
// 靜態方法
Person.getAge = function(){ return this.age; }
// 原型屬性
Person.prototype.canWalk = true;
// 原型方法
Person.prototype.walk = function(){ return this.canWalk; }
...
// 原型對象可訪問權限
Person.six       // undefined
Person.say()     // Uncaught TypeError: Person.say is not a function
Person.nickname  // undefined
Person.aboutMe() // Uncaught TypeError: Person.aboutMe is not a function
Person.age       // 20
Person.getAge()  // 20
Person.canWalk   // undefined
Person.walk()    // Uncaught TypeError: Person.walk is not a function
...
// 普通對象可訪問權限
var p1 = new Person('Franchen');
p1.six       // undefined
p1.say()     // Uncaught TypeError: Person.say is not a function
p1.nickname  // Franchen
p1.aboutMe() // Nickname: Franchen, Six: male
p1.age       // undefined
p1.getAge()  // Uncaught TypeError: p1.getAge is not a function
p1.canWalk   // true
p1.walk()    // true
...
// 靜態屬性及方法的訪問
p1.constructor.age      // 20
p1.constructor.getAge() // 20
// 原型鏈訪問原型屬性和方法
p1.__proto__.canWalk    // true
p1.__proto__.walk()     // true
...
// 訪問權限總結
 1. 私有屬性、方法：僅自身內部可以訪問。
 2. 公有屬性、方法：僅子類可以訪問
 3. 靜態屬性、方法：自身外部可以訪問，自身內部和子類可以間接訪問
 4. 原型屬性、方法：子類可以訪問，自身內部和外部都可以間接訪問