javaScript的原型继承

Javascript是一门面向对象的语言。在JavaScript中有一句很经典的话，万物皆对象。既然是面向对象的，那就有面向对象的三大特征：封装、继承、多态。这里讲的是JavaScript的继承，其他两个容后再讲。

JavaScript的继承和C++的继承不大一样，C++的继承是基于类的，而JavaScript的继承是基于原型的。

现在问题来了。

原型是什么？

function Animal(name) {    this.name = name;}Animal.PRototype.setName = function(name) {    this.name = name;}var animal = new Animal("wangwang");

function Animal(name) {    this.name = name;}var animal = new Animal("wangwang");

Animal.prototype.setName = function(name) {    this.name = name;}

继承本复制——从空的对象开始

方法一：构造复制

方法二：写时复制

方法三：读遍历

1. 保证在读取时首先被访问到
2. 如果在对象中没有指定属性，则尝试遍历对象的整个原型链，直到原型为空或或找到该属性。

constructor

var animal = Animal("wangwang");

function Animal(name) {    this.name = name;    return this;}

function Animal(name) {    if(!(this instanceof Animal)) {        return new Animal(name);     }    this.name = name;}

console.log(Animal.prototype.constructor === Animal); // true

// 设定__proto__是函数内置的成员，get_prototyoe()是它的方法var __proto__ = null;function get_prototype() {    if(!__proto__) {        __proto__ = new Object();        __proto__.constructor = this;    }    return __proto__;}

基于原型的继承

1. 方法一

function Animal(name) {    this.name = name;}function Dog(age) {    this.age = age;}var dog = new Dog(2);

Dog.prototype = new Animal("wangwang");

console.log(dog instanceof Animal); // trueconsole.log(dog instanceof Dog); // false

console.log(Dog.prototype.constructor === Animal); // trueconsole.log(Dog.prototype.constructor === Dog); // false

Dog.prototype.constructor = Dog;

console.log(dog instanceof Animal); // falseconsole.log(dog instanceof Dog); // true

2. 方法二

<pre name="code" class="javascript">function Animal(name) {    this.name = name;}Animal.prototype.setName = function(name) {    this.name = name;}function Dog(age) {    this.age = age;}Dog.prototype = Animal.prototype;

原型链

function Animal(name) {    this.name = name;}function Dog(age) {    this.age = age;}var animal = new Animal("wangwang");Dog.prototype = animal;var dog = new Dog(2);

我们可以看到，子对象的prototype指向父对象的实例，构成了构造器原型链。子实例的内部proto对象也是指向父对象的实例，构成了内部原型链。当我们需要寻找某个属性的时候，代码类似于

function getAttrFromObj(attr, obj) {    if(typeof(obj) === "object") {        var proto = obj;        while(proto) {            if(proto.hasOwnProperty(attr)) {                return proto[attr];            }            proto = proto.__proto__;        }    }    return undefined;}

在这个例子中，我们如果在dog中查找name属性，它将在dog中的成员列表中寻找，当然，会找不到，因为现在dog的成员列表只有age这一项。接着它会顺着原型链，即.proto指向的实例继续寻找，即animal中，找到了name属性，并将之返回。假如寻找的是一个不存在的属性，在animal中寻找不到时，它会继续顺着.proto寻找，找到了空的对象，找不到之后继续顺着.proto寻找，而空的对象的.proto指向null，寻找退出。

原型链的维护

(new obj()).prototype.constructor === obj; 

Dog.prototype = new Animal("wangwang");Dog.prototype.constructor = Dog;

1. __proto__是可以重写的，这意味着使用它时仍然有风险
2. __proto__是spiderMonkey的特殊处理，在别的引擎（例如JScript）中是无法使用的。

function Dog(age) {    this.constructor = arguments.callee;    this.age = age;}Dog.prototype = new Animal("wangwang");

function getAttrFromObj(attr, obj) {  if(typeof(obj) === "object") {    do {      var proto = Object.getPrototypeOf(dog);      if(proto[attr]) {        return proto[attr];      }    }    while(proto);  }  return undefined;}