读书笔记-1【javascript语言精粹】继承

构造器调用模式

当一个函数对象被创建时，Function构造器会运行类似这样的代码：

this.prototype = {constructor: this}

new一个函数事会发生：

Function.method('new', function() {
    // 创建新对象，继承原型
    let that = Object.create(this.prototype);
    // 调用构造函数，绑定this到新对象
    let res = this.apply(that, arguments);
    return typeof res === 'object' && res || that;
}); 

伪类继承

let Mammal = function(name) {
    this.name = name;
}
Mammal.prototype.get_name = function() {
    return this.name;
}

// 构造一个实例
let myMammal = new Mammal('zhangsan');
// 利用伪类继承Mammal
let Cat = function(name) {
    this.name = name;
    this.age = age;
}

Cat.prototype = new Mammal();
Cat.prototype.get_age = function() {
    return this.age;
}

let myCat = new Cat('miao');

以上就是一个简单的伪类继承。使用构造器有个严重的危害，如果在调用构造器函数的时候忘记使用new前缀，this不仅不会绑定到新对象，还会污染全局变量；

原型模式

原型模式中，我们采用对象来继承。

let myMammal = {
    name: 'aa',
    age: 22,
    get_name: function() {
        return this.name;
    }
}

let myCat = Object.create(myMammal);
Cat.get_age = function() {
    return this.age;
}

这种继承方式，导致没有私有属性和私有函数

函数化模式

它的每一层都是在扩充that

Function.prototype.method = function (name,func) {
    this.prototype[name] = func;
    return this; 
}
// 工厂mammal函数
var mammal = function (spec) {
    var that = {};

    that.get_name = function () {
        return spec.name;
    }
    that.says = function (spec) {
        return spec.saying || '';
    } 

    return that;
}

// 工厂cat函数(基于mammal的函数)
var cat = function (spec) {
    spec.saying = spec.saying || 'meow';
    // 直接调用mammal函数
    var that = mammal(spec);
    that.purr = function (n) {
        var i, s = '';
        for (i = 0; i < n; i += 1) {
            if(s) {
                s += '-';
            }
            s += 'r';
        }
    }
    that.get_name = function () {
        return that.says() + ' ' + spec.name + ' ' + that.says();
    }
    return that;
}

// 创建myCat对象
var myCat = cat({name: 'Henrietta'});

Object.method('superior',function (name) {
    var that = this,
        method = that[name];
    return function () {
        return method.apply(that, arguments)
    }
})

// 工厂coolcat函数(基于cat函数)
var coolcat = function (spec) {
    var that = cat(spec),
        super_get_name = that.superior('get_name');
    that.get_name = function (n) {
        return 'like ' + super_get_name() + ' baby';
    }
    return that;
}

var myCoolCat = coolcat({name : 'Bix'});

var name = myCoolCat.get_name();

部件

没看懂。。

let eventuality = function(that) {
    let registry = {};
    that.fire = function(event) {
        let array, 
            func,
            handler,
            i,
            type = typeof event === 'string' ? event : event.type;
        if (registry.hasOwnProperty(type)) {
            array = registry[type];
            for(i = 0; i < array.length; i++) {
                handler = array[i];
                func = handler.method;
                if (typeof func === 'string') {
                    func = this[func];
                }
                func.apply(this, handler.parameters || [events]);
            }
        }
        return this;
            
    }
    that.on = function(type, method, parameters) {
        let handler= {
            method,
            parameters
        };
        if (registry.hasOwnProperty(type)) {
            registry[type].push(handler);
        } else {
            registry[type] = [handler];
        }
        return this;
    }
    return that;
}