摘要：先來看一個這樣的對象在函數的原型上擴展了一個方法可以看到實例化的對象下有一個屬性，而這個屬性就指向構造函數的原型對象。重點是，連接的是實例對象與構造函數原型對象，而不是，實例對象和構造函數。

介紹原型的概念，和相關屬性，以及jquery判斷純凈對象的實現，不小心點進來的直接 ctrl+f 搜你想找的屬性。

什么是原型

isPrototypeOf() || Object.getPrototypeOf()

hasOwnProperty() || in

jQuery.isPlainObject() 源碼解讀

prototype（原型，雛形，藍本） 說新上市的一部手機的原型機，就可以用這個單詞。
每一個函數默認都有一個prototype（原型）屬性，這個屬性指向函數的原型對象。就是說函數的原型是一個對象。先來打印一個函數的這個prototype屬性，來看看他是什么樣的。

function Zoom(){};
var proto = Zoom.prototype;
console.log(proto);

眼見為實，這就是Zoom函數的原型對象，其中還有一個constructor 屬性，我們并未對prototype原型對象進行修改，但卻有一個constructor屬性。默認情況下，函數的原型對象都會獲取到一個constructor屬性。
constructor（構造器）英文中的解釋為構造器。圖中constructor的屬性值為Zoom函數。便于記憶，也可以理解為，函數的原型是由函數產生的，那構造出原型的東西，就是函數本身。也就是：

Zoom.prototype.constructor = Zoom;
//語言描述就是：zoom函數的原型對象的constructor屬性，指向函數本身。

當我們通過new操作符，獲取了一個構造函數的實例后（就是產生了一個對象）。先來看一個這樣的對象：

function Zoom(){
  this.bird = function(){
    console.log("bird");
  }
};
//在函數的原型上擴展了一個方法
Zoom.prototype.cat = function(){
  console.log("cat");
}
var zoom = new Zoom();
console.log(zoom);

可以看到實例化的zoom對象下有一個__proto__屬性，而這個屬性就指向構造函數Zoom的原型對象。重點是，__proto__連接的是實例對象與構造函數原型對象，而不是，實例對象和構造函數。

function Zoom(){
  this.bird = function(){
    console.log("bird");
  }
};
//在函數的原型上擴展了一個方法
Zoom.prototype.cat = function(){
  console.log("cat");
}
Zoom.prototype.fish= function(){
  console.log("fish");
}
var zoom1 = new Zoom();
var zoom2 = new Zoom();
zoom1.cat ();//cat
zoom2.fish();//fish
console.log(zoom1);
console.log(zoom2);

根據上一節說的，zoom1,zoom2實例對象都有一個屬性__proto__指向構造函數的原型對象，換句話說，就是實例對象和構造函數沒什么直接的聯系。
但是我們發現，這兩個實例都不包含方法，卻能夠使用a,b 方法，這就是通過查找對象屬性的過程來實現的。
當我們在調用一個對象的屬性值是，首先會從實例對象本身開始搜索，如果找到了就返回屬性值，沒有找到就在原型對象上查找。這也是原型對象的屬性或方法可以共享的原因。
那如何知道一個對象，例如兩個實例的原型鏈中，是否有構造函數的原型對象（Zoom）的方法呢。這就是isPrototypeOf（）。用來確定一個對象是否存在于另一個對象的原型鏈中。

console.log(Zoom.prototype.isPrototypeOf(zoom1));//true

雖然原型可以共享，但是不能通過實例對象修改原型：

zom1.cat = function (){
  console.log("zom1 輸出的 cat");
}
zom1.cat ();//z1 輸出的 cat
zom2.cat ();//原型輸出的cat

這個其實很好理解，因為對象屬性查找是從實例向原型上查找，所以寫在實例上的方法如果和原型上的方法同名的話，會屏蔽原型上的方法，可以簡單理解為就近原則。

既然同一個方法可以出現在實例中，也可以出現在原型中，如何可以判斷是否在實例中呢。
hasOwnProperty() 方法會返回一個布爾值，指示對象是否具有指定的屬性作為自身（不繼承）屬性。
如果判斷在zoom1對象自身是否有a屬性，就可以：

zoom1.hasOwnProperty(bird); // true
zoom1.hasOwnProperty(fish); // false

因為bird 是zoom1 自身的屬性，所以返回true，而fish是zoom1原型的的屬性，所以返回false。
另一個要介紹的in方法，它比hasOwnProperty判斷的范圍更大，無論在原型上或者是在實例上，如果存在要檢測的屬性，都會返回true。

"bird" in zoom1; // true
"fish" in zoom1; // false

那就可以理解為，在in方法的判斷范圍中中排除hasOwnProperty的判斷范圍，剩下的不就是屬性只出現在原型中的可能。
轉為簡單邏輯就是，如果in為真則可能在實例中也可能在原型中，如果hasOwnProperty方法為假，就肯定不是在實例中。所以in為真，hasOwnProperty為假，就一定是在原型中：

function hasProtoTypeProto(attr,obj){
   return !obj.hasOwnProperty(attr) && (attr in obj)
}
hasProtoTypeProto("fish",zoom1) //true
hasProtoTypeProto("bird",zoom1) //false

是jquery提供的外部可以直接使用的方法，這個方法是用來判斷一個對象是否是純粹的對象，即對象字面量，而不是一個構造函數的實例。其中涵蓋了大部分原型相關的方法。我們先來看一下如何使用。

var log = console.log.bind(console);
log(jQuery.isPlainObject({x:0}));//true
log(jQuery.isPlainObject(new Object({})))//true
log(jQuery.isPlainObject([0]))//false
function Zoom(){
  this.fish = function(){
    return "Im a fish";
  }
}
var zoom = new Zoom();
log(jQuery.isPlainObject(zoom))//false

可以看到只有純粹的對象才會返回真，typeof類型檢測出數組為object，或是構造函數的實例都是返回假。我們看一看在jquery 3.1版本中是如何實現這個方法的。分析過程請見代碼：

//傳入需要判斷的對象
function isPlainObject(obj) {
//沒有具體的意義只是保存其他執行的結果。
var proto, Ctor;
if (!obj || toString.call(obj) !== "[object Object]") {
  // toString 在之前的代碼中已被定義為 Object.prototype.toString,代碼等價于Object.prototype.toString.call( obj ) !== "[object Object]"
  //在任何值上調用Object 原生的toString()方法，都會返回一個[object NativeConstructorName] 格式的字符串，
  //[[Class]]是一個內部屬性,所有的對象(原生對象和宿主對象)都擁有該屬性，這個屬性中就指定了上述字符串中的構造函數名（NativeConstructorName）
  // 類似的 [object Array] [object Function] [object RegExp]
  //但是這個判斷不能排除一個實例對象，因為上[[Class]] 屬性默認保存對象的類型，所以也會返回Object;
  //所以除了對象的其他類型，都會返回false
  return false;
}
proto = getProto(obj);
// getProto 之前已經被定義為 getProto = Object.getPrototypeOf 返回對象構造函數的原型
// Objects with no prototype (e.g., `Object.create( null )`) are plain
// 上一行是坐著的注釋，即為通過Object.create( null ) 方法，可以創建一個沒有原型的對象null
// 所以如果proto 為false，表示對象沒有原型，只會是null，而null也是一個純粹的對象，所以返回真
if (!proto) {
  return true;
}

Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
// Objects with prototype are plain iff they were constructed by a global Object function
// hasOwn之前被定義為，hasOwn = {}.hasOwnProperty 
// hasOwn.call( proto, "constructor" ) 傳入對象構造函數的原型，判斷原型上面有沒有constructor屬性（而不是在原型鏈的其他位置），因為constructor屬性只會出現在Object函數的原型上，其他函數原型的constructor屬性，都是從Object原型上繼承來的
// 所以有constructor屬性表示是通過Object對象得到的，但是還不能確定為是Object的實例，或是字面量方式得到。最后保存proto.constructor 即是傳入對象的構造函數


return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
// fnToString被定義為hasOwn.toString 即是{}.hasOwnProperty.toString.call(Ctor);
// ObjectFunctionString定義為fnToString.call( Object ) 即是{}.hasOwnProperty.toString.call(Object);
// 所以 typeof Ctor = "fuction" 為函數就是需要判斷對象的原型是函數類型，{}.hasOwnProperty目的是得到一個函數，一個函數的toString方法會以字符串的格式顯示函數
// 如果兩個字符串相等，表示兩個函數相等。也就表示傳入對象的構造函數就是Object，所以他是一個純凈的對象。

}

至此就是全文的所有內容，有疑問盡情留言，一定回復。