Javascript 闭包覆盖函数表达式

Question

我试图弄清楚闭包是如何工作的，这是我的例子

function func1(func) {
    return function(summand) {
        return func() + summand;
    }
}

var func2 = function() {
    return 3;
}

var func3 = func1(func2);
var value = func3(4);

alert(value);

var func2 = function() {
    return 100;
}

var newValue = func3(100);
alert(newValue);

首先让我们分解代码。我编写了一个函数，期望将函数作为参数，它会返回一个函数。

function func1(func) {
    return function(summand) {
        return func() + summand;
    }
}

然后我定义了表达式形式的参数函数func2

var func2 = function() {
    return 3;
}

然后调用 func1 并给 func2 作为参数。结果我得到了一个函数

var func3 = func1(func2);

然后我执行函数并传递 4 作为参数参数

var value = func3(4);

结果我得到了 7。然后我覆盖 func2 并返回 100

var func2 = function() {
    return 100;
}

然后再次调用 func3 并作为参数值 100 传递。

var newValue = func3(100);

结果我得到了 103。我定义的第一个函数(返回一个函数并将函数作为参数)仍将使用 func2 的第一个版本。这就是封闭的力量，我知道。
但是看看下面的代码，当我将 func2 定义为函数声明而不是表达式时，func2 将覆盖

function func1(func) {
    return function(summand) {
        return func() + summand;
    }
}

function func2() {
    return 3;
}

var func3 = func1(func2);
var value = func3(4);

alert(value);

function func2() {
    return 100;
}

var newValue = func3(100);
alert(newValue);

第一个值为 104，第二个为 200。
我的问题是，为什么当我使用函数声明时它会覆盖旧函数，在这个例子中是 func2。但是当我使用函数表达式时，它会保留对旧 func2 的引用。
是不是因为函数提升？

Answer 1

这不是因为闭包。

就像您发现的那样 - 这个问题是因为函数提升。

您可以将函数声明视为“向上移动”到当前作用域的开头。

var f2 = function(){
    return 50;
}
function f2(){
    return 100;
}

在这种情况下，f2 是 50，因为它的解析方式类似于:

var f2 = function(){
    return 100;
}
var f2 = function(){
    return 50;
}

因为吊装。