当前位置: 代码迷 >> JavaScript >> DOJO中的面向对象_第五章 Dojo/_base/declare.js源码剖解(2)
  详细解决方案

DOJO中的面向对象_第五章 Dojo/_base/declare.js源码剖解(2)

热度:342   发布时间:2012-10-13 11:38:17.0
DOJO中的面向对象__第五章 Dojo/_base/declare.js源码剖析(2)

接着第四章....

(二)?? getInherited和inherited方法

  这两个方法是对外提供的扩展接口,可以用declare出来的类型的实例调用。它们的用途是返回父类中曾经出现的方法,或者对其进行调用。具体的用法在第二章中已经描述,这里不再举例说明。

  1. getInherited方法主要用来返回父类中的方法;

  2. inherited方法主要用来调用父类中的方法;

  首先来看getInherited方法,该方法的实现比较简单:

//getInherited的实现,调用了inherited
function getInherited(name, args){
	//如果传入name,则返回指定name的方法
	if(typeof name == "string"){
		return this.inherited(name, args, true);
	}
	//否则返回的是父类中的同名方法
	return this.inherited(name, true);
}

  上面的实现中可以看出,在getInherited中其实还是调用inherited来做进一步处理,只不过将inherited的最后一个参数设置为true,在inherited里会判断该参数,为true就是返回函数,不为true则是调用函数。

?

  接下来看inherited方法,可以分成个3步骤依次来看inherited具体的实现细节。第一步 依然是crack arguments,这是由于dojo提供的API的灵活性所致,就要求这样也能调用,那样也能调用,很蛋疼。第二步 就是根据name参数来寻找父类中的同名方法,这里的name有可能是constructor,也就是说我们可以利用inherited去调用父类中的构造函数,因此在inherited的实现里做了分情况讨论,一种情况是调用父类的非构造函数,还有一种是调用构造函数。想想在第三章末尾曾讲述过,可以把某继承链的构造器调用顺序设置为manual,这样将会破坏默认的自动调用父类构造函数,用户可以根据自己手动去调用父类的构造函数,用的正是this.inherited('constructor',arguments)....在第二步完成之后,第三步 所做的工作很简单,即决定是返回找到的同名方法还是调用这个同名方法。

function inherited(args, a, f){
	var name, chains, bases, caller, meta, base, proto, opf, pos,
		cache = this._inherited = this._inherited || {};	
	// 首先是crack arguments
	// 最后传入的参数f可能是true,也可能是一个替代args的数组,还有可能是默认的undefined
	if(typeof args == "string"){
		name = args;
		args = a;
		a = f;
	}
	f = 0;

	//args是子类方法的参数列表,args.callee代表在子类的哪个方法中调用了inherited
	caller = args.callee;	

	//获取欲调用的父类的方法的名称,如果没有传入name参数,那么就是调用父类中的同名方法
	name = name || caller.nom;
	if(!name){
		err("can't deduce a name to call inherited()");
	}
	//这里获取到的是子类型的meta信息,下面接着通过meta信息来进一步获取子类型的MRO链
	meta = this.constructor._meta;
	bases = meta.bases;

	//第一次调用inherited的时候,由于缺少this._inherited信息,
	//所以cache是一个空的Object,这里pos是undefined
	//但是如果第二回及以后用到了inherited
	//那么在cache中记录了之前一次利用inherited寻找的方法和位置
	//注意实际上整个实现中并未利用cache,这里的cache疑似某个实现版本遗留下的痕迹
	pos = cache.p;

	//分情况讨论
	//1.要调用的方法不是父类中的构造函数
	if(name != cname){
		// method
		if(cache.c !== caller){
			// cache bust
			pos = 0;
			base = bases[0];
			meta = base._meta;
			if(meta.hidden[name] !== caller){
				// error detection
				chains = meta.chains;
				if(chains && typeof chains[name] == "string"){
					err("calling chained method with inherited: " + name);
				}
				// find caller
				do{
					meta = base._meta;
					proto = base.prototype;
					if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
						break;
					}
				}while(base = bases[++pos]); // intentional assignment
				pos = base ? pos : -1;
			}
		}
		// 在正常情况下,在bases[0]中根据name寻找到的方法就是caller
		// 因此需要沿着bases继续寻找,有可能会进入while循环,找到的函数放在f中			
		base = bases[++pos];
		if(base){
			proto = base.prototype;
			if(base._meta && proto.hasOwnProperty(name)){
				f = proto[name];
			}else{
				opf = op[name];
				do{
					proto = base.prototype;
					f = proto[name];
					if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
						break;
					}
				}while(base = bases[++pos]); // intentional assignment
			}
		}
		//这个写法太高级了....就是在bases中没有去就Object.prototype里找
		//不过很可能Object.prototype中依然没有名为name的方法,这时候f就是undefined
		f = base && f || op[name];
	}
	//2.要调用的方法是父类中的构造函数
	else{
		if(cache.c !== caller){
			//如果name是constructor,依然是沿着bases依次寻找
			pos = 0;
			meta = bases[0]._meta;
			if(meta && meta.ctor !== caller){
				// error detection
				chains = meta.chains;
				if(!chains || chains.constructor !== "manual"){
					err("calling chained constructor with inherited");
				}
				// find caller
				while(base = bases[++pos]){ // intentional assignment
					meta = base._meta;
					if(meta && meta.ctor === caller){
						break;
					}
				}
				pos = base ? pos : -1;
			}
		}
		// 这里找到的父类型的构造函数是base._meta.ctor
		// 即当初declare该类型时props中自定义的constructor函数
		while(base = bases[++pos]){	// intentional assignment
			meta = base._meta;
			f = meta ? meta.ctor : base;
			if(f){
				break;
			}
		}
		f = base && f;
	}

	// 把f和pos放进cache中,即this._inherited
	// 这样下次再次利用inherited寻找name方法的时候就很方便了
	cache.c = f;
	cache.p = pos;

	// 决定是返回f还是调用f
	if(f){
		return a === true ? f : f.apply(this, a || args);
	}
}

  上面不仅贴出了整个inherited的实现,也标注了一些关键步骤的解释。其中的cache疑似是一个过期的实现,因为实在想不出会有什么情况下cache.c === caller,除非人为的故意设置成如此,不过幸好即使忽略掉cache的作用也不会影响整段代码的理解。还有一个颇为有趣的地方在于如果发现了一个方法处于chains之中,那么会抛出异常,因为对一个已经chains的方法再去手动调用是毫无意义的。

(三)? isInstanceOf方法

  在第二章中已经提及,为了弥补JS自带的instanceof运算符无法判断Dojo中的继承,所以才有了isInstanceOf扩展。该方法由Dojo中类型的实例来调用。

function isInstanceOf(cls){
	//获取该类型meta信息中的bases(即MRO的结果)
	var bases = this.constructor._meta.bases;
	//遍历bases
	for(var i = 0, l = bases.length; i < l; ++i){
		if(bases[i] === cls){
			return true;
		}
	}
	return this instanceof cls;
}

  整个实现也很清晰很简单,在第三章曾经描述过,不论Dojo中一个继承结构多么的复杂,归根结底还是一个单继承的形式,外加mixin进了许多类型的属性而已。那么在判断instanceof的时候,只要顺着这样一条继承链从低向高处遍历,沿途无论是发现了mixin的class,或者直接就是父类,这里都会返回true。

?

如果对JS中原生instanceof的判断机制感兴趣,可以参考

1. http://www.iteye.com/topic/461096

2. http://ejohn.org/blog/objectgetprototypeof

?

(四)? chainedConstructor方法

  第四章中提过,在declare中构建ctor的时候,针对不同的情况分别调用了三个函数。这里只研究其中的chainedConstructor,因为该函数最为复杂,另外两个simpleConstructor和singleConstructor函数不作详细分析。chainedConstructor是当declare的类型存在继承,且未设置constructor="manual"时调用的函数,返回值是一个用以充当declare类型的函数。

?

  整个chainedConstructor可以看作三大步。第一步 就是就是执行在继承结构链上所有类型中定义的preamble函数,第二步 是调用所有类型的constructor函数,第三步 是执行当前类型中定义的postscript方法。如果撇开preamble和postscript,那么整个chainedConstructor的实现就只需要调用所有类型的constructor函数,相应的实现也可以被压缩成:

// 遍历bases中的类型,未指明constructor的调用顺序,因此默认是after,即
// 从bases[i]---->bases[0]依次调用constructor
for(i = bases.length - 1; i >= 0; --i){
	f = bases[i];
	m = f._meta;
	f = m ? m.ctor : f;//可能是raw class
	if(f){
		f.apply(this, arguments);
	}
}

?

  可惜必须要面对存在preamble和postscript的情况,而且这两种情况的处理方式还不一样。其实preamble的调用也很简单,就是遍历bases,找出其中定义过的preamble函数,然后依次执行。

function chainedConstructor(bases, ctorSpecial){
	return function(){
		var a = arguments, args = a, a0 = a[0], f, i, m,l = bases.length, preArgs;

		//如果不是利用new的时候调用该函数,那要强迫new出实例
		if(!(this instanceof a.callee)){
			// not called via new, so force it
			return applyNew(a);
		}

		// ctorSpecial=true仅发生在:没有定义chains,或者chains中的constructor
		// 一旦有了chains并且设置了constructor的顺序,则无需执行preamble
		// 有两种设置preamble的方式:
		// 一是在new的时候将preamble作为参数传递给该类型
		// 二是在declare一个类型的时候定义好
		if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
			preArgs = new Array(bases.length);
			preArgs[0] = a;
			for(i = 0;;){
				// 如果是在参数中定义了preamble并传第给ctor
				a0 = a[0];
				if(a0){
					f = a0.preamble;
					if(f){
						a = f.apply(this, a) || a;
					}
				}
				// 如果是在类型的declare中定义preamble
				f = bases[i].prototype;
				f = f.hasOwnProperty("preamble") && f.preamble;
				if(f){
					a = f.apply(this, a) || a;
				}
				// for循环再遍历完了bases之后会结束
				if(++i == l){
					break;
				}
				//会记录下每次调用preamble之后的arguments
				//主要是为了防止某个preamble对arguments作出修改
				preArgs[i] = a;
			}
		}
		
		//第二步开始
		……

}

  上面对第一步preamble的执行作出了一些解释。现在还剩最后一步,只针对当前的类型来调用postscript:

f = this.postscript;
if(f){
     f.apply(this, args);
}

  这个实在没什么好讲的。

?

  从整个chainedConstructor的三大步骤实现来看,其实dojo的源码写的还是很通俗易懂的,结构也很清楚,是不错的学习材料^_^至此declare.js中比较重要的函数基本都已经讲完了,只缺少一个关于c3mro函数的剖析,但是前面讲mro已经花了大量的篇幅,便不打算再写下去了。以前都是仅仅停留在参阅Dojo的API的说明上,这是我第一次花力气去阅读Dojo的源码,可惜目前的工作中已经没有机会再使用Dojo了。

?

  相关解决方案