封闭及；JavaScript语法

我在控制台中运行此命令是为了找到result的值，但我不明白为什么它是122。我不知道为什么，也不知道奖金是如何在代码中使用的。请有人解释一下奖金的价值，以及他们是如何获得开始时声明的每个变量的价值的。我认为这将有助于我和全世界了解本学习脚本中的内容：

var hidden = mystery(3);
var jumble = mystery3(hidden);
var result = jumble(2);

function mystery ( input ){
    var secret = 4;

    input+=2;

    function mystery2 ( multiplier ) {
        multiplier *= input;

        return secret * multiplier;
    }

    return mystery2;
}

function mystery3 ( param ){
    function mystery4 ( bonus ){
        return param(6) + bonus;
    }

    return mystery4;
}

---

提前非常感谢！（我已经查阅了很多资料，但还不能完全理解这个相当基本的资料。）（

注销或更好，手工写出返回值，每次查看一条语句，可以帮助您简化问题

var hidden = mystery(3);

神秘（3）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

请注意，在这种情况下，

input

和

secret

始终是常量。但情况并非总是如此。通常使用闭包的原因是在私有环境中封装变量，闭包函数为非局部函数提供了一种“到达”的方式这些变量在函数完成执行后不会被垃圾收集，因为返回的函数仍然可以访问它们。即使函数已经结束，这些函数仍然可以更改函数中变量的值

---

mystery3（隐藏）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

---

---

好的，

jumble（2）

，也就是上面的“

mystery4

，就是

120+2

，因此是122。

注销或者更好，手工写出返回值，一次只看一条语句可以帮助简化问题

var hidden = mystery(3);

神秘（3）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

请注意，在这种情况下，

input

和

secret

始终是常量。但情况并非总是如此。通常使用闭包的原因是在私有环境中封装变量，闭包函数为非局部函数提供了一种“到达”的方式这些变量在函数完成执行后不会被垃圾收集，因为返回的函数仍然可以访问它们。即使函数已经结束，这些函数仍然可以更改函数中变量的值

---

mystery3（隐藏）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

---

---

好的，

jumble（2）

，也就是上面的“

mystery4

，就是

120+2

，因此是122。

注销或者更好，手工写出返回值，一次只看一条语句可以帮助简化问题

var hidden = mystery(3);

神秘（3）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

请注意，在这种情况下，

input

和

secret

始终是常量。但情况并非总是如此。通常使用闭包的原因是在私有环境中封装变量，闭包函数为非局部函数提供了一种“到达”的方式这些变量在函数完成执行后不会被垃圾收集，因为返回的函数仍然可以访问它们。即使函数已经结束，这些函数仍然可以更改函数中变量的值

---

mystery3（隐藏）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

---

---

好的，

jumble（2）

，也就是上面的“

mystery4

，就是

120+2

，因此是122。

注销或者更好，手工写出返回值，一次只看一条语句可以帮助简化问题

var hidden = mystery(3);

神秘（3）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

请注意，在这种情况下，

input

和

secret

始终是常量。但情况并非总是如此。通常使用闭包的原因是在私有环境中封装变量，闭包函数为非局部函数提供了一种“到达”的方式这些变量在函数完成执行后不会被垃圾收集，因为返回的函数仍然可以访问它们。即使函数已经结束，这些函数仍然可以更改函数中变量的值

---

mystery3（隐藏）

返回函数：

function mystery2 ( multiplier ) {
    multiplier *= input;        //notice input is 5
    return secret * multiplier; //  and secret is 4
}

function mystery4 ( bonus ){
    return param(6) + bonus;  //param(6), which points to mystery2 above,
                              //          is just 6*5*4 = 120
}

---

---

嗯，

jumble（2）

，也就是上面的“

mystery4

，就是

120+2

，所以是122。

这是一组非常复杂的函数，但是

您可以将

var hidden=summary（3）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

然后，您可以将

var jumble=mystery3（隐藏）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

…或

function mystery4(bonus) {
    return 120 + bonus; // 120 is the result of 6 *  5 * 4
}

---

然后当你调用

jumble（2）

时，它会调用

神秘（奖金）

，它会

返回120+奖金

，或者

返回120+2；

这是一组非常复杂的函数，但是

您可以将

var hidden=summary（3）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

然后，您可以将

var jumble=mystery3（隐藏）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

…或

function mystery4(bonus) {
    return 120 + bonus; // 120 is the result of 6 *  5 * 4
}

---

然后当你调用

jumble（2）

时，它会调用

神秘（奖金）

，它会

返回120+奖金

，或者

返回120+2；

这是一组非常复杂的函数，但是

您可以将

var hidden=summary（3）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

然后，您可以将

var jumble=mystery3（隐藏）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

…或

function mystery4(bonus) {
    return 120 + bonus; // 120 is the result of 6 *  5 * 4
}

---

然后当你调用

jumble（2）

时，它会调用

神秘（奖金）

，它会

返回120+奖金

，或者

返回120+2；

这是一组非常复杂的函数，但是

您可以将

var hidden=summary（3）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

然后，您可以将

var jumble=mystery3（隐藏）

想象为：

function mystery2( multiplier ) { 
    multiplier *= 5;
    return 4 * multiplier;
}

function mystery4( bonus ){
    return mystery2(6) + bonus;
} 

…或

function mystery4(bonus) {
    return 120 + bonus; // 120 is the result of 6 *  5 * 4
}

然后，当您调用

jumble（2）

时，它会调用

神秘（奖金）

，它会

返回120+奖金

，或者

返回120+2；

这并不难