记忆函数+闭包

函数可以用对象去记住先前操作的结果，从而避免无谓的运算。这种优化，被称为记忆。 Memoizations ，而 js 的对象和数组实现这种优化十分方便。

Var Fibonacci = function (n) {

        Return n<2 ? n : Fibonacci(n-1) + Fibonacci(n – 2);

};

For (var i=0; I <= 10 ; i+=1) {

        Document.writeln(‘//’ + I + ‘ ;’ + Fibonacci(i));

}

上面的这种情况就进行了 500 多次的冗余运算。

那么用下面的方法，就仅仅进行了十几次的运算。

               <script type="text/javascript" >

                      var abc = function(){

                             var memo=[0,1];

                             var fib= function(n){

                                    var result = memo[n];

                                    if( typeof result !=='number'){

                                           result = fib(n-1) + fib(n-2)    ;

                                           memo[n]=result;

                                           alert(" 计算 :"+n);

                                    };

                                    return result;  

                                   

                             };   

                             return fib;

                      }();

                      alert( abc(10));

               </script>

 

这个记忆函数，可以做成通用体 ~

Fundamental 函数：

 

Var memoizer = functiong (memo, fundamental) {

        Var shell = function (n) {

               Var result = memo[n];

               If (typeof result !== ‘number’){

                      Result = fundamental(shell,n);

                      Memo[n] = result;

}

Return result;

};

};

下面，就可以用上面的东西，自定义一个方法了。

Var Fibonacci = memoizer([0,1], function (shell,n){

        Return shell(n-1) + shell(n-2);

});

如果是要整一个 可记忆阶乘，则可以使用

Var Fibonacci = memoizer([0,1], function (shell,n){

        Return n*shell(n-1);

});

 

这种设计模式看起来是相当的不错哦，很多 jquery 里面的方法，貌似都是通过这种方式进行的定义，而且，不管是 js 还是在 java 中， 这种方式都是一种令人垂涎三尺的方式。很好，很强大，以后得多采用这种记忆的模式。

另外 就是，因为很多时候都会有一种这样的情况，

采用 var a=function （） {} （）；这种方法，其实，你打印 a 的时候， a 不是 funcion 什么的，而是这个 function 的返回值。所以，完全可以在里面定义一个方法。并且将这个方法作为返回值来出现，则，里面定义的变量就完全不可见了。但却可以通过方法来进行调用。闭包真的是很神奇的一种情况。很好，很强大。