js设计模式第二章 读书笔记

创建一个类，可在类内部通过this增加属性和方法，也可通过原型增加，如下

var Book = function(id, bookname, price) {
    this.id = id;
    this.bookname = bookname;
    this.price = price;
}
Book.prototype.display = function() {
    // 展示这本书
};

那么用this添加的方法、属性和用prototype添加的属性、方法有什么区别？

通过this添加的属性和方法是在当前对象上添加的。然后js是一种基于原型prototype的语言，所以创建一个对象的时候，它都有一个原型对象prototype用于指向其继承的属性、方法。这样通过prtotype继承的方法并不是对象自身的。所以使用这些方法的时候，需要通过prototype一级一级查找来得到。当我们创建新的对象的时候，这些方法是不会再创建的。
而this创建是属于对象自身的。我们创建对象的时候，相当于执行了一个类，因此类里面的方法肯定会复制一份。

（1）封装（属性和方法的封装）

function Book(name){
	//私有属性/方法
    var num=1;
    //共有属性/方法
    this.getName=function(){console.log(name)};
    //特权方法  能够操纵私有属性、方法
    this.getNum=function(){console.log(num)};
    this.setNum=function(n){num=n};
}
//类静态共有属性 （对象不能访问）
Book.isChinese=true;
//类静态共有方法 （对象不能访问）
Book.resetTime=function(){
    console.log(new Date());
};
Book.prototype={
    //共有属性
    isJSBook:true,
    //共有方法
    display:function(){}
};
var b=new Book('JavaScript');
console.log(b.num);       //undefined
console.log(b.isJSBook);  //true
console.log(b.isChinese);  //undefined

共有属性/方法用于创建对象后调用。类静态属性、私有方法和方法对象不能调用

闭包

    var Book=(function(){
        //静态私有变量
        var bookNum=0;
        function checkBook(name){}
        //返回构造函数
        return function(id,name,price){
            //私有变量
            var name,price;
            //特权方法
            this.getName=function(){};
            this.setName=function(){};
            //公有属性/方法
            this.id=id;
            this.copy=function(){};
            //调用 静态私有变量
            bookNum++;
            if(bookNum>100){throw new Error('我们仅出版100本书')}
        }
    })();
    //类静态共有属性 （对象不能访问）
    Book.isChinese=true;
    //类静态共有方法 （对象不能访问）
    Book.resetTime=function(){
        console.log(new Date());
    };
    Book.prototype={
        //共有属性
        isJSBook:true,
        //共有方法
        display:function(){}
    };
    var b=new Book('JavaScript');
 
    console.log(b.bookNum);   //undefined
    console.log(b.isJSBook);  //true
    console.log(b.isChinese); //undefined

闭包是有权访问另外一个函数作用域中变量的函数，即在一个函数内部创建另外一个函数。我们将这个闭包作为创建对象的构造函数，这样他既是闭包you又是可实例对象的函数，既可访问类函数作用域中的变量，也可将checkBook称之为静态私有方法。

（2）继承

// 声明父类
function SuperClass(){
    this.superValue = true;
}
// 为父类原型添加公有方法,可供所有实例调用
SuperClass.prototype.getSuperValue = function(){
    return this.superValue;
}
// 声明子类
function SubClass(){
    this.subValue = false;
}
// 子类继承父类,子类prototype原型为父类实例
SubClass.prototype = new SuperClass();
// 为子类原型添加公有方法,可供所有实例调用
SubClass.prototype.getSubValue = function(){
    return this.subValue;
}
var instance = new SubClass();
instance.getSuperValue();   // true
instance.getSubValue();     // false

类式继承:将父类实例赋值给子类原型

通过类的原型对象可以为类添加公有方法，创建一个父类实例,会复制一套父类构造函数中的属性与方法,并将实例的__proto__指向父类原型对象，因此新创建的父类实例拥有了父类原型对象上的属性和方法,并且能访问到父类原型上的属性和方法，将这个父类实例赋值给子类原型,子类原型就能访问到父类原型上的属性,方法以及从父类的构造函数中复制的属性和方法

instanceof作用:检测对象是否为某个类的实例(是否继承了某个类)

console.log(instance instanceof SuperClass);// true prototype链存在SuperClass
console.log(instance instanceof SubClass);  // true prototype链存在SubClass
console.log(SubClass instanceof SuperClass);            // false 
console.log(SubClass.prototype instanceof SuperClass);  // true
console.log(instance.prototype instanceof Object);//true所有对象都是Object实例

类式继承的缺点

子类通过prototype原型对父类实例化,实现子类继承父类
所有子类实例的prototype原型都指向同一个父类对象,
此时,如果父类中的公有属性为引用类型,就会被所有子类实例所共用
所以,任何一个子类实例修改从父类构造函数中继承来的公有属性就会影响到其他子类实例

function SuperClass(){
    // 父类公有属性-数组为引用类型
    this.books = ['js', 'html', 'css']
}
// 创建子类
function SubClass(){}
// 子类继承父类
SubClass.prototype = new SuperClass();
//创建2个子类实例
var instance1 = new SubClass();
var instance2 = new SubClass();
console.log(instance1.books);//  ['js', 'html', 'css']
instance2.books.push('js设计模式');
console.log(instance1.books);//  ['js', 'html', 'css', 'js设计模式']

由于2个子类原型指向同一个父类实例,共享了数组引用类型的属性,导致相互影响

构造函数继承

// 声明父类
function SuperClass(id){
    // 公有属性-数组为引用类型
    this.books = ['js', 'html', 'css'];
    // 公有属性-值类型
    this.id = id;
}
// 父类原型方法
SuperClass.prototype.showBooks = function(){
    console.log(this.books);
}
// 声明子类
function SubClass(id){
    SuperClass.call(this, id);
}
// 创建两个子类实例
var instance1 = new SubClass(1);
var instance2 = new SubClass(2);
// 修改instance1的books数组
instance1.books.push("js设计模式");
// 打印修改后的结果
console.log(instance1.id);      // 1
console.log(instance1.books);   // ['js', 'html', 'css', 'js设计模式']
console.log(instance2.id);      // 2
console.log(instance2.books);   // ['js', 'html', 'css']
instance1.showBooks();          // TypeError 父类原型方法未被子类继承

SuperClass.call(this, id);call方法可以更改函数的作用环境,this指代当前环境在子类(SubClass)中对父类(SuperClass)调用call方法,让父类在子类环境中执行。父类执行时会给this绑定属性,而this是子类环境,所以子类就继承了父类的公有属性，也正是因此,这种继承方式并没有涉及到prototype原型。

构造函数继承的优缺点

优点:
相比于类式继承,构造函数继承克服了实例共享引用类型属性和不能初始化属性的缺点
缺点:
但由于没有使用prototype原型,导致子类不能继承父类原型

// 声明父类
function SuperClass(name){
    // 公有属性-数组为引用类型
    this.books = ['js', 'html', 'css'];
    // 公有属性-值类型
    this.name = name;
}
// 父类原型公有方法
SuperClass.prototype.getName = function(){
    console.log(this.name);
}
// 声明子类
function SubClass(name, createTime){
    // 构造函数式继承
    SuperClass.call(this, name);
    // 子类新增公有属性
    this.createTime = createTime;
}
//类式继承-子类原型继承父类实例
SubClass.prototype = new SuperClass();
// 子类原型新增公有方法
SubClass.prototype.getCreateTime(){
    console.log(this.time);
}
// 实例化两个子类对象并对其进行操作
var instance1 = new SubClass("js设计模式", 2018);
instance1.books.push("js设计模式");
console.log(this.books);    // ['js', 'html', 'css', 'js设计模式']
instance1.getName();        // js设计模式
instance1.getCreateTime();  // 2018
var instance2 = new SubClass("javascrpit", 2017);
console.log(instance2.books);   // ['js', 'html', 'css']
instance2.getName();            // javascrpit
instance2.getCreateTime();      // 2017

父类的构造函数被调用了两次,造成了资源的浪费

寄生组合式继承

//1, 原型式继承: 以一个已有的对象为原型,创造一个新的对象
    function inheritObject(o) {
        function F() {}
        F.prototype=o;
        return new F();
    }

     //2, 寄生式继承: 在原型式继承的基础上, 为新的对象添加新的方法
    function createObj(proto) {
        var o=inheritObject(proto);
        o.getName=function () {
            console.log(name);
        }
        return o;
    }

    //3, 寄生组合式继承: 在子类和父类中间添加一层次,
    //比如该层次的对象为p, p的原型指向父类的原型,子类的原型指向p,
    //p的构造函数指向子类.
    function inheritProto(subClass,superClass) {
        //使用原型继承创建一个父类的子类;
        var middle=inheritObject(superClass);
        //子类的原型指向middle
        subClass.prototype=middle;
        //middle的构造属性指向子类
        middle.constructor=subClass;
    }

    //4,缺陷
    //因为寄生组合继承只是解决了继承链的问题,
    //没有解决实例属性的问题,
    //所以在子类构造函数中,需要用构造函数式继承,解决实例属性继承的问题

    //5, 测试用例
    function SuperClass(name) {
        this.name=name;
        this.colors=['red','blue','green'];
    }
    SuperClass.prototype.showColors=function () {
        console.log(this.colors);
    }
    function SubClass(name,time) {
        SuperClass.call(this,name);
        this.time=time;
    }
    var instance1=new SubClass("sub1","2014");
    var instance2=new SubClass("sub2","2015");

    instance1.colors.push("yellow");
    instance2.colors.push("gray");

    console.log(instance1);
    console.log(instance2);

（3）多态

function Add() {

    // 无参数
    function zero() {
        return 10;
    }

    //一个参数
    function one(num) {
        return 10 + num;
    }

    //两个参数
    function two(num1, num2) {
        return 10 + num1 + num2;
    }

    this.add = function () {
        var arg = arguments,
            len = arguments.length;
        switch (len) {
            case 0:
                return zero();
            case 1:
                return one(arguments[0]);
            case 2:
                return two(arguments[0], arguments[1]);
            default:
                return 0;
        }
    }
}

var instance = new Add();
console.log(instance.add())     // 10
console.log(instance.add(1))    // 11
console.log(instance.add(1, 2)) // 13

调用实例的add方法,会根据参数数量,选择不同算法进行计算

请da大神多多赐教。qq:274501366