prototype

JS中的phototype是JS中比较难理解的一个部分

 

本文基于下面几个知识点:

 

1 原型法设计模式

在.Net中可以使用clone()来实现原型法

原型法的主要思想是，现在有1个类A,我想要创建一个类B,这个类是以A为原型的,并且能进行扩展。我们称B的原型为A。

 

2 javascript的方法可以分为三类：

a 类方法

b 对象方法

c 原型方法

例子：

function  People(name)
{
  this .name = name;
  // 对象方法
  this .Introduce = function (){
    alert( " My name is  " + this .name);
  }
}
// 类方法
People.Run = function (){
  alert( " I can run " );
}
// 原型方法
People.prototype.IntroduceChinese = function (){
  alert( " 我的名字是 " + this .name);
}

 

// 测试

var  p1 = new  People( " Windking " );

p1.Introduce();

People.Run();

p1.IntroduceChinese(); 

 

3 obj1.func.call(obj)方法

意思是将obj看成obj1,调用func方法

 

 

好了，下面一个一个问题解决：

 

prototype是什么含义？

 

javascript中的每个对象都有prototype属性，Javascript中对象的prototype属性的解释是：返回对象类型原型的引用。

A.prototype = new B();

理解prototype不应把它和继承混淆。A的prototype为B的一个实例，可以理解A将B中的方法和属性全部克隆了一遍。A能使用B的方法和属性。这里强调的是克隆而不是继承。可以出现这种情况：A的prototype是B的实例，同时B的prototype也是A的实例。

 

先看一个实验的例子：

function  baseClass()
{
  this .showMsg  =   function ()
  {
     alert( " baseClass::showMsg " );   
  }
}

function  extendClass()
{
}

extendClass.prototype  =   new  baseClass();
var instance  =   new  extendClass();
instance.showMsg();  //  显示baseClass::showMsg

我们首先定义了baseClass类，然后我们要定义extentClass，但是我们打算以baseClass的一个实例为原型，来克隆的extendClass也同时包含showMsg这个对象方法。

extendClass.prototype = new baseClass()就可以阅读为：extendClass是以baseClass的一个实例为原型克隆创建的。

 

那么就会有一个问题，如果extendClass中本身包含有一个与baseClass的方法同名的方法会怎么样？

下面是扩展实验2：

function  baseClass()
{
     this .showMsg  =   function ()
    {
        alert( " baseClass::showMsg " );   
    }
}

function  extendClass()
{
     this .showMsg  = function  ()
    {
        alert( " extendClass::showMsg " );
    }
}

extendClass.prototype  =   new  baseClass();
var instance  =   new  extendClass();

instance.showMsg(); // 显示extendClass::showMsg

 

实验证明：函数运行时会先去本体的函数中去找，如果找到则运行，找不到则去prototype中寻找函数。或者可以理解为prototype不会克隆同名函数。

 

那么又会有一个新的问题：

如果我想使用extendClass的一个实例instance调用baseClass的对象方法showMsg怎么办？

 

答案是可以使用call:

extendClass.prototype  =   new  baseClass();
var instance  =   new  extendClass();


var  baseinstance  =   new  baseClass();
baseinstance.showMsg.call(instance); // 显示baseClass::showMsg

 

这里的baseinstance.showMsg.call(instance);阅读为“将instance当做baseinstance来调用，调用它的对象方法showMsg”

好了，这里可能有人会问，为什么不用baseClass.showMsg.call(instance);

这就是对象方法和类方法的区别，我们想调用的是baseClass的对象方法

 

最后，下面这个代码如果理解清晰，那么这篇文章说的就已经理解了：

 

< script type = " text/javascript " >

function  baseClass()
{
     this .showMsg  =   function ()
    {
        alert( " baseClass::showMsg " );   
    }
   
     this .baseShowMsg  =   function ()
    {
        alert( " baseClass::baseShowMsg " );
    }
}
baseClass.showMsg  =   function ()
{
    alert( " baseClass::showMsg static " );
}

function  extendClass()
{
     this .showMsg  = function  ()
    {
        alert( " extendClass::showMsg " );
    }
}
extendClass.showMsg  =   function ()
{
    alert( " extendClass::showMsg static " )
}

extendClass.prototype  =   new  baseClass();
var instance  =   new  extendClass();

instance.showMsg();  // 显示extendClass::showMsg
instance.baseShowMsg();  // 显示baseClass::baseShowMsg
instance.showMsg();  // 显示extendClass::showMsg

baseClass.showMsg.call(instance); // 显示baseClass::showMsg static

var  baseinstance  =   new  baseClass();
baseinstance.showMsg.call(instance); // 显示baseClass::showMsg

< / script>

性能

如果一个属性在原型链的上端，则对于查找时间将带来不利影响。特别的，试图获取一个不存在的属性将会遍历整个原型链。

并且，当使用 for in 循环遍历对象的属性时，原型链上的所有属性都将被访问。

扩展内置类型的原型

一个错误特性被经常使用，那就是扩展 Object.prototype 或者其他内置类型的原型对象。

这种技术被称之为 monkey patching 并且会破坏封装。虽然它被广泛的应用到一些 JavaScript 类库中比如 Prototype, 但是我仍然不认为为内置类型添加一些非标准的函数是个好主意。

扩展内置类型的唯一理由是为了和新的 JavaScript 保持一致，比如Array.forEach。

译者注：这是编程领域常用的一种方式，称之为 Backport，也就是将新的补丁添加到老版本中。

总结

在写复杂的 JavaScript 应用之前，充分理解原型链继承的工作方式是每个 JavaScript 程序员必修的功课。 要提防原型链过长带来的性能问题，并知道如何通过缩短原型链来提高性能。 更进一步，绝对不要扩展内置类型的原型，除非是为了和新的 JavaScript 引擎兼容。

hasOwnProperty 函数

为了判断一个对象是否包含自定义属性而不是原型链上的属性， 我们需要使用继承自 Object.prototype 的 hasOwnProperty 方法。

注意: 通过判断一个属性是否undefined 是不够的。 因为一个属性可能确实存在，只不过它的值被设置为undefined。

hasOwnProperty 是 JavaScript 中唯一一个处理属性但是不查找原型链的函数。

// 修改Object.prototype
Object.prototype.bar = 1; 
var foo = {goo: undefined};

foo.bar; // 1
'bar' in foo; // true

foo.hasOwnProperty('bar'); // false
foo.hasOwnProperty('goo'); // true

只有 hasOwnProperty 可以给出正确和期望的结果，这在遍历对象的属性时会很有用。 没有其它方法可以用来排除原型链上的属性，而不是定义在对象自身上的属性。

hasOwnProperty 作为属性

JavaScript 不会保护 hasOwnProperty 被非法占用，因此如果一个对象碰巧存在这个属性， 就需要使用外部的 hasOwnProperty 函数来获取正确的结果。

var foo = {
    hasOwnProperty: function() {
        return false;
    },
    bar: 'Here be dragons'
};

foo.hasOwnProperty('bar'); // 总是返回 false

// 使用其它对象的 hasOwnProperty，并将其上下文设置为foo
({}).hasOwnProperty.call(foo, 'bar'); // true

结论

当检查对象上某个属性是否存在时，hasOwnProperty 是唯一可用的方法。 同时在使用 for in loop 遍历对象时，推荐总是使用 hasOwnProperty 方法， 这将会避免原型对象扩展带来的干扰。