Javascript 此闭包中的参数在哪一点传递？

清单5.14将isPrime的num参数传递给一个记忆函数，我假设num参数在#1中可见，而在#2中不可见，但实际上相反

Function.prototype.memoized = function(key){
  this._values = this._values || {};
  return this._values[key] !== undefined ?
    this._values[key] :
    this._values[key] = this.apply(this, arguments);
};

Function.prototype.memoize = function() {
  var fn = this;                                  //#1
  console.log(Array.prototype.slice.call(arguments)); // Prints []

  return function(){                              //#2
    console.log(Array.prototype.slice.call(arguments)); //Prints [17]
    return fn.memoized.apply(fn, arguments);
  };
};

var isPrime = (function(num) {
  var prime = num != 1;
  for (var i = 2; i < num; i++) {
    if (num % i == 0) {
      prime = false;
      break;
    }
  }
  return prime;
}).memoize();

assert(isPrime(17), "17 is prime");                //#3

Function.prototype.memoized=函数（键）{
这个。_值=这个。_值| |{}；
返回此值。_值[键]！==未定义？
此._值[键]：
this._values[key]=this.apply（this，参数）；
};
Function.prototype.memoize=函数（）{
var fn=这个；/#1
console.log（Array.prototype.slice.call（arguments））；//Prints[]
返回函数（）{/#2
console.log（Array.prototype.slice.call（arguments））；//打印[17]
返回fn.memonized.apply（fn，参数）；
};
};
变量isPrime=（函数（num）{
var prime=num！=1；
对于（变量i=2；i

num参数（本例中为17）如何可能仅在内部闭包（#2）中可见，而在包装memoize函数中不可见？我不明白memoize（）调用在什么时候将num参数传递给#2中的闭包

请重复并补充上面的问题：为什么我不能在#1中看到num参数

谢谢。

因为

#2

是分配给

iPrime

的功能。然后将

17

传递给

isPrime

。另一方面，调用

.memoize

（

#1

），而不向其传递任何参数：

(function() { ... }).memoize()
//                          ^^ no arguments

我不明白memoize（）调用在哪一点将num参数传递给#2中的闭包

---

没有

memoize

返回一个新函数，并将参数传递给该函数。

因为此时匿名函数尚未被调用

您要做的是调用

memoize

，将匿名函数作为

this

值，并且没有参数（因此是空的

参数

数组）

memoize

然后返回一个函数，该函数基本上检查“是否已使用此参数调用此函数”，如果是，则返回上一个值；如果不是，则调用该函数并存储其返回值

---

这意味着你的函数只有在你实际执行isPrime（17）时才会被调用，在这一点上，你在函数内部，它说的是

return function（）{…}

，在那里你可以看到你的参数。

所以memoize调用，实际上是在调用内部匿名闭包，对吗？这有点令人困惑，因为#1处的上下文实际上是isPrime函数，而#2中的上下文是window。这就是为什么对我来说没有意义。你能解释一下吗？谢谢你的回复！

这个

的工作原理在中有很好的解释。基本上，如果你调用一个函数“normall”，比如

foo（）

，那么

this

指的是

window

，如果你把它称为

bar.foo（）

，那么

this

指的是

bar

。因此，在您的例子中，当您调用

func.memoize（）

时，

这个

指的是

func

。“所以memoize调用实际上是调用内部匿名闭包，对吗？”它不是调用内部函数。它正在创建并返回。我还有一个问题要问你，先生。。。为什么匿名闭包中的上下文（this）是窗口对象？上下文不应该是它的包装功能吗？感谢您的友好回复，（很难知道谁接受答案，两个答案都很好）您正在调用

isPrime（17）

，此调用中没有给出上下文，因此上下文“默认”为窗口对象。