javascript中的中对象和原型

使用对象字面量的方式或者new Object()(Object构造函数)的方法创建对象有个明显的缺点:产生大量的冗余代码.为了解决这个问题我们有以下的几种方法:

工厂模式

这种模式抽象了具体创建某个对象的过程.如下所示:

function createPerson(name, age, sex) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.sex = sex;
    o.sayHello = function() {
        console.log(this.name);
    }
    return o;
}

var p1 = createPerson('Nike', 22, '男');
var p2 = createPerson('Dicy', 21, '女');

以上的代码有一个明显的缺点:我们无法知道产生的对象是哪个实例(因为工厂函数的内部使用的是new Object(),都是Object的实例,我们无法判断它是Person的实例).

构造函数模式

这种模式解决了上述问题,我们来看以下的代码:

function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sayHello = function() {
        console.log(this.name);
    }
}

var p1 = new Person('Nike', 22, '男');
var p2 = new Person('Dicy', 21, '女');

这种模式和工厂模式的不同之处在于:

• 没有显式地创建对象
• 直接将属性和方法赋给了 this 对象
• 没有 return 语句

使用构造函数模式创建对象需要经过以下的几个步骤:

1. 创建一个新对象
2. 将构造函数的作用域赋给新对象(因此 this 就指向了这个新对象)
3. 执行构造函数中的代码(为这个新对象添加属性)
4. 返回新对象

p1和p2都保存了Person的一个不同的实例,这两个对象都有一个constructor属性,该属性指向Person:

console.log(p1.constructor === Person); // true
console.log(p2.constructor === Person); // true

对象的constructor属性最初是用来标识对象类型的。但是,提到检测对象类型,还是 instanceof 操作符要更可靠一些。

console.log(p1 instanceof Person,p2 instanceof Person,p1 instanceof Object,p1 instanceof Object); // true true true true

通过构造函数创建对象有一个很好的优点,可以知道它的类型,这是工厂函数无法比拟的!

将构造函数当做普通函数使用

构造函数本质上也是普通函数,也可以直接调用,反之普通函数也可以加new来创建对象:

function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sayHello = function() {
        console.log(this.name);
    }
}

// 作为普通函数调用(this是全局对象)
Person('Mike', 22, '男');ff
window.sayHello(); // Mike

// 在另一个作用域中调用
var p = {};
Person.call(p, 'Dency', 21, '女');
p.sayHello(); // Dency

构造函数模式的问题

构造函数模式虽然好用,但是仍然存在问题:每个实例的方法都是一个新的实例,在java等类型的语言中我们可以定义静态方法,每个实例化对象共享这个方法.在开头的这个例子中我们创建了p1和p2两个对象,这两个方法都有一个sayHello()方法,但那两个方法不是同一个Function的实例(因为函数是对象,因此每定义一个函数,也就是实例化了一个对象。)。

也就是说开头的构造函数模式实际上是以下的方式:

function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sayHello = new Function('console.log(this.name)'); // 与声明函数在逻辑上是等价的
}

以下的代码更加验证了通过构造函数创建的对象方法是每个实例特有的:

function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sayHello = function() {
        console.log(this.name);
    }
}

var p1 = new Person('Nike', 22, '男');
var p2 = new Person('Dicy', 21, '女');
console.log(p1.sayHello == p2.sayHello); // false

给每个实例创建一个相同的函数没有必要.针对这个问题我们有了新的模式.

原型模式

每个函数都有一个prototype(原型)属性,这个属性是一个指针,指向一个对象,这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。

function Person(name, age) {
    this.name = name;
    this.age = age;
}

Person.prototype.country = 'China';
Person.prototype.sayHello = function() {
    console.log(this.name);
}

// 可以简化为如下的写法
Person.prototype = {
    country: 'China',
    sayHello: function() {
        console.log(this.name);
    }
};

var p1 = new Person('Jetty', 12);
var p2 = new Person('Kissy', 18);
console.log(p1, p2); // Person { name: 'Jetty', age: 12 } Person { name: 'Kissy', age: 18 }
p1.sayHello(); // Jetty
p2.sayHello(); // Kissy
console.log(p1.sayHello === p2.sayHello); // true

理解原型对象

只要创建了一个新函数,就会根据一组特定的规则为该函数创建一个prototype属性,这个属性指向函数的原型对象。在默认情况下,所有原型对象都会自动获得一个constructor(构造函数)属性,这个属性包含一个指向prototype属性所在函数的指针。就拿前面的例子来说,Person.prototype.constructor`指向 Person 。而通过这个构造函数,我们还可继续为原型对象添加其他属性和方法。

创建了自定义的构造函数之后,其原型对象默认只会取得constructor属性;至于其他方法,则都是从Object继承而来的。当调用构造函数创建一个新实例后,该实例的内部将包含一个指针(内部属性),指向构造函数的原型对象。ES5中管这个指针叫[[Prototype]]。虽然在脚本中没有标准的方式访问[[Prototype]],但Firefox、Safari和Chrome在每个对象上都支持一个属性proto;而在其他实现中,这个属性对脚本则是完全不可见的。不过,要明确的真正重要的一点就是,这个连接存在于实例与构造函数的原型对象之间,而不是存在于实例与构造函数之间。

确定一个对象中的实例属性可以采用hasOwnProperty()方法,而in运算符只要对象具有这个属性(不管是在原型上还是实例上)都会返回true.因此我们可以采用以下的方法判断是否是原型上的属性:

function hasPrototypeProperty(object, name) {
    return !object.hasOwnProperty(name) && (name in object);
}

在实际的应用中我们往往是混合采用原型模式和构造函数模式.在构造函数中保存私有属性,而将共同的属性和方法放在原型中.

function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
}

Person.prototype = {
    constructor: Person,
    sayHello: function() {
        console.log(this.name);
    }
}

动态原型

这种方式将所有信息都封装在了构造函数中,而通过在构造函数中初始化原型(仅在必要的情况下),又保持了同时使用构造函数和原型的优点。换句话说,可以通过检查某个应该存在的方法是否有效,来决定是否需要初始化原型。

function Person(name, age, sex) {
    // attrs
    this.name = name;
    this.age = age;
    this.sex = sex;

    // method
    if (typeof this.sayHello != 'function') {
        Person.prototype = function() {
            console.log(this.name);
        }
    }
}

这里只在sayHello()方法不存在的情况下,才会将它添加到原型中。这段代码只会在初次调用构造函数时才会执行。此后,原型已经完成初始化,不需要再做什么修改了。不过要记住,这里对原型所做的修改,能够立即在所有实例中得到反映。因此,这种方法确实可以说非常完美。