谈谈 Object.create ，JS的原型继承

谈到Object.create ，那就说说大家常用的原型继承这一块。

所谓继承：我理解的是子类继承了父类。当父类发生了变化，遗传了它基因的子类会有影响。相反它的子类发生了变化，不会影响到父类

ecmascript 5.1 开始 Object 对象添加了create 方法 。 官方描述是:创建一个具有指定原型且可选择性地包含指定属性的对象。

Object.create 其实只是创建了一个函数，再把属性赋给函数原型，再通过new 创建一个新的function 对象.这样它的指针，指向的是函数。而不是且继承的属性。当对象发生变化不会影响继承的属性

Object.create 兼容性写法是:

if (typeof Object.create !== 'function') {

Object.create = function(o) {

function F() { }

F.prototype = o;

return new F();

};

}

不正确的写法:

var parent=function(){} parent.prototype.age=18; var child=function(){} child.prototype=parent.prototype;(这样的话，当child 变化了，会直接影响parent的原型，并且会导致所有继承parent 类的子类)

不正确的写法（误区），那就是原型扩展（这样可以把某个对象的属性或方法，扩展到目标对象上。但是并非真正的继承）

通过一些比如：jquery、zepto 或underscore 的 extend 方法，复制父类属性 对prototype 进行延伸扩展.

一般继承一个父类的写法:

var parent=function(){} parent.prototype.age=18; var child=function(){} child.prototype=Object.crate(parent.prototype);

这样的写法有什么好处呢?它可以创建一个干净 的原型继承模式。

假始我们改变child.prototype的属性或方法。它也不会直接影响它的父类.相反它的父类变化了，它会有影响。

child.prototype.age=80 .

当child 继承了parent ，但它还想扩展其它属性或方法。并且有些属性覆盖它原有继承的属性。但有时候又想使用它父类的属性或方法

这里有三种方法，调用之后。会返回: {age: 18}

child.prototype.__proto__ ecm6 出现的

child.prototype.constructor.prototype

Object.getPrototypeOf(a.prototype) ecm 6 出现的，推荐
使用

最后推荐 几个比较常用的extend 方法，kendo.js 和backbone.js 的继承扩展方法

使用方法：当我需要继承Class 。var childClass=Class.extend({desc:"我的class 的子类"});

var childClass2=childClass.extend({desc:"我是childClass的子类，Class
是我爷爷"})

childClass2 会继承childClass 和Class 的属性和方法

kendo.js 是这样写的,它做了深度复制。

function Class() {}

Class.extend = function(proto) {

var base = function() {},

member,

that = this,

subclass = proto && proto.init ? proto.init : function () {

that.apply(this, arguments);

},

fn;

base.prototype = that.prototype;

fn = subclass.fn = subclass.prototype = new base();

for (member in proto) {

if (typeof proto[member] === OBJECT && !(proto[member] instanceof Array) && proto[member] !== null) {

// Merge object members

fn[member] = extend(true, {}, base.prototype[member], proto[member]);

} else {

fn[member] = proto[member];

}

}

fn.constructor = subclass;

subclass.extend = that.extend;

return subclass;

};

backbone.js

var extend = function(protoProps, staticProps) {

var parent = this;

var child;

// The constructor function for the new subclass is either defined by you

// (the "constructor" property in your `extend` definition), or defaulted

// by us to simply call the parent's constructor.

if (protoProps && _.has(protoProps, 'constructor')) {

child = protoProps.constructor;

} else {

child = function(){ return parent.apply(this, arguments); };

}

// Add static properties to the constructor function, if supplied.

_.extend(child, parent, staticProps);

// Set the prototype chain to inherit from `parent`, without calling

// `parent`'s constructor function.

var Surrogate = function(){ this.constructor = child; };

Surrogate.prototype = parent.prototype;

child.prototype = new Surrogate;

// Add prototype properties (instance properties) to the subclass,

// if supplied.

if (protoProps) _.extend(child.prototype, protoProps);

// Set a convenience property in case the parent's prototype is needed

// later.

child.__super__ = parent.prototype;

return child;

};