本文整理自阮一峰老师blog。

封装、继承、多态都是对对象而言,在js中提到封装也是对属性和方法的一种包装。

下面是一个最简单的封装对象:

var cat1 = {};//create object
    cat1.name = "tiny";
    cat1.eat = function () {
        console.log('eat mouse');
    }

显然这么去做的话,需要每次手动实例对象,使得代码冗余同时占用大量内存。有没有更好的方法咧。是有的!

我们可以用函数把对象的属性和方法封装

var Cat = function(name) {
    return {
        name: name,
        eat: function (){
            console.log('eat mouse');
        }
    }
}
var cat1 = Cat("tiny");
var cat2 = Cat("heihei")

函数封装不能反映属于同一原型,cat1和cat2之间内在联系不紧密,有没有更好的呢?有的!用构造函数封装。这样不同的实例对象就有了共同的原型。

var Cat = function(name) {
    this.name = name;
    this.eat = function () {
        console.log('eat mouse');
    }
}
var cat1 = new Cat("tiny");
var cat2 = new Cat("heihei")

//基于构造函数的实例对象默认有一个constructor属性,指向其构造函数
alert(cat1.constructor == Cat); //true
alert(cat2.constructor == Cat); //true

//instanceof运算符,验证实例与原型对象的关系
alert(cat1 instanceof Cat); //true
alert(cat2 instanceof Cat); //true

不知道大家发现没有,对于同一个对象,名字name是各部相同的,但是方法eat却是一样的。每次实例对象再实例一次相同的方法,意味着浪费内存。因此原型排上用场了.你可以简单的理解原型上的属性和方法是公用内存的,意味着该属性和方法是公有的。对次实例对象时,共有属性不占用多余内存。

由于javacsript中都是对象,包括函数,他们都有个原型属性prototype,那么原型过度到原型链就很自然了,原型链的尽头是Object对象的_prototype = null。

var Cat = function(name) {
    this.name = name;
}
Cat.prototype.eat = function(){
    console.log('eat mouse');
}

var cat1 = new Cat("tiny");
var cat2 = new Cat("heihei")

//hasOwnProperty方法判断属性是本地属性还是原型属性
alert(cat1.hasOwnProperty("name")); // true
alert(cat1.hasOwnProperty("type")); // false

//in运算符,判断实例是否含有某属性或者遍历所有属性
alert('name' in cat1);
for(var prop in cat1){
    console.log('cat1[' + prop + ']');
}

有了封装就有继承啦,继承可以理解为公用属性,自然而然就使用原型啦,或者在构造函数中apply/call重新绑定对象。下面代码封装好了继承,仔细琢磨

function Cat(name,color){
    Animal.apply(this, arguments);
    this.name = name;
    this.color = color;
}
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

function extend(Child, Parent) {
    var F = function(){};
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype;
}

extend(Cat,Animal);//species是Animal的属性
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

上面是构造函数的继承,下面介绍非构造函数的继承。(还有一种思路是,将父对象中的属性拷贝到子对象中,嗯,暴力。。。)

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}
var Doctor = object(Chinese);
Doctor.career = '医生';
alert(Doctor.nation); //中国

浅拷贝,浅拷贝有一个问题。那就是,如果父对象的属性等于数组或另一个对象,那么实际上,子对象获得的只是一个内存地址,而不是真正拷贝,因此存在父对象被篡改的可能。

function extendCopy(p) {
    var c = {};
    for (var i in p) {
        c[i] = p[i];
    }
    c.uber = p;
    return c;
}

var Doctor = extendCopy(Chinese);
Doctor.career = '医生';
alert(Doctor.nation); // 中国

Chinese.birthPlaces = ['北京','上海','香港'];
var Doctor = extendCopy(Chinese);
//然后,我们为Doctor的"出生地"添加一个城市:
Doctor.birthPlaces.push('厦门');
//发生了什么事?Chinese的"出生地"也被改掉了!
alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
alert(Chinese.birthPlaces); //北京, 上海, 香港, 厦门

深拷贝,目前jQuery库使用的就是深拷贝。

function deepCopy(p, c) {
    var c = c || {};
    for (var i in p) {
        if (typeof p[i] === 'object') {
            c[i] = (p[i].constructor === Array) ? [] : {};
            deepCopy(p[i], c[i]);
        } else {
            c[i] = p[i];
        }
    }
    return c;
}

var Doctor = deepCopy(Chinese);

Chinese.birthPlaces = ['北京','上海','香港'];
Doctor.birthPlaces.push('厦门');

alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
alert(Chinese.birthPlaces); //北京, 上海, 香港