JavaScript类的继承操作实例总结

本文实例总结了javascript类的继承操作。分享给大家供大家参考，具体如下：

一、类式继承

首先要做的是创建构造函数。按惯例，其名称就是类名，首字母应该大写。在构造函数中，创建实例属性要用关键字this 。类的方法则被添加到prototype对象中。要创建该类的实例，只需结合关键字new调用这构造函数即可。

/* class person. */
function person(name) {
 this.name = name;
}
person.prototype.getname = function() {
 return this.name;
}
var reader = new person('john smith');
reader.getname();

二、原型链

javascript的每个对象都有一个名为prototype的属性，这个属性要么指向另一个对象，要么是null.在访问对象的某个成员时，如果这个成员未见于当前对象，那么就会到prototype所指的对象中去查找。如果还是没有找到，那么就会沿着原型链逐一访问每个原型对象，直到找到这个成员。这意味着让一个类继承另一个类，只需将子类的prototype设置为超类的一个实例即可。

为了让author继承person，必须手工将author的prototype设置为person的一个实例。最后一步是将prototype的construct属性重设为author(因为prototype属性设置为person的实例)时，其construct属性被抹除了。

function author(name, books) {
 person.call(this, name); // call the superclass' constructor in the scope of this.
 this.books = books; // add an attribute to author.
}
author.prototype = new person(); // set up the prototype chain.
author.prototype.constructor = author; // set the constructor attribute to author.
author.prototype.getbooks = function() { // add a method to author.
 return this.books;
};
var author = [];
author[0] = new author('dustin diaz', ['javascript design patterns']);
author[1] = new author('ross harmes', ['javascript design patterns']);
console.log(author[1].getname());
console.log(author[1].getbooks());

三、extend函数

为了简化类的声明，可以把派生子类的整个过程包装在一个名为extend的函数中。它的作用与其他语言的extend关键字类似，即基于一个给定的类的结构创建一个新的类：

function extend(subclass, superclass) {
 var f = function() {};
 f.prototype = superclass.prototype;
 subclass.prototype = new f();
 subclass.prototype.constructor = subclass;
}

其实所做的事与之前的是一样的。它先设置了prototype，然后再将其constructor重设为恰当的值。并且中间利用了一个空函数，这样就可以避免创建超类的实例。使用extend继承的写法：

function person(name) {
 this.name = name;
}
person.prototype.getname = function() {
 return this.name;
}
/* class author. */
function author(name, books) {
 person.call(this, name);
 this.books = books;
}
extend(author, person);
author.prototype.getbooks = function() {
 return this.books;
};

但上面的存在一个问题就是超类person的名称被固化在author类的声明当中。更普世性的做法应该像下面这样：

/* extend function, improved. */
function extend(subclass, superclass) {
 var f = function() {};
 f.prototype = superclass.prototype;
 subclass.prototype = new f();
 subclass.prototype.constructor = subclass;
 subclass.superclass = superclass.prototype;
 if(superclass.prototype.constructor == object.prototype.constructor) {
  superclass.prototype.constructor = superclass;
 }
}
/* class author. */
function author(name, books) {
 author.superclass.constructor.call(this, name);
 this.books = books;
}
extend(author, person);
author.prototype.getbooks = function() {
 return this.books;
};
author.prototype.getname = function() {
 var name = author.superclass.getname.call(this);
 return name + ', author of ' + this.getbooks().join(', ');
};

这个extend改进之后，多了一个superclass的属性，这个属性可以弱化author和person之间的耦合。extend后面三行用来确保超类的construtor已经被正确设置了。有了superclass的属性，就可以直接调用超类中的方法。这在既要重新定义超类的某个方法而又想访问其在超类中的实现时可以派上用场。例如，为了用一个新的getname的方法重新定义person类中的同名方法，你可以先用author.superclass.getname获得作者的名字，然后再次基础上添加新的信息。

四、原型继承

原型式继承与类式继承截然不同，我们在学习他的时候，最好忘记自己关于类和实例的一切知识，只从对象的角度来思考。使用原型式继承时，并不需要用类来定义对象的结构，只需直接创建一个对像就可以。这个对象随后可以被新的对象使用，该对象被称为原型对象。

下面使用原型对象来重新设计上面person和author：

var person = {
 name: 'default name',
 getname: function() {
  return this.name;
 }
};
var reader = clone(person);
alert(reader.getname()); // this will output 'default name'.
reader.name = 'john smith';
alert(reader.getname()); // this will now output 'john smith'.

clone函数可以用来创建新的类person对象，创建一个空对象，并且该对象的原型对象被设置为person。当新对象中找不到某个方法时就会在原型对象中查找。

你不必去为了创建author而定义一个person子类，只要执行一次克隆就可以：

var author = clone(person);
author.books = []; // default value.
author.getbooks = function() {
 return this.books;
}

然后你可以重定义该克隆中的方法和属性。可以修改person的默认值。也可以添加新的属性和方法。这样一来就创建了一个新的原型对象，你可以将其用于创建新的author对象：

var author = [];
author[0] = clone(author);
author[0].name = 'dustin diaz';
author[0].books = ['javascript design patterns'];
author[1] = clone(author);
author[1].name = 'ross harmes';
author[1].books = ['javascript design patterns'];
author[1].getname();
author[1].getbooks();

clone函数的写法：

function clone(object) {
  function f() {}
  f.prototype = object;
  return new f;
}

五、原型继承和类式继承之间的比较

可以自己去总结、
从内存，适用范围，优缺点等方面去分析

六、掺元类

有一种重用代码的方法不需要用到严格的继承，如果想把一个函数运用到多个类当中，可以通过扩充的方法让这些类共享函数。其实际大体做法就是：先创建一个包含各种通用的方法类，然后再扩充其他类，这种包含通用方法类称为掺元类，他们通常不会被实例化和直接调用，其存在的目的是向其他类提供自己的方法。

var mixin = function() {};
mixin.prototype = {
 serialize: function() {
  var output = [];
  for(key in this) {
   output.push(key + ': ' + this[key]);
  }
  return output.join(', ');
 }
};
augment(author, mixin);
var author = new author('ross harmes', ['javascript design patterns']);
var serializedstring = author.serialize();
function augment(receivingclass, givingclass) {
 for(methodname in givingclass.prototype) {
  if(!receivingclass.prototype[methodname]) {
   receivingclass.prototype[methodname] = givingclass.prototype[methodname];
  }
 }
}

但是有时候你并不需要所有的方法，因此我们还需要提供额外的参数来选择我们所需要的方法。如果不提供，那就全部复制。

function augment(receivingclass, givingclass) {
 if(arguments[2]) { // only give certain methods.
  for(var i = 2, len = arguments.length; i < len; i++) {
   receivingclass.prototype[arguments[i]] = givingclass.prototype[arguments[i]];
  }
 }
 else { // give all methods.
  for(methodname in givingclass.prototype) {
   if(!receivingclass.prototype[methodname]) {
    receivingclass.prototype[methodname] = givingclass.prototype[methodname];
   }
  }
 }
}

更多关于javascript相关内容还可查看本站专题：《javascript面向对象入门教程》、《javascript错误与调试技巧总结》、《javascript数据结构与算法技巧总结》、《javascript遍历算法与技巧总结》及《javascript数学运算用法总结》

希望本文所述对大家javascript程序设计有所帮助。