Javascript的原型和原型鏈你瞭解嗎

一、為什麼要使用原型？怎樣去理解原型的出現

1、對象字面量創建對象的缺點

想要介紹原型，就不得不提為什麼我們要使用原型，在js早期，我們創建一個對象，比較流行的做法是使用對象字面量去創建一個對象，例如：

const person = {
            name: "wywy",
            age: 21,
            hobby: "聽周傑倫"
}

用這種方式去創建對象，雖然簡潔明瞭，但是我們如果需要大批量的創建這一類的對象，就像person這個對象，我們可能需要去創建多個不同的人，那麼每一次都需要去聲明創建，這樣工作量是巨大的，為瞭解決這個問題我們引入瞭工廠函數的概念。

2、工廠函數

什麼是工廠函數，顧名思義就可以把工廠函數看作是一個流水線的工廠，這個工廠的作用就是批量生產person對象，就像下面這樣：

function createPerson(name,age,hobby){
	const obj = {};
	obj.name = name;
	obj.age = age;
	obj.hobby = hobby;
	return obj;
}
const person1 = createPerson("zs", 23, "滑板");
const person2 = createPerson("ls", 22, "聽歌");
console.log(person1);
console.log(person2);

這裡我們在創建person對象的時候隻需要調用這個函數即可，並把每個對象對應的屬性值傳入就好瞭，這樣相對於用對象字面量去創建一個個的person確實簡化瞭代碼量，但是工廠函數也有自身的缺點，就是我們不能去判斷出這個對象的類型，按我們知道的在 js 中復雜引用數據類型進行細分，有 Array，Function，String 等，但是通過工廠函數模式創建的這些對象用控制臺打印去全部都是 Object 類型，假如你有多個工廠函數，用多個工廠函數創建瞭多個實例，但是你卻並不知道這些對象屬於哪個工廠。為此又推出瞭構造函數這個概念。

3、構造函數

關於構造函數其實它和工廠函數非常相似，在js的函數中其實並沒有單獨的一類函數叫做構造函數，構造函數總是和new關鍵字一起使用，更準確地說一個函數被構造調用瞭。當一個構造函數不使用new關鍵字調用時，他和普通的函數無異。

function CreatePerson(name, age, hobby) {
            this.name = name;
            this.age = age;
            this.hobby = hobby;
}
const person1 = new CreatePerson("zs", 23, "滑板");
const person2 = new CreatePerson("ls", 22, "聽歌");
console.log(person1);
console.log(person2);

仔細觀察，不難發現我們對上面的工廠函數進行瞭以下幾點改造：

1、我們將函數名的首字母大寫瞭，在 js 中有個規定如果你以後打算將一個函數作為構造函數去使用那麼最好把它的函數名首字母大寫，來提醒使用者這是一個構造函數。其實不大寫也不會有什麼語法錯誤。

2、我們取消瞭在函數內部顯示的聲明一個對象 “const obj = {}”，並一並取消瞭最後返回這個對象的操作 “return obj”。

3、在調用這個這個 CreatePerson 函數時在前面加上瞭 new 關鍵字。

然後我們看這個結果，這個時候我們打印的對象不在是 Object 瞭，而是我們自己創建的函數 CreatePerson。看來構造函數確實解決瞭對象無法判定類型的問題。
那麼神奇的new關鍵字在後臺做瞭什麼呢？其實它做瞭下面的五件事

1、在內存中創建一個新的對象。

2、讓新對象的內部特性 [[Prototype]] 保存函數 CreatePerson 的 prototype 的屬性值，也就是把函數的原型的指針保存到瞭 [[Prototype]] 中。

3、把函數內部的 this 指向這個新創建的對象。

4、執行函數內部的代碼。

5、如果函數本身沒有返回對象，那麼就把這個新對象返回。

我們看構造函數原來在後臺為我們做瞭這麼多事。那麼構造函數就完美瞭嗎？並不是的，我們想一個 person 是不是應該也該給他加一個方法呢？那麼我們就給加一個說話的方法吧：

function CreatePerson(name, age, hobby) {
     this.name = name;
     this.age = age;
     this.hobby = hobby;
     // 添加一個方法
     this.sayHi = function() {
         console.log("你好，我叫" + this.name)
     }
 }
const person1 = new CreatePerson("zs", 23, "滑板");
const person2 = new CreatePerson("ls", 22, "聽歌");
 console.log(person1);
 console.log(person2);

但是我們發現這樣做無疑為每一個實例對象都添加瞭一個 sayHi 方法，而且每個實例上的方法都不相等，但我們的目的是讓每個實例都有這麼一個功能就好瞭，不必創建這麼多的 sayHi 方法而去浪費內存空間。說的直白一點，比如傢裡有五個孩子，每個孩子都想玩 switch 遊戲，那麼傢長要給每個孩子買一臺 switch 嗎？當然傢裡有礦的當我沒說，一般傢庭是不是就買一臺，然後哪個孩子想玩就管傢長去要就行瞭是不是。

同樣的，代碼就是對現實生活的抽象，那麼我們是不是也可以這樣做，把方法添加到這些實例都擁有的一個爸爸是不是就好瞭，而仔細想想在 new 的五步中第二步是不是做瞭這麼一件事，沒錯他就是 js 中的原型。這個原型就是這些實例的爸爸。

說瞭這麼多我們總算要講原形瞭!!!

二、使用原型

通過上面的講解我們似乎對原型的作用有瞭大致的理解，就是把實例對象上需要用到的共有方法添加到原型上，而實例對象的自己的私有屬性寫在構造函數內部。
接下來我們對構造函數進行再一次改造：

function CreatePerson(name, age, hobby) {
     this.name = name;
     this.age = age;
     this.hobby = hobby;
     // 添加一個方法
     this.sayHi = function() {
         console.log("你好，我叫" + this.name)
     }
 }
const person1 = new CreatePerson("zs", 23, "滑板");
const person2 = new CreatePerson("ls", 22, "聽歌");
 console.log(person1);
 console.log(person2);

首先向大傢說明一點我並沒有按著定義一個構造函數，然後在構造函數的原型上添加 sayHi 方法，接著使用 new 創建實例的順序來寫代碼。而是先 new 創建瞭實例，然後再在原型上添加方法，這樣的目的是想告訴大傢，原型是具有動態性的，即你先創建瞭實例，在實例之後給原型添加瞭方法那麼實例依然是可以訪問的。而且可以看到通過比較 person1 和 person2 的 sayHi 方法我們發現這是同一個方法。這樣我們完美的解決瞭構造函數的問題。

三、原型概念辨析

首先清楚兩個概念：

• 引用類型，都具有對象特性，即可自由擴展屬性。（引用類型：Object、Array、Function、Date、RegExp）
• 每個函數function都有一個顯示原型prototype,每個實例對象都有一個隱式原型__proto__

function Fn() { // 內部語句：this.prototype = {}
}
// 1、每個函數function都有一個prototype，即顯示原型（屬性）
console.log(Fn.prototype);
// 2、每個實例對象都有一個__proto__,可稱為隱式原型（屬性）
var fn = new Fn(); // 內部語句： this.__proto__ = Fn.prototype
console.log(fn.__proto__);

兩個準則：

在設計js原型原型鏈的時候遵循以下兩個準則：

準則一： 原型對象（即Fn.prototype）的 constructor 指向構造函數本身。

準則二： 實例對象（即 fn ）的__proto__ 指向其構造函數的顯示原型。

function Fn() {}
var fn = new Fn();
// 原型對象的 constructor 指向構造函數本身
console.log(Fn.prototype.constructor === Fn); // true
// 對象的隱式原型的值為其對應構造函數的顯示原型的值
console.log(Fn.prototype === fn.__proto__); // true

理解Function與Object特例

每個函數都是 Function 的實例，所以每個函數既有顯示原型又有隱式原型，所有函數的隱式原型指向 Function.prototype; 構造器Function的構造器是它自身。

// function Foo() {} 相當於 var Foo = new Function()
// Function = new Function() => Function.__proto__ = Function.prototype
// Object 作為構造函數時，其 __proto__ 內部屬性值指向 Function.prototype
// Object.__proto__ = Function.prototype
// Function.constructor=== Function;//true

Object構造函數創建一個對象包裝器。JavaScript中的所有對象都來自 Object，所有對象都是Object的實例；所有對象從Object.prototype繼承方法和屬性，盡管它們可能被覆蓋。

// Fn的原型對象(Fn.prototype)也來自Object，故Fn.prototype.__proto__ = Object.prototype
function Fn() {}

原型鏈：

讀取某個對象的屬性時，會自動找到原型鏈中查找。

• 1、現在自身屬性中查找，找到返回
• 2、找不到則繼續沿著__proto__這條鏈向上查找，找到返回
• 3、如果最終沒有找到。返回undefined設置對象的屬性值時，不會查找原型鏈，如果當前對象中沒有此屬性，直接添加此屬性並設置其值方法一般定義在原型中，屬性一般通過構造函數定義在對象本身

原型鏈就是一個過程，原型是原型鏈這個過程中的一個單位，貫穿整個原型鏈

圖解

四、原型鏈練習

//練習題1
function A(){
}
A.prototype.n = 1;
var b = new A();
A.prototype = {
	n:2,
	m:3
}
var c = new A();
console.log(b.n,b.m,c.n,c.m)
// 1 undefined 2 3

// 測試題2
var F = function() {
};
Object.prototype.a = function() {
    console.log('a()');
};
Function.prototype.b = function() {
    console.log('b()');
};
var f = new F();
f.a(); // a()
f.b(); // 報錯：Uncaught TypeError: f.b is not a function
F.a(); // a()
F.b(); // b()

原型、原型鏈的意義與使用場景：

原型對象的作用，是用來存放實例中共有的那部分屬性、方法、可以大大減少內存消耗。

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容!       

推薦閱讀：

• 一文徹底理解js原生語法prototype,__proto__和constructor
• 帶你理解JavaScript 原型原型鏈
• 如何利用JavaScript 實現繼承
• Javascript 原型與原型鏈深入詳解
• JavaScript中new操作符的原理與實現詳解