Dojo1.7的新功能-aspect

var aspect = function(){
	"use strict";
	function advise(dispatcher, type, advice, receiveArguments){
		var previous = dispatcher[type];
		var around = type == "around";
		var signal;
		if(around){
			var advised = advice(function(){
				return previous.advice(this, arguments);
			});
			signal = {
				remove: function(){
					signal.cancelled = true;
				},
				advice: function(target, args){
					return signal.cancelled ?
						previous.advice(target, args) : // cancelled, skip to next one
						advised.apply(target, args);	// called the advised function
				}
			};
		}else{
			// create the remove handler
			signal = {
				remove: function(){
					var previous = signal.previous;
					var next = signal.next;
					if(!next && !previous){
						delete dispatcher[type];
					}else{
						if(previous){
							previous.next = next;
						}else{
							dispatcher[type] = next;
						}
						if(next){
							next.previous = previous;
						}
					}
				},
				advice: advice,
				receiveArguments: receiveArguments
			};
		}
		if(previous && !around){
			if(type == "after"){
				// add the listener to the end of the list
				var next = previous;
				while(next){
					previous = next;
					next = next.next;
				}
				previous.next = signal;
				signal.previous = previous;
			}else if(type == "before"){
				// add to beginning
				dispatcher[type] = signal;
				signal.next = previous;
				previous.previous = signal;
			}
		}else{
			// around or first one just replaces
			dispatcher[type] = signal;
		}
		return signal;
	}
	function aspect(type){
		return function(target, methodName, advice, receiveArguments){
			var existing = target[methodName], dispatcher;
			if(!existing || existing.target != target){
				// no dispatcher in place
				dispatcher = target[methodName] = function(){
					// before advice
					var args = arguments;
					var before = dispatcher.before;
					while(before){
						args = before.advice.apply(this, args) || args;
						before = before.next;
					}
					// around advice
					if(dispatcher.around){
						var results = dispatcher.around.advice(this, args);
					}
					// after advice
					var after = dispatcher.after;
					while(after){
						results = after.receiveArguments ? after.advice.apply(this, args) || results :
								after.advice.call(this, results);
						after = after.next;
					}
					return results;
				};
				if(existing){
					dispatcher.around = {advice: function(target, args){
						return existing.apply(target, args);
					}};
				}
				dispatcher.target = target;
			}
			var results = advise((dispatcher || existing), type, advice, receiveArguments);
			advice = null;
			return results;
		};
	}
	return {
		before: aspect("before"),
		around: aspect("around"),
		after: aspect("after")
	};
}();

这段代码与aspect.js的主要区别是，我们将原来代码中的匿名函数直接执行（第109句），并将结果赋给了变量aspect.

function weave(target){
	for (var x in target){
	    if (!dojo.isFunction(target[x])){
	        console.log(x, target[x]);
	        continue;
	    }
	    aspect.around(target, x, function(oFun){
	        log("trying to advise ", x);
	            if (!oFun.funcName)
	                oFun.funcName = x;
	        return function(){
	            var start = new Date().getTime();
	            console.log(">>>", oFun.funcName);
	            var results = oFun.apply(this, arguments); // call the original
	            var end = new Date().getTime();
	            console.log("<<<", oFun.funcName, " take", (end - start) + " ms");
	            return results;
	        };
	    });
	}; 
}

获取Javascript函数的函数名没有标准的和放之四海皆准的方法。一般会在被调用函数内部使用arguments.callee.name来获取该函数的名字，但它有两个缺点，第一，如果脚本声明了”use strict”，则不使用这一方法；另外，在我们的应用场景里这根本就不可行。好在我们可以在织入时让函数自己带着这个名字。Javascript中函数即对象！（这一技巧我们已经在 Javascript中的变量中使用过，用来构造函数中的静态变量）这就是第9～10行所做的工作。

>>> weave(__global);