web 原型鏈與對象

原型鏈類

一、建立對象有幾種方法

 二、原型、構造函數、實例、原型鏈的概念

三、instanceof的原理

四、new運算符

建立對象有幾種方法

字面量的方法   構造函數的方法  Object.create的方法

原型、構造函數、實例、原型鏈的概念

 

構造函數：只有是new後面的函數，它就不是一個普通的函數，它就是一個構造函數，任何一個函數只要被new使用了，均可以是構造函數

 函數都有一個prototype屬性，在聲明一個函數的時候，js就會自動給一個prototype屬性，prototype指的是原型對象，原型對象的constructor是聲明的那個函數

 原型鏈是經過什麼往上查找呢？經過__proto__

任何一個實例化的對象，經過原型鏈找到它上面的原型對象，這個原型對象上面的方法和屬性是它的實例對象所共用的。這就是原型鏈的基本原理

 

M = function (name) {
   this.name = name
    this.say = function () {
        console.log('say hi')
    }
}
M.prototype.say = function () {
    console.log('say hi')
}
var o1 = new M('o1')
上述代碼中，在構造函數中寫的方法，和在原型對象上寫的方法的區別：
構造函數中寫的方法在每次實例化對象的時候都會被執行一次，會比較佔內存，而在原型對象上面寫的方法，是可讓實例對象經過原型鏈進行繼承的

 只有實例纔有__proto__屬性，可是會發現上述的M也有__proto__屬性，這是由於函數其實它也是一個對象，發現M.__proto ==function.prototype,就是說M的構造函數是function

 instanceof的原理

instanceof 判斷實例是不是某個構造函數的實例

好比：o1.instanceof == M // true

　　o1.instanceof == Object //true

只要是在o1的原型鏈上的構造函數，o1均可以instanceof

好比 A繼承了B,B繼承了C，那麼A的實例a1 a1.instanceof === B | A | C都是返回true

那麼若是知道a1是經過誰來進行實例化的呢？這得用constructor

a1.__proto__.contractor === A // true

a1.__proto__.contractor === B // false

new 運算符

面向對象類

　　類與實例

　　　　類的聲明

　　　　生成實例

　　類與繼承

　　　　如何實現繼承

　　　　繼承的幾種方式

 

類與實例

/**
* 類的聲明
*/
var Animal = function () {
this.name = 'Animal';
};

/**
* es6中class的聲明
*/
class Animal2 {
constructor () {
this.name = 'Animal2';
}
}

/**
* 實例化
*/
console.log(new Animal(), new Animal2());

類與繼承

 

/**
* 藉助構造函數實現繼承

這種方法只能部分繼承，繼承不了原型對象上的方法和屬性

call:將父級函數運行的this指向子類函數
*/
function Parent1 () {
this.name = 'parent1';
}
Parent1.prototype.say = function () {

};
function Child1 () {
Parent1.call(this);
this.type = 'child1';
}
console.log(new Child1(), new Child1().say());

/**
* 藉助原型鏈實現繼承

這種方法的缺點：若是其中一個實例改變了原型對象上的一個方法，則其餘的實例的方法都會被改變，由於全部實例都是繼承了一個原型鏈上的方法
*/
function Parent2 () {
this.name = 'parent2';
this.play = [1, 2, 3];
}
function Child2 () {
this.type = 'child2';
}
Child2.prototype = new Parent2();

var s1 = new Child2();
var s2 = new Child2();
console.log(s1.play, s2.play);
s1.play.push(4);

/**
* 組合方式

這種方式的缺點就是：父級的構造函數執行了兩次，

若是把play寫到prototype中，實例中的一個對象改變此方法，則另外的對象的此方法也跟着改變
*/
function Parent3 () {
this.name = 'parent3';
this.play = [1, 2, 3];
}
function Child3 () {
Parent3.call(this);
this.type = 'child3';
}
Child3.prototype = new Parent3(); // 構造函數執行了一次
var s3 = new Child3();// 構造函數又執行了一次
var s4 = new Child3();
s3.play.push(4);
console.log(s3.play, s4.play);

/**
* 組合繼承的優化1

Child4.prototype = Parent4.prototype;此步把child4的原型對象和parent4的原型對象是指向了同一個，當new chlid4（）的時候，沒法區分這個實例的構造函數是chlid4仍是parent4
* @type {String}
*/
function Parent4 () {
this.name = 'parent4';
this.play = [1, 2, 3];
}
function Child4 () {
Parent4.call(this);
this.type = 'child4';
}
Child4.prototype = Parent4.prototype;
var s5 = new Child4();
var s6 = new Child4();
console.log(s5, s6);

console.log(s5 instanceof Child4, s5 instanceof Parent4);
console.log(s5.constructor);

/**
* 組合繼承的優化2

Object.create(Parent5.prototype) 首先創造一個空的對象，這個對象的原型對象繼承了parent5.prototype的原型對象，這就能區分了child5的構造函數了

Object.create（參數）這個方法建立的對象的原型對象就是它的參數
*/
function Parent5 () {
this.name = 'parent5';
this.play = [1, 2, 3];
}
function Child5 () {
Parent5.call(this);
this.type = 'child5';
}
Child5.prototype = Object.create(Parent5.prototype);

Child5.prototype.constractor = Child5