基于ECMAScript5的继承链实现，跟原型链继承说拜拜

记得以前写过一篇基于javascript function的类继承链实现。在ECMAScript3.1中，可以把function模拟成类。但是，因为原型链，构造体的实现非常繁琐。

现在各大浏览器升级到ECMAScript5之后，逐渐抛弃了以function来模拟类的思路。而转变为以对象来模拟类的思路。即：

var Cat = {};

 以上的代码，可以看成是一个对象，也可以看成是一个类。当然像现在流行的静态语言中，比如java，Class本身就是对象。(究竟是先有对象还是先有类这样究竟是鸡生蛋还是蛋生鸡这样的哲学问题这里不加以讨论)

由此，新的Class函数如下：

var Class = (function() {

		/**
		 * Initialze object from class.
		 * @param class object.
		 */
		var initializeClass = (function() {
			if (Object.create) {
				return Object.create;
			} else {
				return function(o) {
					function F() {}  
			        F.prototype = o;  
			        return new F();
				};
			}
		})();

		/**
		 * The main function of Class.
		 * 
		 * @param classContent
		 * @param superClass
		 */
		return function() {

			var classPrototype = arguments[arguments.length - 1] || {};

			for (var index = 0; index < arguments.length - 1; index++) {

				var superClass = arguments[index];
				
				if (typeof superClass["initialize"] == "function") {
					classPrototype.superclass = superClass["initialize"];
				} else {
					classPrototype.superclass = function() {};
				}
				
				for (var prop in superClass) {

					if (prop == "initialize" || prop == "newInstance") {
						continue;
					}
					
					if (classPrototype.hasOwnProperty(prop)) {
						if (typeof superClass[prop] == "function") {
							classPrototype.superclass[prop] = superClass[prop];
						}
					} else {
						classPrototype[prop] = superClass[prop];
					}
				}
			}
			classPrototype.newInstance = function() {
				var instance = initializeClass(this);
				if (instance["initialize"]) {
					instance["initialize"].apply(instance, arguments);
				}
				return instance;
			};
			return classPrototype;
		};
	})();

大致功能为为对象增加getInstance方法和父类的superclass对象使其能够调用父类的构造体和方法。

测试：

	var Animal = Class({
		initialize: function(age) {
			this.age = age;
		},
		eat: function() {
			alert("eat");
		}
	});

	var Cat = Class(Animal, {
		initialize: function(name, age) {

			// 调用父类构造体
			Cat.superclass.call(this, age);

			// 本类属性
			this.name = name;

			// 调用父类方法
			this.superclass.eat();
		},
		eat: function() {
			alert("eat fish");
		}
	});
	var animal = Animal.newInstance(12);
	animal.eat();
	var cat = Cat.newInstance("123", 12);
	alert(cat.name);
	alert(cat.age);
	cat.eat();

此方式注意点：

1.无法完全使用instanceof 来模糊判断是何种类型(判断父类)。但是可以用isPrototypeOf来精确判断是何种子类

2.无需使用关键字new来实例化对象。。而要用newInstance方法。(废话)

大家可以比较下我以前的那篇文章，会发现，继承的实现不是简单了一点半点。

至于instanceof的判断限制问题，大家完全可以不用担心

例如下面的java代码，instanceof用来判断何种接口，然后判断完后无非为了调用接口的方法。

public interface Animal {
}

public interface Cat extends Animal {
     void eatFish()；
}

public interface Dog extends Animal {
     void eatFood（）；
}


public class Test {
     public void animalExecute(Animal animal) {
          if (animal instanceof Cat) {
                (（Cat） animal).eatFish();
          } else if (animal instanceof Dog) {
                (（Cat） animal).eatFood();
          }
     }
}

而javascript在没有instanceof的情况下，代码可以这么实现

var Animal = Class({});

var Dog = Class(Animal, {
       eatFood: function() {};
})

var Cat = Class(Animal, {
       eatFish: function() {};
})

function animalExecute(animal) {
       
       if (animal.eatFood) {// Dog
              animal.eatFood();
       } else if (animal.eatFish) {// Cat
              animal.eatFish();
       }
}

 也就是说，javascript完全无需instanceof，也能完成相同功能

var Animal = Class({});

var Dog = Class(Animal, {
       eatFood: function() {};
})

var Cat = Class(Animal, {
       eatFish: function() {};
})

function animalExecute(animal) {
       
       if (animal.eatFood) {// Dog
              animal.eatFood();
       } else if (animal.eatFish) {// Cat
              animal.eatFish();
       }
}

var Animal = Class({
       eat: function() {
              throw new Error('interface...');
       };
});

var Dog = Class(Animal, {
       eat: function() {
              return 'dog eating food';
       };
})

var Cat = Class(Animal, {
       eat: function() {
              return 'cat eating fish';
       };
})

function animalExecute(animal) {
       
       // 接口检查
       //Interface.ensureImplements(animal, Animal);
       animal.eat();
}