JavaScript：let 和 const 提升的区别？ [复制]

Question

背景

我有一个函数负责生成随机数并使其可用。

"use strict";

module.exports = function(args) {
    let {
        min,
        max,
    } = args;

    let currNumber = genRandom(min, max);

    const genRandom = (min, max) => Math.floor(Math.random() * max) + min;

    const getNumber = () => currNumber;    

    return Object.freeze({
        getNumber
    });
};

问题

由于我不明白的原因，当我使用 Node.js 7.8 运行此代码时，我收到 genRandom is not defined 的错误。

但如果我将代码更改为：

let currNumber = genRandom(min, max);

const genRandom = (min, max) => Math.floor(Math.random() * max) + min;

到：

const genRandom = (min, max) => Math.floor(Math.random() * max) + min;

let currNumber = genRandom(min, max);

然后就可以了！

我不明白为什么会这样。我以为const 和let 就像var 一样被吊起，但这让我相信我错了。

问题

有人可以解释一下这种行为吗？

Answer 1

const 或let 与var 的不同之处在于该变量在声明之前是不可访问的。

只需查看规范：http://www.ecma-international.org/ecma-262/6.0/#sec-let-and-const-declarations

变量是在实例化包含它们的词法环境时创建的，但在评估变量的 LexicalBinding 之前不能以任何方式访问。

语法

LexicalDeclaration_{[In, Yield]} :
LetOrConst BindingList_{[?In, ?Yield]} ;

LetOrConst :
让
常量

BindingList_{[In, Yield]} :
词法绑定_{[?In, ?Yield]}
BindingList_{[?In, ?Yield]} , LexicalBinding_{[?In, ?Yield]}

LexicalBinding_{[In, Yield]} :
BindingIdentifier_[?Yield]Initializer_{[?In, ?Yield]opt} BindingPattern_[?Yield]Initializer_{[?In, ?Yield]}

Answer 2

我认为 const 和 let 就像 var 一样被提升，但这让我相信我错了。

不是真的，let 和 const 确实被提升了，或者我喜欢称之为，half-提升。 var foo 和 let foo 之间有两个很大的区别：作用域和初始化。您已经知道范围差异。第二个是var foo，foo 的声明和初始化（使用undefined）都被提升了。对于let，只有foo 的声明被提升，而不是初始化。 foo 仅在代码的逐步执行到达let foo 语句时初始化。您不能使用（读取或写入）未初始化的标识符。不能使用标识符的这段时间称为时间死区 (TDZ)。

即使使用var，被提升的初始化也是使用undefined 的初始化，而不是= 右侧的值：

console.log(typeof foo); // "undefined"
foo();                   // TypeError: foo is not a function
var foo = () => {};

您所做的更改，在第一次使用之前将getRandom 的声明向上移动，是正确的做法。 （或者使用函数声明，因为声明作为一个整体[包括函数的创建]被提升了。）

我们来看看这个半吊的东西：

let foo = "outer";
function x()
{
    console.log("...");
    let foo = "inner";
    console.log(foo);
}
x();

（let 和 const 具有块作用域，但我正在使用函数，因为稍后我将与 var 进行对比。）

在x 中，内部foo 直到let foo 行才能使用。 但是，你不能访问它上面的外部foo；这失败了：

let foo = "outer";
function x()
{
    console.log(foo);    // ReferenceError: `foo` is not defined
    let foo = "inner";
    console.log(foo);
}
x();

这是半提升：内部foo 的声明被提升，但变量直到let foo 语句才初始化。这意味着您根本不能在let foo 行上方使用foo（甚至不能从包含范围内）。内部foo 会在整个函数中遮盖外部foo，但在初始化之前不能使用它。这在规范中的Let and Const Declarations 中有介绍。

这与var相反：

var foo = "outer";
function x()
{
    console.log(foo);    // undefined
    var foo = "inner";
    console.log(foo);    // "inner"
}
x();

这运行得很好，因为foo（带有undefined）的声明和都被提升到函数的顶部。 （在提升之后，var foo = "inner"; 行变成了一个简单的赋值语句。）因此，内部的foo 始终遮蔽外部的foo，并且也可以始终访问，最初使用其默认值 (undefined)，然后使用"inner"（一旦分配给它）。

由于 TDZ 是时间性的（与时间相关），而不是空间性的（与范围内的空间或位置相关），您可以使用由 let 或 const（或 class）创建的标识符 在其声明之上，而不是在其声明之前。这失败了，因为getNumber 尝试访问theNumber 在它被初始化之前，而它仍在 TDZ 中：

const getNumber = () => theNumber;

console.log(getNumber()); // ReferenceError

let theNumber = 42;

这是因为getNumber 访问theNumber 在它被初始化之后：

const getNumber = () => theNumber;

let theNumber = 42;

console.log(getNumber()); // 42