架构整洁之道
各大类库的类工厂
类工厂是指用于生成类的函数，我们不能每写一个类都重复以下代码，要好好封装一下！
var F = function (){}
F.prototype = SuperClass.prototype;
SubClass.prototype = new F;
SubClass.prototype.constructor = SubClass
Prototype.js1.6之后的类工厂
var Animal = Class.create({
initialize: function (name, sound) {
this .name = name;
this .sound = sound;
},
speak: function () {
alert( this .name + " says: " + this .sound + "!" );
}
});
// subclassing Animal
var Snake = Class.create(Animal, {
initialize: function ($ super , name) {
$ super (name, 'hissssssssss' );
}
});
var ringneck = new Snake( "Ringneck" );
ringneck.speak();
//-> alerts "Ringneck says: hissssssssss!"
var rattlesnake = new Snake( "Rattler" );
rattlesnake.speak();
//-> alerts "Rattler says: hissssssssss!"
// mixing-in Enumerable
var AnimalPen = Class.create(Enumerable, {
initialize: function () {
var args = $A(arguments);
if (!args.all( function (arg) { return arg instanceof Animal }))
throw "Only animals in here!"
this .animals = args;
},
// implement _each to use Enumerable methods
_each: function (iterator) {
return this .animals._each(iterator);
}
});
var snakePen = new AnimalPen(ringneck, rattlesnake);
snakePen.invoke( 'speak' );
//-> alerts "Ringneck says: hissssssssss!"
//-> alerts "Rattler says: hissssssssss!"
通过Class.create来创建一个类与连结一个父类与其他材料构成一个子类。想调用同名父方法，需要在此方法的参数中传入一个$super参数。
dojo的类工厂：
var F = function (){}
F.prototype = SuperClass.prototype;
SubClass.prototype = new F();
SubClassprototype.constructor = SubClass
Prototype.js1.6之后的类定义
dojo.declare(
"TestClass" ,
null ,
{
id: "" ,
info: { name : "" ,age: "" },
staticValue:{count:0},
constructor : function (id,name,age) {
this .id=id;
this .info.name=name;
this .info.age=age
this .staticValue.count++;
}
}
);
它有三个参数，类名，父类，与一个对象，里面包含构建这个类的材料。
YUI的类工厂
// http://blog.csdn.net/phphot/article/details/4325823
YUI().use( 'oop' , function (Y) {
var Bird = function (name) {
this .name = name;
};
Bird.prototype.getName = function (){ return this .name; };
var Chicken = function (name) {
Chicken.superclass.constructor.call( this , name);
};
Y.extend(Chicken, Bird);
var chicken = new Chicken( 'Tom' );
Y.log(chicken.getName());
});
supperclass 有两个作用：一是可以用来调用父类的方法，二是可以通过 supperclass.constructor 调用父类的构造函数。一举两得.
不过它相对于其他类工厂来说是非常原始的，只负责连结子类与父类。
Simple JavaScript Inheritance
这是jquery作者搞的东西
// http://ejohn.org/blog/simple-javascript-inheritance/
var Person = Class.extend({
init: function (isDancing){
this .dancing = isDancing;
},
dance: function (){
return this .dancing;
}
});
var Ninja = Person.extend({
init: function (){
this ._super( false );
},
dance: function (){
// Call the inherited version of dance()
return this ._super();
},
swingSword: function (){
return true ;
}
});
var p = new Person( true );
p.dance(); // => true
var n = new Ninja();
n.dance(); // => false
n.swingSword(); // => true
// Should all be true
p instanceof Person && p instanceof Class &&
n instanceof Ninja && n instanceof Person && n instanceof Class
由Class.create来创建父类,然后通过父类的extend方法加个属性包创建子类.
mootools的类工厂
// http://hmking.blog.51cto.com/3135992/682098
var Animal = new Class({
initialize: function (age) {
this .age = age;
}
});
var Cat = new Class({
Extends: Animal,
initialize: function (name, age) {
this .parent(age); // calls initalize method of Animal class
this .name = name;
}
});
var cat = new Cat( 'Micia' , 20);
console.log(cat.name); // 'Micia'
console.log(cat.age); // 20
它应该是所有框架中最复杂也是最强大的,涉及的API就有Mutator Extends Implements还有从Type继承过来的extend implement，它内部拷贝父类属性还用到了深拷贝！
Extends: 可以实现父类，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。
Implements: 实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。
implement: 是用于调整已经创建好的类的原型成员.
extend: 调用子类(非其实例)的extend方法创建一个新的子类.
mass Framework的类工厂
// http://rubylouvre.github.com/doc/index.html
$.require( "class,spec" , function () {
var Shape = $.factory({
init: function (len) {
$.log(len)
this .length = len || 0;
},
getLength: function () {
return this .length;
},
setLength: function (len) {
this .length = len;
},
getArea: function () {
throw "Subclasses must implement this method"
}
})
var Triangle = $.factory({
inherit: Shape,
init: function (len, hei) { //len属性在父类中已定义，这里可以省去
this .height = hei || 0;
},
getArea: function () {
return this .length * this .height / 2
}
})
var Square = $.factory({
inherit: Shape,
getArea: function () {
return this .length * this .length;
}
});
var t = new Triangle(3, 4)
$.log(t.getArea(), true )
var s = new Square(4)
$.log(s.getArea(), true )
});
$.factory为类工厂,参数为一个普通对象,此对象拥有如下可选属性
init为新类的构造器,没有默认传入空函数进去 inherit为新类的父类 extend的参数是一个对象或对象数组,不管怎么样,这些对象的属性只是为新类添加静态成员,或者说它们是添加到类之上的 implement的参数是一个对象或对象数组或类(类即函数),这些对象的属性只是为新类添加实例成员,或者说它们是添加到类的原型上.
标签: javascript
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息