JS原型和原型链

原型使用方式1

个人理解，之前写JS都是这样:

var decimalDigits = 2,
            tax = 5;

        function add(x, y) {
            return x + y;
        }

        function subtract(x, y) {
            return x - y;
        }

        //alert(add(1, 3));

但是，这个并不能体现OOP思想，看了原型与原型链之后觉得OOP一目了然:

  var Calculator = function (decimalDigits, tax) {
             this.decimalDigits = decimalDigits;
            this.tax = tax;
          };

然后给Calculator的prototype属性赋值对象字面量来设定Calculator对象的原型。(个人觉得这里的原型就如同C#中类的概念,prototype则是用来给类添加属性，方法的)

Calculator.prototype = {
            add: function (x, y) {
                return x + y;
            },

            subtract: function (x, y) {
                return x - y;
            }
        };
        //alert((new Calculator()).add(1, 3));

样，通过new 一个对象就可以调用里面的公开的方法，属性。

原型使用方式2

当我们把一堆方法写到Calculator中，但是有些方法我们不想对外公开，即实现public/private，那么我们只能返回公开的方法:

var Calculaotr = function(x, y) {
    this.x = x;
    this.y = y;
};
Calculaotr.prototype = function() {
    add= function (x,y) {
        return x + y;
    },
    subtract=function (x,y) {
        return x - y;
    }
    return {
        A:add,
        S:subtract
    } 
}();

这里用利用函数自执行在加载文件同时，执行上面的JS代码，那么我们就可以访问对外公开的方法和属性，如果不通过自执行，则会报异常:

在C#中，我们可能会遇到这样的情况，类A的一个属性是类B型，在JS中，可以通过以下方式实现:

var BaseCalculator = function() {
    this.decimalDigits = 2;
};
BaseCalculator.prototype = {
    A: function(x, y) {
        return x + y;
    },
    S: function(x, y) {
        return x - y;
    }
};
var Calculator = function() {
    this.tax = 3;
};
15Calculator.prototype = new BaseCalculator();

这里我们可以看到Calculator的原型是指向到BaseCalculator的一个实例上，目的是让Calculator集成它的add(x,y)和subtract(x,y)这2个function，

还有一点要说的是，由于它的原型是BaseCalculator的一个实例，所以不管你创建多少个Calculator对象实例，他们的原型指向的都是同一个实例。

如果我们不想让Calculator对象访问BaseCalculator的decimalDigits属性，可以这样:

var BaseCalculator = function() {
    this.decimalDigits = 2;
};
BaseCalculator.prototype = {
    A: function(x, y) {
        return x + y;
    },
    S: function(x, y) {
        return x - y;
    }
};
var Calculator = function() {
    this.tax = 3;
};
Calculator.prototype =new prototype;

通过以上两种原型使用方式，结合C#中的继承，不难想到JS中如何重写原型。

重写原型:
在项目中，引入外部JS库，但是有些方法并不是我们想要的，此时我们通过重写原型，就可以达到我们想要的结果:

//重写原型
Calculaotor.prototype.add = function(x, y) {
    return x + y + this.tax;
}

原型链

function Foo() {
    this.value = 42;
}
Foo.prototype = {
    method: function() {}
};

function Bar() {}

// 设置Bar的prototype属性为Foo的实例对象
Bar.prototype = new Foo();
Bar.prototype.foo = 'Hello World';

// 修正Bar.prototype.constructor为Bar本身
Bar.prototype.constructor = Bar;

var test = new Bar() // 创建Bar的一个新实例

// 原型链
test [Bar的实例]
    Bar.prototype [Foo的实例] 
        { foo: 'Hello World' }
        Foo.prototype
            {method: ...};
            Object.prototype
                {toString: ... /* etc. */};

上面的例子中，test对象从Bar.prototype和Foo.prototype继承下来；因此，它能访问Foo的原型方法method。同时，它也能够访问那个定义在原型上的Foo实例属性value。需要注意的是new Bar()不会创造出一个新的Foo实例，而是重复使用它原型上的那个实例；因此，所有的Bar实例都会共享相同的value属性。

属性查找

当查找一个对象的属性时，会遍历原型链，一直往顶层Object找，如果没有找到，则返回undefined.

function foo() {
            this.add = function (x, y) {
                return x + y;
            }
        }

        foo.prototype.add = function (x, y) {
            return x + y + 10;
        }

        Object.prototype.subtract = function (x, y) {
            return x - y;
        }

        var f = new foo();
        alert(f.add(1, 2)); //结果是3，而不是13
        alert(f.subtract(1, 2)); //结果是-1

以上add函数返回的是3，而不是13则说明，属性查找时，优先查找自己的属性。然后在往上一级找，最后找Object，这样看来，在遍历时用for in效率就是个问题。

还有一点，我们可以赋值任何类型的对象到原型上，但是不能赋值原子类型的值，比如如下代码是无效的：

function Foo() {}
Foo.prototype = 1; // 无效

hasOwnProperty函数

hasOwnProperty是判断一个对象是否包含自定义属性而不是原型链上的属性，是JS中唯一一个查找属性，但不查找原型链的函数。

但是JS不会保护hasOwnProperty函数，如果刚好某个对象中也有hasOwnProperty函数，则我们可以通过以下方式正确获得想要的结果:

alert({}.hasOwnProperty.call(c, 'tax'));//返回true

这里的c是Calculator的一个对象,tax是我们要找的属性。

当我面在for in loop 语句中查找属性时，用hasOwnProperty函数，提高效率:

Object.prototype.bar = 1;
    var foo={moo : 1}
    for (var i in foo) {
        if(foo.hasOwnProperty(i)) {
            alert(console.log(i));
        } 
    }//此时只会输出moo属性

原文地址:http://www.cnblogs.com/TomXu/archive/2012/01/05/2305453.html