1 var decimalDigits = 2,
2 tax = 5;
3
4 function add(x, y) {
5 return x + y;
6 }
7
8 function subtract(x, y) {
9 return x - y;
10 }
11
12 //alert(add(1, 3));
但是，这个并不能体现OOP思想，看了原型与原型链之后觉得OOP一目了然:
1 var Calculator = function (decimalDigits, tax) {
2 this.decimalDigits = decimalDigits;
3 this.tax = tax;
4 };
然后给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，那么我们只能返回公开的方法:
1 var Calculaotr = function(x, y) {
2 this.x = x;
3 this.y = y;
4 };
5 Calculaotr.prototype = function() {
6 add= function (x,y) {
7 return x + y;
8 },
9 subtract=function (x,y) {
10 return x - y;
11 }
12 return {
13 A:add,
14 S:subtract
15 }
16 }();
这里用利用函数自执行在加载文件同时，执行上面的JS代码，那么我们就可以访问对外公开的方法和属性，如果不通过自执行，则会报异常:
在C#中，我们可能会遇到这样的情况，类A的一个属性是类B型，在JS中，可以通过以下方式实现:
1 var BaseCalculator = function() {
2 this.decimalDigits = 2;
3 };
4 BaseCalculator.prototype = {
5 A: function(x, y) {
6 return x + y;
7 },
8 S: function(x, y) {
9 return x - y;
10 }
11 };
12 var Calculator = function() {
13 this.tax = 3;
14 };
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;
}
原型链
1 function Foo() {
2 this.value = 42;
3 }
4 Foo.prototype = {
5 method: function() {}
6 };
7
8 function Bar() {}
9
10 // 设置Bar的prototype属性为Foo的实例对象
11 Bar.prototype = new Foo();
12 Bar.prototype.foo = 'Hello World';
13
14 // 修正Bar.prototype.constructor为Bar本身
15 Bar.prototype.constructor = Bar;
16
17 var test = new Bar() // 创建Bar的一个新实例
18
19 // 原型链
20 test [Bar的实例]
21 Bar.prototype [Foo的实例]
22 { foo: 'Hello World' }
23 Foo.prototype
24 {method: ...};
25 Object.prototype
26 {toString: ... /* etc. */};
上面的例子中，test 对象从 Bar.prototype 和 Foo.prototype 继承下来；因此，它能访问 Foo 的原型方法 method。同时，它也能够访问那个定义在原型上的 Foo 实例属性 value。需要注意的是 new Bar() 不会创造出一个新的 Foo 实例，而是重复使用它原型上的那个实例；因此，所有的 Bar 实例都会共享相同的 value 属性。
属性查找
当查找一个对象的属性时，会遍历原型链，一直往顶层Object找，如果没有找到，则返回undefined.
1 function foo() {
2 this.add = function (x, y) {
3 return x + y;
4 }
5 }
6
7 foo.prototype.add = function (x, y) {
8 return x + y + 10;
9 }
10
11 Object.prototype.subtract = function (x, y) {
12 return x - y;
13 }
14
15 var f = new foo();
16 alert(f.add(1, 2)); //结果是3，而不是13
17 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函数，提高效率:
1 Object.prototype.bar = 1;
2 var foo={moo : 1}
3 for (var i in foo) {
4 if(foo.hasOwnProperty(i)) {
5 alert(console.log(i));
6 }
7 }//此时只会输出moo属性