記憶函數+閉包

函數可以用對象去記住先前操作的結果，從而避免無謂的運算。這種最佳化，被稱為記憶。
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
的傳回值。所以，完全可以在裡面定義一個方法。並且將這個方法作為傳回值來出現，則，裡面定義的變數就完全不可見了。但卻可以通過方法來進行調用。閉包真的是很神奇的一種情況。很好，很強大。