JS高程读书笔记--第六章原型继承

时间 2019-12-11

标签高程读书笔记第六原型继承栏目 JavaScript 繁體版

原文原文链接

JS高程读书笔记--第六章

理解对象

建立自定义对象的方式有建立一个Object实例，而后为它添加属性和方法。还可用建立对象字面量的方式javascript

属性类型

ECMAScript在定义只有内部采用的特性时，描述了属性的各类特征。
ECMAScript中有两种属性：数据属性和访问器属性。在JS中不能直接访问它们。java

数据属性

数据属性包含一个数据值的位置。在这个位置能够读取和写入值。数组

[[Configurable]]：表示可否经过delete删除属性从而从新定义属性，可否修改属性的特性，或者可否把属性修改成访问器属性。默认值为true；浏览器
[[Enumerable]]：表示可否经过for-in循环返回属性。默认值为true；app
[[Writable]]：表示可否修改属性的值。默认值为true；函数
[[Value]]：包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性值的时候，把新值保存在这个位置。默认值为undefined；测试

要修改属性默认的特性，必须使用ES5的Object.defineProperty()方法。这个方法接收三个参数：属性所在的对象、属性的名字和一个描述符对象。在调用这个方法时，若是不指定，configurable、enumerable和writable特性的默认值都是false；this

一旦把属性定义为不可配置的，就不能再把它变回可配置的。prototype

访问器属性

访问器属性不包含数据值；他们包含一对getter和setter函数（这两个函数都不是必须的）。在读取访问器属性时，会调用getter函数，这个函数负责返回有效值；在写入访问器属性时，会调用setter函数并传入新值，这个函数负责决定如何处理数据。指针

[[Configurable]]：表示可否经过delete删除属性从而从新定义属性，可否修改属性的特性，或者可否把属性修改成数据属性。默认值为true；
[[Enumerable]]：表示可否经过for-in循环返回属性。默认值为true；
[[Get]]：在读取属性时调用的函数。默认值为undefined;
[[Set]] ：在写入属性时调用的函数。默认值为undefined；

访问器属性不能直接定义，必须使用Object.defineProperty()来定义。

不必定非要同时指定getter和setter。只指定getter意味着属性是不能写，尝试写入属性会被忽略。在严格模式下，尝试写入只指定了getter函数的属性会抛出错误。相似的，只指定setter函数的属性也不能读，不然在非严格模式下会返回undefined，而在严格模式下会抛出错误。

定义多个属性

能够利用ES5定义的Object.defineProperties()方法经过描述符一次定义多个属性。这个方法接收两个对象参数：第一个对象是要添加和修改其属性的对象，第二个对象的属性与第一个对象中要添加或修改的属性一一对应。

读取属性的特性

使用ES5的Object.getOwnPropertyDescriptor()方法，能够取得给定属性的描述符。这个方法接收两个参数：属性所在对象和要读取其描述符的属性名称，返回值是一个对象。

建立对象

工厂模式

这种模式抽象了建立具体对象的过程。开发人员发明了一种函数，用函数来封装以特定接口建立对象的细节。

function createPerson(name,age,job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        console.log(this.name);
    }
    return o;
}
var person1 = createPerson('junyan','25','FE');

工厂模式虽然解决了建立多个类似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）

构造函数模式

能够建立自定义的构造函数，从而定义自定义对象类型的属性和方法。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        console.log(this.name);
    };
}
var person1 = new Person('junyan','25','FE')

这种方式与工厂模式存在如下不一样：

没有显式的建立对象；
直接将属性和方法赋给了this对象；
没有return语句；

要建立Person新实例，必须使用new操做符。以这种方式调用构造函数实际上会经历如下4个步骤：

建立一个新对象；
将构造函数的做用域赋给新对象（所以this就指向了这个新对象）；
执行构造函数中的代码（为这个新对象添加属性）；
返回新对象；

实例都有一个constructor（构造函数）属性，该属性指向Person。对象的这个属性最初是用来标识对象类型的。可是，提到检测对象类型，仍是instanceof操做符要更可靠一些。

建立自定义的构造函数意味着未来能够将它的实例标识为一种特定的类型

将构造函数当作函数

构造函数与其余函数的惟一区别，就在于调用它们的方式不一样。任何函数，只要经过new操做符来调用，那它就能够做为构造函数；
不使用new操做符调用，属性和方法都被添加给window对象

构造函数的问题

使用构造函数的主要问题就是每一个方法都要在每一个实例上从新建立一遍。
不一样实例上的同名函数是不相等的，能够经过把函数定义转移到构造函数外部来解决。

原型模式!!

咱们建立的每一个函数都有一个prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含能够由特定类型的全部实例共享的属性和方法

prototype就是经过调用构造函数而建立的那个对象实例的原型对象

使用原型对象的好处是可让全部对象实例共享它所包含的属性和方法。换句话说，没必要在构造函数中定义对象实例的信息，而是能够将这些信息直接添加到原型对象中。

构造函、原型和实例的关系：每一个构造函数构造函数都有一个原型对象(prototype)，原型对象都包含一个指向构造函数的指针(constructor)，而实例都包含一个指向原型对象的内部指针(__proto__)

理解原型对象!!!

只要建立了一个新函数，就会根据一组特定的规则为该函数建立一个prototype属性，这个属性指向函数的原型对象。
全部原型对象都会自动得到一个constructor（构造函数）属性，这个属性包含一个指向prototype属性所在函数的指针。例：Person.prototype.constructor = Person。

建立了自定义的构造函数以后，其原型对象默认只会取得constructor属性；至于其余方法都是从Object继承而来的。

原型最初只包含constructor属性，而该属性也是共享的，所以能够经过对象实例访问

当调用构造函数建立一个新实例后，该实例的内部将包含一个指针（内部属性）ECMA叫[[Prototype]]，指向构造函数的原型对象，高级浏览器在每一个对象上都支持一个属性__proto__。

注：这个链接存在于实例与构造函数的原型对象之间，不存在于实例与构造函数之间。

能够经过isPrototypeOf()方法来肯定对象之间是否存在这种关系
Person.prototype.isPrototypeOf(person1); // true;
ES5新增了一个方法，叫Object.getPrototypeOf()，这个方法返回[[Prototype]]的值。
Object.getPrototypeOf(person1) == Person.prototype。

使用这个方法能够方便的取得一个对象的原型；

当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中的同名属性；换句话说，添加这个属性只会阻止咱们访问原型中的那个属性，但不会修改那个属性。即便将这个属性设置为null，也只会在实例中设置这个属性，而不会恢复其指向原型的连接。不过，能够经过使用delete操做符则能够彻底删除实例属性，从而让咱们可以从新访问原型中的属性。

使用hasOwnProperty()方法能够检测一个属性是存在于实例中，仍是存在于原型中。这个方法（从Object继承而来）只在给定属性存在于对象实例中，在返回true。

原型与in操做符

单独使用in时，in操做符会在经过对象可以访问给定属性时返回true，不管该属性存在于实例中仍是原型中。
同时使用hasOwnProperty()方法和in操做符，就能够肯定该属性究竟是存在于对象中，仍是存在于原型中
在使用for-in循环时，返回的是全部可以经过对象访问的、可枚举的属性，其中即包括存在于实例中的属性，也包括存在于原型中的属性。屏蔽了原型中不可枚举属性的实例属性也会在for-in循环中返回。
要取得对象上可枚举的实例属性，可使用ES5的Object.keys()，这个方法接收一个对象做为参数，返回一个包含全部可枚举属性的字符串数组。
若是想获得全部实例属性，不管它是否可枚举，均可以使用Object.getOwnPropertyNames()

更简单的原型语法

能够用一个包含全部属性和方法的对象字面量来重写整个原型对象

Person.prototype = {
    name:'junyan',
    job:'FE'
}

可是这样constructor属性就再也不指向Person，这种语法实际上彻底重写了默认的prototype对象，所以constructor属性就变成了新对象的constructor属性，再也不指向Person，而是指向Object。此时instanceof还能返回正确的结果。
若是constructor属性很重要，能够特地设定将它设置回适当的值，但这种方式重设constructor属性会致使它的[[Enumerable]]特性被设置为true，由于默认状况下原生的constructor属性是不可枚举的。可使用ES5的Object.defineProperty()

原型的动态性

咱们对原型对象所作的任何修改都可以当即从实例上反映出来，即便是先建立了实例后修改原型也照样如此，由于实例与原型之间的链接只不过是一个指针，而非一个副本；
可是若是重写了整个原型对象，就不同。调用构造函数时会为实例添加一个指向最初原型的[[Prototye]]指针（__proto__），而把原型修改成另外一个对象就等于切断了构造函数与最初原型之间的联系
重写原型对象切断了现有原型与任何以前已经存在的对象实例之间的联系，它们引用的仍然是最初的原型

实例中的指针仅指向原型，而不指向构造函数

原生对象的原型

全部原生引用类型（Object、Array、String等）都在其构造函数的原型上定义了方法；
经过原生对象的原型，不只能够取得全部默认方法的引用，并且也能够定义新方法。能够像修改自定义对象的原型同样修改原生对象的原型，所以能够随时添加方法。（不建议）；

原型对象的问题

原型中全部属性被实例共享，对于基本类型值的属性，经过在实例上添加一个同名属性，能够隐藏原型中的对应属性，但对于引用类型值的属性来讲，实例上修改其值，在全部其余实例中都会反映出来，因此基本不单独使用原型模式。

组合使用构造函数模式和原型模式

构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["xiaohua","hanghang"]
}
Person.prototype = {
    constructor:Person,
    sayName:function(){
        console.log(this.name);        
    }
}

继承

ECMAScript只支持实现继承，并且实现继承主要是依靠原型链来实现。

原型链

原型链做为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另外一个引用类型的属性和方法。

若是让原型对象等于另外一个类型的实例，此时的原型对象将包含一个指向另外一个原型的指针(__proto__)相应地，另外一个原型中也包含着一个指向另外一个构造函数的指针。若另外一个原型又是另外一个类型的实例，上述关系依然成立，如此层层递进，就构成了实例与原型的链条。

在找不到属性或方法的状况下，搜索过程老是要一环一环地前行到原型链末端才会停下来

默认的原型

全部引用类型默认都继承了Object，而这个继承也是经过原型链实现的。全部函数的默认原型都是Object实例，所以默认原型都会包含一个内部指针(__proto__)，指向Object.prototype。这也正是全部自定义类型都会继承toString()、valueOf()等默认方法的根本缘由

肯定原型和实例的关系

第一种方式是使用instanceof操做符，只要用这个操做符来测试实例与原型链中出现过的构造函数，结果就会返回true。
第二种方式是使用isPrototypeOf()方法。一样，只要是原型链中出现过的原型，均可以说是该原型链所派生的实例的原型，所以这个方法也会返回true.

谨慎地定义方法

给原型添加方法必定要放在替换原型的语句以后，重写的方法会屏蔽原来的那个方法
在经过原型链实现继承时，不能使用对象字面量建立原型方法。由于这样作就会重写原型链。

原型链的问题

实践中不多会单独使用原型链

在经过原型来实现继承时，原型实际上会变成另外一个类型的实例，原先的实例属性也就瓜熟蒂落的变成了如今的原型属性
在建立子类型的实例时，不能向超类型的构造函数中传递参数。应该说是没有办法在不影响全部对象实例的状况下，给超类型的构造函数传递参数。

借用构造函数

在子类型构造函数的内部调用超类型构造函数，能够经过使用apply()和call()方法在新建立的对象上执行构造函数。

function SubType(){
    SuperType.call(this);
}

这一年就会在新的Subtype对象上执行SuperType()函数中定义的全部对象初始化代码。

能够在子类型构造函数中向超类型构造函数传递参数

function SubType(){
    SuperType.call(this,'junyan');
}

若是仅仅是借用构造函数，那么也将没法避免构造函数模式存在的问题——方法都在构造函数中定义，所以函数复用就无从谈起，并且在超类型的原型中定义的方法，对子类型而言也是不可见的，结果全部类型都只能使用构造函数模式。

组合继承

有时也叫做伪经典继承，使用原型链实现对原型属性和方法的继承，而经过借用构造函数来实现对实例属性的继承。这样既经过在原型上定义方法实现了函数复用，又可以保证每一个实例都有它本身的属性。

instanceof和isPrototypeof()也可以用于识别基于组合继承建立的对象

组合继承最大的问题就是不管什么状况下，都会调用两次超类型构造函数：一次是在建立子类原型的时候，另外一次是在子类型构造函数内部。

原型式继承

这个方法没有使用严格意义上的构造函数，是基于已有的对象建立新对象，同时还没必要所以建立自定义类型。

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

严格上讲，object()对传入其中的对象执行了一次浅复制

ES5经过新增Object.create()方法规范了原型式继承。这个方法接收两个参数：一个用做新对象原型的对象和（可选的）一个为新对象定义额外属性的对象。在传入一个参数的状况下，Object.create()与object()方法的行为相同。
只想让一个对象与另外一个对象保持相似的状况下，原型式继承是彻底能够胜任的，不要忘了，包含引用类型值的属性始终都会共享相应的值，就像使用原型模式同样。

寄生式继承

建立一个仅用于封装继承过程的函数，该函数在内部以某种方式来加强对象，最后再像真地是它作了全部工做同样返回对象。

function createAnother(original){
    var clone = object(original);
    clone.sayHi = function(){
        console.log('Hi');
    };
    return clone;
}

在主要考虑对象而不是自定义类型和构造函数的状况下，寄生式继承也是一种有用的模式。任何可以返回新对象的函数都适用于这个模式

寄生式组合继承

所谓寄生组合式继承，即经过借用构造函数来继承属性，经过原型链的混成形式来继承方法。其背后的基本思路是：没必要为了指定子类型的原型而调用超类型的构造函数，咱们所须要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，而后再将结果指定给子类型的原型

function inheritPrototype(subType,superType){
    var prototype = Object(superType.prototype);
    prototype.constructor = subType;
    subType.prototype = prototype;
}

第一步是建立超类型原型的一个副本
第二部是为建立的副本添加constructor属性，从而弥补因重写原型而失去的默认的constructor属性。
将新建立的对象（即副本）赋值给子类型的原型

这种继承的高效率体如今它只调用了一次超类型构造函数，而且所以避免了在子类型.prototype上面建立没必要要的、多余的属性。于此同事，原型链还能保持不变；所以还能正常使用instanceof()和isPrototypeOf()