我一直在玩 ES6 一段时间，我注意到虽然声明的变量var按预期提升......
console.log(typeof name); // undefined
var name = "John";
...声明的变量let或const似乎在提升方面存在一些问题：
console.log(typeof name); // ReferenceError
let name = "John";
和
console.log(typeof name); // ReferenceError
const name = "John";
这是否意味着使用let或未const提升声明的变量？这里到底发生了什么？在这件事上let和之间有什么区别const吗？
@thefourtheye 说这些变量在声明之前无法访问是正确的。然而，它比那要复杂一些。
与声明的变量
let或const不悬挂？这里到底发生了什么？
所有声明（var, let, const, function, function*, class）在 JavaScript 中都被“提升”了。这意味着如果在一个范围内声明了一个名称，那么在该范围内，标识符将始终引用该特定变量：
x = "global";
// function scope:
(function() {
x; // not "global"
var/let/… x;
}());
// block scope (not for `var`s):
{
x; // not "global"
let/const/… x;
}
对于函数作用域和块作用域1都是如此。
之间的差var/ function/function*声明和let/ const/class声明是初始化。当在作用域顶部创建绑定时，
前者使用undefined或（生成器）函数进行初始化。然而，词法声明的变量保持未初始化。这意味着ReferenceError当您尝试访问它时会抛出异常。它只会得到当初始化let/ const/class这就是所谓的（上述）之前声明进行评估，一切时间盲区。
x = y = "global";
(function() {
x; // undefined
y; // Reference error: y is not defined
var x = "local";
let y = "local";
}());
请注意，let y;语句会使用undefinedlikelet y = undefined;来初始化变量。
该时间盲区不是语法的位置，而是时间的变量（范围）的创建和初始化之间。只要不执行该代码（例如函数体或简单的死代码），在声明上方的代码中引用变量就不是错误，并且如果您在初始化之前访问该变量，即使访问代码位于声明下方（例如，在过早调用的提升函数声明中）。
在这件事上
let和之间有什么区别const吗？
不，就起重而言，它们的工作原理相同。它们之间的唯一区别是constant 必须并且只能在声明的初始化部分分配（const one = 1;，两者const one;和以后的重新分配one = 2都是无效的）。
1：当然，var声明仍然只在函数级别起作用
引用 ECMAScript 6 (ECMAScript 2015) 规范let和const声明部分，
变量在其包含的 Lexical Environment 被实例化时创建，但在评估变量的 LexicalBinding 之前不能以任何方式访问。
因此，要回答您的问题，是的，let并且const提升但在运行时评估实际声明之前您无法访问它们。
ES6引入Let随block level scoping. 直到ES5我们没有block level scoping，所以在块内声明的变量始终hoisted是函数级别的范围。
基本上Scope是指您的变量在程序中的可见位置，这决定了您可以在何处使用已声明的变量。在ES5我们有global scope,function scope and try/catch scope, withES6我们还通过使用 Let 获得块级范围。
var关键字定义变量时，从定义它的那一刻起就知道整个函数。当你用let语句定义一个变量时，它只在它定义的块中是已知的。
function doSomething(arr){
//i is known here but undefined
//j is not known here
console.log(i);
console.log(j);
for(var i=0; i<arr.length; i++){
//i is known here
}
//i is known here
//j is not known here
console.log(i);
console.log(j);
for(let j=0; j<arr.length; j++){
//j is known here
}
//i is known here
//j is not known here
console.log(i);
console.log(j);
}
doSomething(["Thalaivar", "Vinoth", "Kabali", "Dinesh"]);
如果你运行代码，你可以看到变量j只在 the 中loop而不是 before 和 after 中是已知的。然而，我们的变量从定义的那一刻起i就是已知的entire function。
使用 let 还有一个很大的优势，因为它创建了一个新的词法环境并且绑定了新的值而不是保留一个旧的引用。
for(var i=1; i<6; i++){
setTimeout(function(){
console.log(i);
},1000)
}
for(let i=1; i<6; i++){
setTimeout(function(){
console.log(i);
},1000)
}
第一个for循环总是打印最后一个值，let它创建一个新的范围并绑定打印 us 的新值1, 2, 3, 4, 5。
来到constants，它的工作原理与let，唯一的区别是它们的值不能改变。在常量中允许突变，但不允许重新分配。
const foo = {};
foo.bar = 42;
console.log(foo.bar); //works
const name = []
name.push("Vinoth");
console.log(name); //works
const age = 100;
age = 20; //Throws Uncaught TypeError: Assignment to constant variable.
console.log(age);
如果常量引用 an object，它将始终引用 theobject但它object本身可以更改（如果它是可变的）。如果你喜欢不可变的object，你可以使用Object.freeze([])
在2015年的ECMAScript，let并const高挂，但没有初始化。在变量声明之前引用块中的变量会导致 a，ReferenceError因为从块的开始直到处理声明，变量都处于“时间死区”中。
console.log(x); // ReferenceError
let x = 3;
在函数或脚本的顶层，函数声明被视为 var 声明而不是词法声明。
在变量声明之前引用块中的变量会导致 ReferenceError，因为从块的开始到处理声明，变量都处于“时间死区”中。
下面的示例清楚地说明了“let”变量在词法范围/嵌套词法范围内的行为方式。
var a;
console.log(a); //undefined
console.log(b); //undefined
var b;
let x;
console.log(x); //undefined
console.log(y); // Uncaught ReferenceError: y is not defined
let y;
变量 'y' 给出了一个引用错误，这并不意味着它没有被提升。该变量是在实例化包含环境时创建的。但是它可能无法访问，因为它位于无法访问的“时间死区”。
let mylet = 'my value';
(function() {
//let mylet;
console.log(mylet); // "my value"
mylet = 'local value';
})();
let mylet = 'my value';
(function() {
let mylet;
console.log(mylet); // undefined
mylet = 'local value';
})();
在示例 3 中，函数内新声明的“mylet”变量在日志语句之前没有初始化器，因此值为“undefined”。