不存在变量提升
基本用法
ES6新增了两个重要的关键字let和const，相信大家都不陌生，但是包括我在内，在系统学习ES6之前也只使用到了【不存在变量提升】这个特性。
ES6 声明变量的六种方法
let a = 1;let a = 2;console.log(a);
}
来看一个let的例子(const效果一样):
let arg; // 不报错
来看一个var的例子:
不存在变量提升
暂存死区
var tmp = 'hello world';
var定义的变量声明会提升到作用域顶部，所以bar是undefined，而let定义的变量从作用域开始到let foo=2这中间都无法访问，访问会报错ReferenceError
if (true) {
console.log(typeof foo); // undefinedconsole.log(typeof bar); // ReferenceErrorconsole.log(typeof bar2); // undefinedlet bar = 1;var bar2 = 2;
{let insane = 'Hello World'}
此时输出1，因为两者作用域不同
(function () {
同一作用域内不可以重复声明
: this);
var定义的变量会提升到整个函数作用域内，let/const则支持块级作用域。
var foo = 2;
块级作用域: 由{}包裹的作用域（函数那种{}不算）
function f() {}
var a = 1;var a = 2;console.log(a);
}());
let声明一个块级作用域的本地变量const语句声明一个块级作用域的本地常量，不可以重新赋值支持块级作用域
ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。ES6 规定，块级作用域之中，函数声明语句的行为类似于let，在块级作用域之外不可引用。
暂存死区与typeof
function () {
同一作用域内let/const不可以重复声明,var可以。
块级作用域
来看一个let的例子(const效果也一样):
console.log(tmp);
再来看一个不同作用域的例子：
let t = f();
function test(){ var foo = 33; { let foo = (foo + 55); }}test();
if (true) {
console.log(a);let a = 1;
上面代码中，变量x使用let命令声明，所以在声明之前，都属于x的“死区”，只要用到该变量就会报错。因此，typeof运行时就会抛出一个ReferenceError。
此时会报错ReferenceError，因为let/const支持块级作用域，所以let定义的a只在{}可以访问
// 浏览器的 ES6 环境
let a = 1;{ let a = 2;}console.log(a);
上面代码报错，也是因为暂时性死区。使用let声明变量时，只要变量在还没有声明完成前使用，就会报错。上面这行就属于这个情况，在变量x的声明语句还没有执行完成前，就去取x的值，导致报错”x 未定义“。
来看一个var的例子:
上面代码中，常量a是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给a，就会报错。
来看以下例子：
}
通过let/const定义的变量直到执行他们的初始化代码时才被初始化。在初始化之前访问该变量会导致ReferenceError。该变量处于一个自作用域顶部到初始化代码之间的“暂存死区”中。
const声明的常量，也与let一样不可重复声明。
以上函数执行结果是什么?为什么?
上面代码正确运行，输出了3次abc。这表明函数内部的变量i与循环变量i不在同一个作用域，有各自单独的作用域。
来看一个let的例子(const效果也一样):
let f = function () {
时间: 2019-09-22阅读: 107标签: 作用域
上面代码中，变量foo用var命令声明，会发生变量提升，即脚本开始运行时，变量foo已经存在了，但是没有值，所以会输出undefined。变量bar用let命令声明，不会发生变量提升。这表示在声明它之前，变量bar是不存在的，这时如果用到它，就会抛出一个错误。
console.log(a);var a = 1;
顶层对象，在浏览器环境指的是window对象，在Node指的是global对象。ES5之中，顶层对象的属性与全局变量是等价的。
与var不同的是，let/const声明的变量不存在变量提升，也就是说{}对于let/const是有效的。
为了纠正这种现象，let命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错。
来看一个var的例子:
{let insane = 'Hello World'}
typeof检测var定义的变量或者检测不存在的变量时会返回undefined，如果检测暂存死区内的变量，会报错ReferenceError.
因此，不能在函数内部重新声明参数。
{ var a = 1;}console.log(a);
console.log(tmp); // 123
也就是说typeof去检测未初始化的let变量时会报错，var或者未声明的变量不会报错
t * t + 1;
报错：{}内有let定义的foo，所以存在暂存死区，(foo + 55)这个表达式是在let foo之前执行的(赋值时先执行等号右边的，执行完毕把结果赋给等号左边)，表达式执行的时候还没有初始化foo，所以报错ReferenceError
if (true) {
面试题
全局环境中，this会返回顶层对象。但是，Node 模块和 ES6 模块中，this返回的是当前模块。
此时会输出undefined，因为var声明的变量会提升到作用域顶部（只提升声明，不提升赋值）
if (true)
function do_something() { console.log(bar); // undefined console.log(foo); // ReferenceError var bar = 1; let foo = 2;}do_something();
// 严格模式时，该行会报错
总结let/const支持函数作用域和块级作用域,var只有函数作用域let/const不存在变量提升，var存在变量提升let/const同一作用域内不可以重复声明，var可以重复声明let/const存在暂存死区，var不存在
上面代码中，调用bar函数之所以报错（某些实现可能不报错），是因为参数x默认值等于另一个参数y，而此时y还没有声明，属于”死区“。如果y的默认值是x，就不会报错，因为此时x已经声明了。
此时会输出2，var是支持重复声明的，后面声明的值会覆盖前面声明的值。
下面是另一个例子。
此时会报错ReferenceError，因为let不存在变量提升
上面代码中，变量i是var命令声明的，在全局范围内都有效，所以全局只有一个变量i。每一次循环，变量i的值都会发生改变，而循环内被赋给数组a的函数内部的console.log(i)，里面的i指向的就是全局的i。也就是说，所有数组a的成员里面的i，指向的都是同一个i，导致运行时输出的是最后一轮的i的值，也就是10。
此时输出1，因为var没有块级作用域。
// ...
{ let a = 1;}console.log(a);
// 重复声明一次函数f
此时会报错SyntaxError，因为同一作用域内let/const不可以重复声明。
// ES5 环境
暂存死区TDZ(Temporal Dead Zone)是ES6中对作用域新的语义。
// abc
}
同一段代码为了能够在各种环境，都能取到顶层对象，现在一般是使用this变量，但是有局限性。
: (typeof process === 'object' &&
}
try {
t = t * t + 1;
上面代码中，顶层对象的属性赋值与全局变量的赋值，是同一件事。
ES6 的块级作用域
// 不报错
var tmp = 123;
const a = [];
? global
}}}};
for循环的计数器，就很合适使用let命令。
{
let tmp; // TDZ结束
do 表达式
let a = 10;
上面代码中，存在全局变量tmp，但是块级作用域内let又声明了一个局部变量tmp，导致后者绑定这个块级作用域，所以在let声明变量前，对tmp赋值会报错。
if (typeof self !== 'undefined') { return self; }
如果真的想将对象冻结，应该使用Object.freeze方法。
}
}
下面的代码如果使用var，最后输出的是10。
// 情况一
a[6](); // 6
{{{{
}
function f() {}
let age = 25;
}
}
ES6 允许块级作用域的任意嵌套。
// CommonJS 的写法
上面代码在 ES5 中运行，会得到“I am inside!”，因为在if内声明的函数f会被提升到函数头部，实际运行的代码如下。
不管是严格模式，还是普通模式，new Function('return this')()，总是会返回全局对象。但是，如果浏览器用了CSP（Content Security Policy，内容安全政策），那么eval、new Function这些方法都可能无法使用。
}
{
上面代码可以保证各种环境里面，global对象都是存在的。
另外，下面的代码也会报错，与var的行为不同。
// 函数表达式
let实际上为 JavaScript 新增了块级作用域。
let insane = 'Hello World';
上面代码中，变量i只用来控制循环，但是循环结束后，它并没有消失，泄露成了全局变量。
(function () {
console.log(tmp); // ReferenceError
// ...
if (true) {
return a;
ES6 新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。
考虑到环境导致的行为差异太大，应该避免在块级作用域内声明函数。如果确实需要，也应该写成函数表达式，而不是函数声明语句。
}
// TypeError: Assignment to constant variable.
bar(); // 报错
bar(); // [2, 2]
console.log(i);
const MAX = 5;
return [10bet，x, y];
{
ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。
}
}
// ReferenceError: i is not defined
const 命令
}());
// 方法一
// abc
throw new Error('unable to locate global object');
require('system.global/shim')();
函数能不能在块级作用域之中声明？这是一个相当令人混淆的问题。
(function () {
// Uncaught TypeError: f is not a function
PI // 3.1415
function f() { console.log('I am inside!'); }
function f() { console.log('I am inside!'); }
ES5 只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。
不允许重复声明
console.log(tmp); // undefined
{{{{{let insane = 'Hello World'}}}}};
只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。
// 报错
上面两种函数声明，根据 ES5 的规定都是非法的。
// 以下两行都会报错
}
if (false) {
上面代码中，在let命令声明变量tmp之前，都属于变量tmp的“死区”。
'use strict';
上面的函数有两个代码块，都声明了变量n，运行后输出5。这表示外层代码块不受内层代码块的影响。如果两次都使用var定义变量n，最后输出的值才是10。
return [x, y];
(function () {
let a = 'secret';
a // 1
// abc
const声明一个只读的常量。一旦声明，常量的值就不能改变。
var tmp = ...;
上面代码中，undeclared_variable是一个不存在的变量名，结果返回“undefined”。所以，在没有let之前，typeof运算符是百分之百安全的，永远不会报错。现在这一点不成立了。这样的设计是为了让大家养成良好的编程习惯，变量一定要在声明之后使用，否则就报错。
var global = require('system.global')();
// 情况二
import getGlobal from 'system.global';
f();
function f() { console.log('I am outside!'); }
const foo;
let a = 'secret';
function () {
a[i] = function () {
f();
foo = {}; // TypeError: "foo" is read-only
函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
console.log(MAX); // ReferenceError
上面代码中，计数器i只在for循环体内有效，在循环体外引用就会报错。
let n = 5;
global 对象
综上所述，很难找到一种方法，可以在所有情况下，都取到顶层对象。下面是两种勉强可以使用的方法。
var a = [];
if (false) {
console.log(i);
}
const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心。
}
a[i] = function () {
// 方法二
// 如果在Node的REPL环境，可以写成global.a
}());
a = ['Dave']; // 报错
for (let i = 0; i < 10; i++) {
var b = 1;
console.log(n); // 5
函数里面的this，如果函数不是作为对象的方法运行，而是单纯作为函数运行，this会指向顶层对象。但是，严格模式下，这时this会返回undefined。
typeof undeclared_variable // "undefined"
typeof x; // ReferenceError
}
上面代码表示，对于const来说，只声明不赋值，就会报错。
Object.keys(obj).forEach( (key, i) => {
根据这三条规则，在浏览器的 ES6 环境中，块级作用域内声明的函数，行为类似于var声明的变量。
// 或者采用通用方法，写成this.a
a // ReferenceError: a is not defined.
}
}());
for (let i = 0; i < 3; i++) {
}
var tmp = new Date();
ES6为了改变这一点，一方面规定，为了保持兼容性，var命令和function命令声明的全局变量，依旧是顶层对象的属性；另一方面规定，let命令、const命令、class命令声明的全局变量，不属于顶层对象的属性。也就是说，从ES6开始，全局变量将逐步与顶层对象的属性脱钩。
let t = f();
f();
}
const命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用。
console.log(i);
// 块级作用域写法
f();
} catch(e) {
tmp = 'abc'; // ReferenceError
};
本文由10bet发布于Web前端,转载请注明出处：let 和 const 命令
关键词：