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了。