学习笔记 javascript 面向对象
写这篇笔记，是阅读了以下这个系列三个网页，想摘录一些东西，以后也方便回忆。
作者由浅入深，娓娓道来，讲的很透彻。文中讲了很多种javascript实现面向对象的方法，和各自的优劣。我只记录作者认为最好的，和我认为最常见的。
在开始之前，有一些heads up。
- JS本身是不支持OO的，但是运用其自身的各种特性，仍然能实现类的封装和继承，这是OO的精华部分
- JS中所有物件都是对象
- function定义的函数是Function类的对象
- 字典是Object类的对象
- 数组是Array类的对象
- 简单变量是Number类对象
1.function Cat(name,color){
2. this.name = name;
3. this.color = color;
4.}
5.
6.Cat.prototype.type = "猫科动物";
7.Cat.prototype.eat = function(){alert("吃老鼠")};
8.
9.var cat1 = new Cat("大毛","黄色");
10.var cat2 = new Cat("二毛","黑色");
11.
12.alert(cat1.type); // 猫科动物
13.cat1.eat(); // 吃老鼠
每个函数都有一个prototype上，每个prototype指向另一个对象。不变的属性，方法可以定义在这个prototype上，从而达到减少重复，节省内存的作用。
express中的model定义就是用的这种方式。
继承有两种，通过构造函数继承和通过对象拷贝继承。javascript是面向函数编程，这个函数对于类定义来说其实就是构造函数。上面讲的prototype就有点继承的意思了。但我们的prototype并没有一个函数与之对应，即没有构造函数，所以它不能称其类，也没法实例化。所以不能称其为继承。
1.function Animal(){
2. this.species = "动物";
3.}
4.Cat.prototype = new Animal();
5.Cat.prototype.constructor = Cat;
6.var cat1 = new Cat("大毛","黄色");
7.alert(cat1.species); // 动物
这样就是真正的继承了，Cat继承自Animal。这里有一个小把戏：Cat.prototype.constructor = Cat;
这里牵涉到一个很饶人的小问题，也是很多人在讨论的，也是jsoo躲不开的问题，就是：
constructor的作用到底是什么？
首先，在js中，所有的物件皆为对象。
其次每一个对象都有他的构造函数，由object.constructor指明。
最后，所有object.constructor均等于object.prototype.constructor。看下面的REPL的代码：
1.> function Cat(){}
2.> function Animal(){}
3.> Cat.prototype=new Animal
4.> cat = new Cat()
5.Animal {} // 看这里的结果
6.> cat.constructor===Animal // 再看这一行
7.true
8.> Cat.constructor === Function
9.true
可见，如果修改了类的prototype，它自己对象的constructor就会指向其他的地方。问题来了：
这么做有什么问题呢？
这让我百思不得其解。引用知乎上一个回答：
constructor属性不影响任何JavaScript的内部属性。instanceof检测对象的原型链，通常你是无法修改的（不过某些引擎通过私有的proto属性暴露出来）。
constructor其实没有什么用处，只是JavaScript语言设计的历史遗留物。由于constructor属性是可以变更的，所以未必真的指向对象的构造函数，只是一个提示。不过，从编程习惯上，我们应该尽量让对象的constructor指向其构造函数，以维持这个惯例。
用instanceof看不出什么差别，可能也印证了这位知乎大牛的观点。
1.> cat = new Cat()
2.Animal {}
3.> cat instanceof Cat
4.true
5.> cat instanceof Animal
6.true
7.> Cat.prototype.constructor=Cat
8.[Function: Cat]
9.> cat=new Cat()
10.Cat {}
11.> cat instanceof Cat
12.true
13.> cat instanceof Animal
14.true
再回到我们之前的例子Cat.prototype = new Animal();这一句也隐含的做了Cat.prototype.constructor = Animal。导致cat.constructor === Cat.prototype.constructor
看起来有点乱，cat看起来是由Animal来构造的了。
我的理解是：
一般使用不会有问题，当在一些高级应用场合，要用到反射的时候，如果constructor设置不对会引起不必要的麻烦。
根据prototype继承的方法，Javascript面向对象编程（二）：构造函数的继承又提出了两种改进型的继承方法，分别是
类的prototype是这个类稳定的部分，当我们想继承的时候，其实就是想继承类中稳定的部分。所以这个方法就是直接继承父类的prototype：
1.function Animal(){
2. this.species = "动物";
3.}
4.Cat.prototype = Aninal.prototype;
5.Cat.prototype.constructor = Cat;
虽然听起来有理，不过真的这么做还是挺奇怪的。子类和父类的prototype指向了同一个对象(JSOO中，万物皆对象，和C++/Java中的对象概念有稍许区别)。
而对Cat.prototype.constructor的修改直接影响了Animal.constructor。
结论就是这个方法不好，不能用。
1.var F = function(){};
2.F.prototype = Animal.prototype;
3.Cat.prototype = new F();
4.Cat.prototype.constructor = Cat;
这样的做法隔离了父类和子类。
- 优点是节省内存
- 因为F是空函数，定义Cat.prototype的时候，new的是F比new一个Animal肯定是要节省内存的。
- 缺点是不太直观。
不过据说有些JS库（YUI）的OO就是用的这种模式。
使用方法：
1.function extend(Child, Parent) {
2. var F = function(){};
3. F.prototype = Parent.prototype;
4. Child.prototype = new F();
5. Child.prototype.constructor = Child;
6. Child.uber = Parent.prototype;
7.}
8.
9.extend(Cat,Animal);
10.var cat1 = new Cat("大毛","黄色");
11.alert(cat1.species); // 动物
这里用到了一个类的uber属性。这是什么？
意思是为子对象设一个uber属性，这个属性直接指向父对象的prototype属性。（uber是一个德语词，意思是”向上”、”上一层”。）这等于在子对象上打开一条通道，可以直接调用父对象的方法。这一行放在这里，只是为了实现继承的完备性，纯属备用性质。
我的理解，给子类能访问父类函数的机会。为什么叫uber，我觉得应该是约定俗成的。
1.> function Cat2(){}
2.> 'uber' in Cat2
3.false
4.>
最后还有一个另类，通过在构造函数里面拷贝父类的属性达到继承的效果，这个和后一章的继承方法有异曲同工之效。区别是这里是在构造函数里做拷贝。
1.function extend2(Child, Parent) {
2. var p = Parent.prototype;
3. var c = Child.prototype;
4. for (var i in p) {
5. c[i] = p[i];
6. }
7. c.uber = p;
8.}
9.
10.extend2(Cat, Animal);
11.var cat1 = new Cat("大毛","黄色");
12.alert(cat1.species); // 动物
注意Javascript面向对象编程（二）：构造函数的继承中虽然没有提到，但这里仍然会有深拷贝，浅拷贝的问题。
这里解决的问题，和标准的OO处理的问题不同。这里要处理的问题，是让两个普通对象之间有继承关系：
1.var Chinese = {
2. nation:'中国'
3.};
4.var Doctor ={
5. career:'医生'
6.}
注意这里都是普通的字典类型对象，并不像前一章说的是用function构造出来的类，再用new构造的对象。
现在要解决的问题，是’中国医生’要如何定义。这里很容易想到就是把Chinese里面的属性拷给Doctor就好了嘛。那这一章讲的就是这个内容。
1.function object(o) {
2. function F() {}
3. F.prototype = o;
4. return new F();
5.}
6.
7.var Doctor = object(Chinese);
8.Doctor.career = '医生';
9.alert(Doctor.nation); //中国
根据上一章我们讲的构造函数的知识，可以知道：
- Doctor是F类的对象
- F类通过prototype继承了Chinese对象
- 有下面的等式
1.> Doctor.constructor === Chinese.constructor
2.true
Doctor是F类的对象，F类的prototype是Chinese对象，Doctor的constructor指向他原型的contructor。
非要和构造函数扯上关系，是想对上一章的知识活学活用。作者把这个方法列在这里的用意，其实是这里的方法跟构造函数，constructor没半毛钱关系。只是单纯的将Chinese通过prototype传给Doctor。
后面的方法就从形式上也和构造函数也没半毛钱关系了。
其实拷贝对于解决这个问题，本身就是最直觉的方案。直接看code：
1.function deepCopy(p, c) {
2. var c = c || {};
3. for (var i in p) {
4. if (typeof p[i] === 'object') {
5. c[i] = (p[i].constructor === Array) ? [] : {};
6. deepCopy(p[i], c[i]);
7. } else {
8. c[i] = p[i];
9. }
10. }
11. return c;
12.}
13.var Doctor = deepCopy(Chinese);
要用深拷贝的原因是Chinese对象内部可能有成员的值是数组或其他对象。jQuery库用的就是这种继承方法。