读《JavaScript面向对象编程指南》（二）

第五章 原型

• 在JavaScript中，所有函数都会拥有一个 prototype 的属性，默认初始值为空对象。
• 可以在相关的原型对象中添加新的方法和属性，甚至可以用自定义对象来完全替换掉原有的原型对象。
• 通过某个构造器函数来new一个对象时，这些对象就会自动拥有一个指向 prototype 属性的 __proto__链接，通过它可以访问相关原型对象的属性。
• 对象自身属性的优先级要高于其原型对象的同名属性。
• 扩展内建对象不是一个好主意，如果必须要采用的话一定要谨慎。
• 当我们对原型对象执行完全替换时，可能会触发原型链某种异常，prototype.constructor属性是不可靠的。
• Best Practice：当我们重写某对象的prototype时，重置相应的constructor属性是一个好习惯。
• 每个对象都会有一个isprototype()方法，这个方法会告诉我们当前对象是否是另一个对象的原型。
• 神秘的__proto__链接。

    枚举属性

      

参考链接：JavaScript for...in循环。

第六章 继承

 //6.1.1 原型链示例
 //6.1.2 将共享属性迁移到原型中去
 //6.2   只继承于原型
 function Shape(){

 }
 Shape.prototype.name = 'shape';
 Shape.prototype.toString = function(){
     return this.name;
 }
 function TwoDShape(){

 }
 TwoDShape.prototype = Shape.prototype;
 TwoDShape.prototype.constructor = TwoDShape;
 TwoDShape.prototype.name = '2D shape';

 function Triangle(side, height){
     this.side = side;
     this.height = height;
 }
 Triangle.prototype = TwoDShape.prototype;
 Triangle.prototype.constructor = Triangle;
 Triangle.prototype.name = 'Triangle';
 Triangle.prototype.getArea = function(){
     return this.side * this.height / 2;
 }
 //临时构造器  new F()
 function Shape(){

 }
 Shape.prototype.name = 'shape';
 Shape.prototype.toString = function(){
     return this.name;
 }
 function TwoDShape(){

 }
 var F = function(){};
 F.prototype = Shape.prototype;
 TwoDShape.prototype = new F();
 TwoDShape.prototype.constructor = TwoDShape;
 TwoDShape.prototype.name = '2D shape';

 function Triangle(side, height){
     this.side = side;
     this.height = height;
 }
 var F = function(){};
 F.prototype = TwoDShape.prototype;
 Triangle.prototype = new F();
 Triangle.prototype.constructor = Triangle;
 Triangle.prototype.name = 'Triangle';
 Triangle.prototype.getArea = function(){
     return this.side * this.height / 2;
 }

 //6.3 uber——子对象访问父对象的方式
 function Shape(){}
 Shape.prototype.name = 'shape';
 Shape.prototype.toString = function(){
     var result = [];
     if (this.constructor.uber){
         result[result.length] = this.constructor.uber.toString();
     }
     result[result.length] = this.name;
     return result.join(', ');
 }
 function TwoDShape(){

 }
 var F = function(){};
 F.prototype = Shape.prototype;
 TwoDShape.prototype = new F();
 TwoDShape.prototype.constructor = TwoDShape;
 TwoDShape.uber = Shape.prototype;
 TwoDShape.prototype.name = '2D shape';

 function Triangle(side, height){
     this.side = side;
     this.height = height;
 }
 var F = function(){};
 F.prototype = TwoDShape.prototype;
 Triangle.prototype = new F();
 Triangle.prototype.constructor = Triangle;
 Triangle.uber = TwoDShape.prototype;
 Triangle.prototype.name = 'Triangle';
 Triangle.prototype.getArea = function(){
     return this.side * this.height / 2;
 }

 // 6.4 将继承部分封装成函数
 function extend(Child, Parent){
     var F = function(){};
     F.prototype = Parent.prototype;
     Child.prototype = new F();
     Child.prototype.constructor = Child;
     Child.uber = Parent.prototype;
 }
 extend(TwoDShape, Shape);
 extend(Triangle, TwoDShape);

 //6.5 属性拷贝
 function extend2(Child, Parent){
     var p = Parent.prototype;
     var c = Child.prototype;
     for (var i in p){
         c[i] = p[i];
     }
     c.uber = p;
 }

 //6.6 小心处理引用拷贝
 //6.7 对象之间的继承
 function extendCopy(p){
     var c = {};
     for(var i in p){
         c[i] = p[i];
     }
     c.uber = p;
     return c;
 }

 //6.8 深拷贝
 function deepCopy(c, p){
     var c = c || {};
     for (var i in p){
         if (typeof p[i] === 'object'){
             c[i] = (p[i].constructor === Array) ? [] : {};
             deepCopy(c[i], p[i])
         }else{
             c[i] = p[i];
         }
     }
     return c;
 }
 //6.9 object()，Douglas Crockford为我们提出了一个建议，既可以用object()
 //函数来接受父对象，并返回一个以该对象为原型的新对象。
 function object()(o){
     var n;
     function F(){}
     F.prototype = o;
     n = new F();
     n.uber = o;
     return n;
 }

 //6.10 原型继承于属性拷贝的混合使用
 function objectPlus(o, stuff){
     var n;
     function F(){};
     F.prototype = o;
     n = new F();
     n.uber = o;

     for(var i in stuff){
         n[i] = stuff[i];
     }
     return n;
 }

 //6.11 多重继承
 function multi(){
     var n = {}, stuff, j = 0, len = arguments.length;
     for(j = 0; j < len; j++){
         stuff = arguments[j];
         for(var i in stuff){
             n[i] = stuff[i];
         }
     }
     return n;
 }

 //6.12 寄生式继承
 var twoD = {
     name : '2D shape',
     dimensions : 2
 }
 function triangle(s, h){
     var that = object(twoD);
     that.name = 'Triangle';
     that.getArea = function(){
         return this.side * this.height / 2
     };
     that.side = s;
     that.height = h;
     return that;
 }

 //6.13 构造器借用
 function Shape(id){
     this.id = id;
 }
 Shape.prototype.name = 'shape';
 Shape.prototype.toString = function(){
     return this.name;
 }
 function Triangle(){
     Shape.apply(this, arguments);
 }
 Triangle.prototype = new Shape();
 Triangle.prototype.name = 'Triangle';
 //消除双重继承
 function Shape(id){
     this.id = id;
 }
 Shape.prototype.name = 'shape';
 Shape.prototype.toString = function(){
     return this.name;
 }
 function Triangle(){
     Shape.apply(this, arguments);
 }
 function extend2(Child, Parent){
     var p = Parent.prototype;
     var c = Child.prototype;
     for (var i in p){
         c[i] = p[i];
         c.uber = p;}

 }
 extend2(Triangle, Shape);
 Triangle.prototype.name = 'Triangle';