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)
}());

此系统(从自动执行的匿名函数返回函数)允许您在局部作用域中定义变量，这些变量仍可由返回的函数使用，但不能由作用域之外的函数使用。这是一个example。

这种技术在JavaScript中称为closure。在上阅读有关它的更多信息

Answer 2

因为该函数返回一个带参数的函数。

Answer 3

为了理解这一点，我认为使用一个更简单的例子是有帮助的。看看下面的两个记忆函数。唯一不同的是在成功记忆代码后的()。

    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)

当我们将()放在add : function(){...}()的末尾时，这里发生的就是successful_memoization的情况。因此，此函数在创建静态对象时立即执行。反过来，执行该函数会返回对象function (number){...}，这会导致赋值：add : function (number){...} ，而不是最初出现的 add : function(){}。

同样需要注意的是，var counter在 return function(name){}之外被声明为。由于它仍在add : function(number){...}中使用，因此可以在该函数中访问该变量。对于failed_memoization.add()(number)，每次我们执行该函数时，它都会使用一个新的counter，因为我们先执行第一个函数，然后在每次调用时执行内部函数。对于successful_memoization.add(number)，我们在初始化时执行外部函数，因此counter将在所有后续调用中保持不变，不会被覆盖。