let 也可用于避免闭包问题。它绑定了新的价值，而不是保留旧的参考，如下面的例子所示。

DEMO

for(var i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

上面的代码演示了一个典型的JavaScript闭包问题参考 i 变量存储在单击处理程序闭包中，而不是实际值 i。

每个单击处理程序都将引用同一个对象，因为只有一个计数器对象可以容纳6，因此每次单击时会得到6个。

一般的解决方法是将其包装在匿名函数中并传递 i 作为论点。现在也可以通过使用来避免这些问题 let 代替 var 如下面的代码所示。

DEMO （在Chrome和Firefox 50中测试过）

'use strict';

for(let i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

这是一个 解释 let 关键词 举一些例子。

让我的工作非常像var。主要区别在于var变量的范围是整个封闭函数

这张桌子 在Wikipedia上显示哪些浏览器支持Javascript 1.7。

请注意，只有Mozilla和Chrome浏览器支持它。 IE，Safari和其他人可能没有。

有什么区别 let 和 var？

• 使用a定义的变量 var 声明始终是已知的 功能 它从函数的开头定义。 （*）
• 使用a定义的变量 let 声明仅在 块 它定义在从定义之后的那一刻起。 （**）

要了解其中的差异，请考虑以下代码：

// i IS NOT known here
// j IS NOT known here
// k IS known here, but undefined
// l IS NOT known here

function loop(arr) {
    // i IS known here, but undefined
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( var i = 0; i < arr.length; i++ ) {
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( let j = 0; j < arr.length; j++ ) {
        // i IS known here, and has a value
        // j IS known here, and has a value
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here
}

loop([1,2,3,4]);

for( var k = 0; k < arr.length; k++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
};

for( let l = 0; l < arr.length; l++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS known here, and has a value
};

loop([1,2,3,4]);

// i IS NOT known here
// j IS NOT known here
// k IS known here, and has a value
// l IS NOT known here

在这里，我们可以看到我们的变量 j 只在第一个for循环中知道，但不在之前和之后。然而，我们的变量 i 在整个功能中都是众所周知的。

另外，请考虑块范围变量在声明之前是未知的，因为它们没有被提升。您也不允许在同一个块中重新声明相同的块范围变量。这使得块范围变量比全局或功能范围变量更不容易出错，这些变量被提升并且在多个声明的情况下不会产生任何错误。

使用安全吗？ let 今天？

有些人会争辩说，将来我们只会使用let语句，而var语句将会过时。 JavaScript大师 凯尔辛普森 写 一篇非常精细的文章，说明为什么不是这样。

然而，今天绝对不是这样。事实上，我们实际上需要问自己，使用它是否安全 let 声明。这个问题的答案取决于您的环境：

• 如果您正在编写服务器端JavaScript代码（Node.js的），你可以安全地使用 let 声明。

• 如果您正在编写客户端JavaScript代码并使用转换器（如 Traceur），你可以安全地使用 let 声明，但是你的代码在性能方面可能不是最优的。

• 如果您正在编写客户端JavaScript代码而不使用转换器，则需要考虑浏览器支持。

今天，2018年6月8日，仍然有一些浏览器不支持 let！

如何跟踪浏览器支持

有关哪些浏览器支持的最新概述 let 在您阅读此答案时的陈述，请参阅 这个 Can I Use 页。

（*）全局和功能范围的变量可以在声明之前初始化和使用，因为JavaScript变量是 悬挂。 这意味着声明始终位于范围的顶部。

（**）未提升块范围变量

接受的答案缺少一点：

{
  let a = 123;
};

console.log(a); // ReferenceError: a is not defined

有一些微妙的差异 - let 范围界定的行为更像是变量范围，或多或少任何其他语言。

例如它适用于封闭块，它们在声明之前不存在，等等。

但值得注意的是 let 只是较新的Javascript实现的一部分，并具有不同程度的 浏览器支持。

以下是两者之间差异的示例（支持刚启动的chrome）：

正如你所看到的那样 var j 变量仍然具有for循环范围之外的值（块范围），但是 let i 变量在for循环范围之外是未定义的。

"use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
  console.log(j);
}

console.log(j);

console.log("let:");
for (let i = 0; i < 2; i++) {
  console.log(i);
}

console.log(i);

let

阻止范围

用变量声明的变量 let 关键字是块范围的，这意味着它们仅在 块 他们被宣布。

在顶层（在功能之外）

在顶层，使用声明的变量 let 不要在全局对象上创建属性。

var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined

内部功能

在一个功能区内（但在一个区域外）， let 与...具有相同的范围 var。

(() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

在一个街区内

使用声明的变量 let 块内部无法访问该块内部。

{
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

在循环内

用变量声明的变量 let in循环只能在该循环内引用。

for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.

带闭合的循环

如果你使用 let 代替 var 在循环中，每次迭代都会得到一个新变量。这意味着您可以安全地在循环内使用闭包。

// Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}

时间死区

因为 时间死区，变量声明使用 let 在声明它们之前无法访问。尝试这样做会引发错误。

console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;

没有重新申报

您不能多次声明相同的变量 let。您也无法使用声明变量 let 与使用声明的另一个变量具有相同的标识符 var。

var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared

const

const 非常相似 let-it是块范围的并且有TDZ。然而，有两件事是不同的。

没有重新分配

变量声明使用 const 无法重新分配。

const a = 42;
a = 43; // TypeError: Assignment to constant variable.

请注意，这并不意味着该值是不可变的。它的属性仍然可以改变。

const obj = {};
obj.a = 42;
console.log(obj.a); // 42

如果你想拥有一个不可变对象，你应该使用 Object.freeze()。

初始化程序是必需的

在使用声明变量时，始终必须指定一个值 const。

const a; // SyntaxError: Missing initializer in const declaration