高阶函数，单例模式，AOP

（1）将函数作为参数的函数的情况，值得一提是前面学习，学到的数组的重排序方法sort(),由于它会调用每个数组项的toString转型方法，然后得到字符串，确定升序排列。即使数组的每一项都是数值，比较的也是字符串。因此，sort()方法可以接收一个函数做参数，以便我们决定我们指定哪个位置在哪个位置的前面。

function compare(v1, v2) {if (v1 < v2) {return -1;} else if (v1 > v2) {return 1;} else {return 0;}}//传入的函数var arr = [];for (var i = 0; i < 10; i++) {arr.push(parseInt(Math.random() * 100));//创建一个数组用于排序}arr.sort(compare);//将函数做参数传入一个函数console.log(arr);

  （2）将函数作为另一个函数的返回值（经典例子：数据类型的判断）

                      function istype(array){
			var Type = {};
			for(var i = 0 , type ; type = array[i++];){
				(function(ty){
					Type["is" + ty] = function(obj){
						return Object.prototype.toString.call(obj);
					}
				})(type);
			}
			return Type;
		}
		var Type = istype(["Number" , "String" , "Object" , "Function" , "boolean"]);//参数可以多加一些
		var o = true;//测试数据
		var result = Type.isString(o);
		console.log("o的数据类型：" + result);

2.单例模式：产生一个类的唯一实例（js值没有类的概念，但有类似机制构造函数）

                function Person(){}

		function getsigle(fn){
			var obj = {};
			return function(){
				return obj || (obj = fn.apply(this,arguments));
			};
		}
		var f = getsigle(function(){new Person()});
		var p1 = f();
		var p2 = f();
		console.log(p1 === p2);//true

3.AOP：面向切面编程（Aspect Oriented Programing）(重要的两个概念before，after)

            Function.prototype.before = function(bFn){
            var that = this;
            return function(){
                bFn.apply(this,arguments);//前置函数
                return that.apply(this , arguments);//业务函数
            }
        }
        Function.prototype.after = function(aFn){
            var that = this;
            return function(){
                var ret;
                ret = that.apply(this,arguments);//业务函数
                aFn.apply(this, arguments);//后置函数
                return ret;
            }
        }
        var coreFunction = function(){console.log("2");};
        coreFunction = coreFunction.before(function(){console.log("1");}).after(function(){console.log("3");});
        coreFunction();//1 2 3