在RabbiqMQ Direct交换中仅向绑定到路由密钥的一个队列发送消息(Deliver message to only one queue bound to a routing key in RabbiqMQ Direct exchange)

 函数doSomething()返回另一个函数，所以当你执行 
 
var exec = doSomething();
 
 您可以将该exec视为包含以下功能 
 
function doThis(a){ // <- takes an argument
    console.log(1); // comes from the b argument in the outer scope
    console.log(a); // not set yet
}
 
 因此，当你调用exec(2)你实际上调用带有参数2 doThis() ，它变成了a的值。 
 
 这是一个稍微简化的版本。 为了扩大这一点， doSomething()函数被描述为关闭 doThis()创建闭包 。 相反，函数doThis()在闭包之上或之内闭合 。 闭包本身就是一个围绕函数的有限状态： 
 
function doSomething(){ // --> defines the closure
  var b = 1; // variable only visible within doSomething()
  return function doThis(a){ //<--> function has access to everything in doSomething(). Also defines another closure
        console.log(b); // --> accesses the OUTER scope
        console.log(a); // <-- comes from the INNER scope
  } // <-- end INNER scope
} // --> end OUTER scope
 
 当您执行doSomething() ，返回的结果仍然保留对其中的作用域的访问权限，这就是为什么doThis()可以访问值b - 它只是可访问的。 这与你如何做相似 
 
 
 
 
 
  
var foo = 40;

function bar(value) {
  return foo + value;
}

console.log(bar(2));
 
 
 
 
 
 只有在这种情况下，任何其他代码都会访问foo因为它是一个全局变量，所以如果在不同的函数中执行foo = 100 ，则会更改bar()的输出。 闭包可防止从闭包外部到达内部的代码。 

The function doSomething() returns another function so when you execute
 
var exec = doSomething();
 
You can think of that exec as containing the following function
 
function doThis(a){ // <- takes an argument
    console.log(1); // comes from the b argument in the outer scope
    console.log(a); // not set yet
}
 
Thus when you call exec(2) you are actually calling doThis() with an argument 2 which becomes the value of a.
 
This is a slightly simplified version. To expand on that, the doSomething() function is described as closing over doThis() creating a closure. Conversely, the function doThis() is closed over or inside a closure. The closure itself is simply a limited state around the function:
 
function doSomething(){ // --> defines the closure
  var b = 1; // variable only visible within doSomething()
  return function doThis(a){ //<--> function has access to everything in doSomething(). Also defines another closure
        console.log(b); // --> accesses the OUTER scope
        console.log(a); // <-- comes from the INNER scope
  } // <-- end INNER scope
} // --> end OUTER scope
 
When you execute doSomething() the returned result still retains access to the scope within it, this is why doThis() has access to the value b - it's simply reachable for it. It's similar how you can do
 
 
 
 
 
  
var foo = 40;

function bar(value) {
  return foo + value;
}

console.log(bar(2));
 
 
 
 
 
Only in this instance any other code will have acces to foo as it's a global variable, so if you do foo = 100 in a different function, that will change the output of bar(). A closure prevents the code inside from being reachable from outside the closure.