Javascript Memoization解释？

Question

从一本书中读取一个例子,有人可以解释当函数本身没有声明任何参数时,函数调用fibonacci如何接受参数'i'吗？

var fibonacci = (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;
        }
        return result;
    };
    return fib;
}());

for(var i = 0; i <= 10; i += 1) {
    document.writeln('// ' + i + ': ' + fibonacci(i));
}

Answer 1

您正在创建一个自执行的匿名函数(function(){}());,它在其中返回fib函数,该函数接受一个参数.var fib = function(n){}...return fib;

var fibonacci = (function () { // Self-executing anonymous function
    var memo = [0, 1];         // local variable within anonymous function
    var fib = function (n) {   // actual fib function (takes one argument)
        var result = memo[n];
        if (typeof result !== 'number') {
            result = fib(n - 1) + fib(n - 2);
            memo[n] = result;
        }
        return result;
    };
    return fib; // return fib (fibonacci is now set to the function fib defined above, which takes one argument)
}());

此系统(从自执行匿名函数返回函数)允许您在本地作用域中定义仍可由返回函数使用的变量,但不能由作用域外的函数使用.这是一个例子.

这种技术closure在JavaScript中调用.在MDN指南中了解更多相关信息 .

Answer 2

因为函数返回一个函数确实需要的参数.

Answer 3

要理解这一点,我认为使用一个更简单的例子是有帮助的.看看下面的两个memoized函数.唯一的区别是()后add : function (){ ... }()上的成功记忆的代码.

    var failed_memoization = {
        add : function (){
            var counter;
            return function(number){
                if(counter){
                    counter = counter + number;
                    return counter;
                }
                counter = number;
                return counter;
            } //NOTE: NO function call brackets here
        }
    }

    var successful_memoization = {
        add : function (){
            var counter;
            return function(number){
                if(counter){
                    counter = counter + number;
                    return counter;
                }
                counter = number;
                return counter;
            }
        }()  //NOTE: the function call brackets here!!
    };
}

现在让我们执行这两个函数.

console.log('Failed Memoization');
console.log(failed_memoization.add(5));      //We wanted 5, but this prints the text of the function instead.... Okay, lets try something else
console.log(failed_memoization.add()(5));    //5
console.log(failed_memoization.add()(10));   //10 (Wanted it to be 5+10 = 15.
console.log('successful_memoization');
console.log(successful_memoization.add(8));  //8
console.log(successful_memoization.add(16)); //24 (This is what we wanted 8 + 16 = 24)

所以这里发生的事情是,successful_memoization当我们()结束它的时候add : function(){...}().因此,在创建静态对象时立即执行此功能.反过来,执行该函数会返回function (number){...}导致赋值的对象:add : function (number){...} NOT, add : function(){}因为它最初出现.

值得注意的是,var counter在外面 宣布return function(name){}.由于它仍在使用中add : function(number){...},因此该变量可在该函数中访问.因为failed_memoization.add()(number),counter每次执行该函数时都使用new ,因为我们执行第一个函数,然后执行每个调用的内部函数.因为successful_memoization.add(number)我们在初始化时执行了外部函数,因此counter将在所有后续调用中保持不变并且不会被覆盖.