let 和 const 命令
good luck
let 和 const 命令
let 命令
根本用法
ES6 新增了let命令，用来申明变量。它的用法相似于var，然而所申明的变量，只在let命令所在的代码块内无效。
{ let a = 10; var b = 1;}a; // ReferenceError: a is not defined.b; // 1下面代码在代码块之中，别离用let和var申明了两个变量。而后在代码块之外调用这两个变量，后果let申明的变量报错，var申明的变量返回了正确的值。这表明，let申明的变量只在它所在的代码块无效。
for循环的计数器，就很适合应用let命令。
for (let i = 0; i < 10; i++) { // ...}console.log(i);// ReferenceError: i is not defined下面代码中，计数器i只在for循环体内无效，在循环体外援用就会报错。
上面的代码如果应用var，最初输入的是10。
var a = [];for (var i = 0; i < 10; i++) { a[i] = function () { console.log(i); };}a[6](); // 10下面代码中，变量i是var命令申明的，在全局范畴内都无效，所以全局只有一个变量i。每一次循环，变量i的值都会产生扭转，而循环内被赋给数组a的函数外部的console.log(i)，外面的i指向的就是全局的i。也就是说，所有数组a的成员外面的i，指向的都是同一个i，导致运行时输入的是最初一轮的i的值，也就是 10。
如果应用let，申明的变量仅在块级作用域内无效，最初输入的是 6。
var a = [];for (let i = 0; i < 10; i++) { a[i] = function () { console.log(i); };}a[6](); // 6下面代码中，变量i是let申明的，以后的i只在本轮循环无效，所以每一次循环的i其实都是一个新的变量，所以最初输入的是6。你可能会问，如果每一轮循环的变量i都是从新申明的，那它怎么晓得上一轮循环的值，从而计算出本轮循环的值？这是因为 JavaScript 引擎外部会记住上一轮循环的值，初始化本轮的变量i时，就在上一轮循环的根底上进行计算。
另外，for循环还有一个特别之处，就是设置循环变量的那局部是一个父作用域，而循环体外部是一个独自的子作用域。
for (let i = 0; i < 3; i++) { let i = "abc"; console.log(i);}// abc// abc// abc下面代码正确运行，输入了 3 次abc。这表明函数外部的变量i与循环变量i不在同一个作用域，有各自独自的作用域。
不存在变量晋升
var命令会产生“变量晋升”景象，即变量能够在申明之前应用，值为undefined。这种景象多多少少是有些奇怪的，依照个别的逻辑，变量应该在申明语句之后才能够应用。
为了纠正这种景象，let命令扭转了语法行为，它所申明的变量肯定要在申明后应用，否则报错。
// var 的状况console.log(foo); // 输入undefinedvar foo = 2;// let 的状况console.log(bar); // 报错ReferenceErrorlet bar = 2;下面代码中，变量foo用var命令申明，会产生变量晋升，即脚本开始运行时，变量foo曾经存在了，然而没有值，所以会输入undefined。变量bar用let命令申明，不会产生变量晋升。这示意在申明它之前，变量bar是不存在的，这时如果用到它，就会抛出一个谬误。
暂时性死区
只有块级作用域内存在let命令，它所申明的变量就“绑定”（binding）这个区域，不再受内部的影响。
var tmp = 123;if (true) { tmp = "abc"; // ReferenceError let tmp;}下面代码中，存在全局变量tmp，然而块级作用域内let又申明了一个局部变量tmp，导致后者绑定这个块级作用域，所以在let申明变量前，对tmp赋值会报错。
ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令申明的变量，从一开始就造成了关闭作用域。但凡在申明之前就应用这些变量，就会报错。
总之，在代码块内，应用let命令申明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。
if (true) { // TDZ开始 tmp = "abc"; // ReferenceError console.log(tmp); // ReferenceError let tmp; // TDZ完结 console.log(tmp); // undefined tmp = 123; console.log(tmp); // 123}下面代码中，在let命令申明变量tmp之前，都属于变量tmp的“死区”。
“暂时性死区”也意味着typeof不再是一个百分之百平安的操作。
typeof x; // ReferenceError
let x;
下面代码中，变量x应用let命令申明，所以在申明之前，都属于x的“死区”，只有用到该变量就会报错。因而，typeof运行时就会抛出一个ReferenceError。
作为比拟，如果一个变量基本没有被申明，应用typeof反而不会报错。
typeof undeclared_variable; // "undefined"
下面代码中，undeclared_variable是一个不存在的变量名，后果返回“undefined”。所以，在没有let之前，typeof运算符是百分之百平安的，永远不会报错。当初这一点不成立了。这样的设计是为了让大家养成良好的编程习惯，变量肯定要在申明之后应用，否则就报错。
有些“死区”比拟荫蔽，不太容易发现。
function bar(x = y, y = 2) { return [x, y];}bar(); // 报错下面代码中，调用bar函数之所以报错（某些实现可能不报错），是因为参数x默认值等于另一个参数y，而此时y还没有申明，属于“死区”。如果y的默认值是x，就不会报错，因为此时x曾经申明了。
function bar(x = 2, y = x) { return [x, y];}bar(); // [2, 2]另外，上面的代码也会报错，与var的行为不同。
// 不报错
var x = x;
// 报错
let x = x;
// ReferenceError: x is not defined
下面代码报错，也是因为暂时性死区。应用let申明变量时，只有变量在还没有申明实现前应用，就会报错。下面这行就属于这个状况，在变量x的申明语句还没有执行实现前，就去取x的值，导致报错”x 未定义“。
ES6 规定暂时性死区和let、const语句不呈现变量晋升，次要是为了缩小运行时谬误，避免在变量申明前就应用这个变量，从而导致意料之外的行为。这样的谬误在 ES5 是很常见的，当初有了这种规定，防止此类谬误就很容易了。
总之，暂时性死区的实质就是，只有一进入以后作用域，所要应用的变量就曾经存在了，然而不可获取，只有等到申明变量的那一行代码呈现，才能够获取和应用该变量。
不容许反复申明
let不容许在雷同作用域内，反复申明同一个变量。
// 报错function func() { let a = 10; var a = 1;}// 报错function func() { let a = 10; let a = 1;}因而，不能在函数外部从新申明参数。
function func(arg) { let arg;}func(); // 报错function func(arg) { { let arg; }}func(); // 不报错块级作用域
为什么须要块级作用域？
ES5 只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。
第一种场景，内层变量可能会笼罩外层变量。
var tmp = new Date();function f() { console.log(tmp); if (false) { var tmp = "hello world"; }}f(); // undefined下面代码的原意是，if代码块的内部应用外层的tmp变量，外部应用内层的tmp变量。然而，函数f执行后，输入后果为undefined，起因在于变量晋升，导致内层的tmp变量笼罩了外层的tmp变量。
第二种场景，用来计数的循环变量泄露为全局变量。
var s = "hello";for (var i = 0; i < s.length; i++) { console.log(s[i]);}console.log(i); // 5下面代码中，变量i只用来管制循环，然而循环完结后，它并没有隐没，泄露成了全局变量。
ES6 的块级作用域
let实际上为 JavaScript 新增了块级作用域。
function f1() { let n = 5; if (true) { let n = 10; } console.log(n); // 5}下面的函数有两个代码块，都申明了变量n，运行后输入 5。这示意外层代码块不受内层代码块的影响。如果两次都应用var定义变量n，最初输入的值才是 10。
ES6 容许块级作用域的任意嵌套。
{ { { { { let insane = "Hello World"; } console.log(insane); // 报错 } } }}下面代码应用了一个五层的块级作用域，每一层都是一个独自的作用域。第四层作用域无奈读取第五层作用域的外部变量。
内层作用域能够定义外层作用域的同名变量。
{ { { { let insane = "Hello World"; { let insane = "Hello World"; } } } }}块级作用域的呈现，实际上使得取得广泛应用的匿名立刻执行函数表达式（匿名 IIFE）不再必要了。
// IIFE 写法(function () { var tmp = ...; ...}());// 块级作用域写法{ let tmp = ...; ...}块级作用域与函数申明
函数能不能在块级作用域之中申明？这是一个相当令人混同的问题。
ES5 规定，函数只能在顶层作用域和函数作用域之中申明，不能在块级作用域申明。
// 状况一if (true) { function f() {}}// 状况二try { function f() {}} catch (e) { // ...}下面两种函数申明，依据 ES5 的规定都是非法的。
然而，浏览器没有恪守这个规定，为了兼容以前的旧代码，还是反对在块级作用域之中申明函数，因而下面两种状况理论都能运行，不会报错。
ES6 引入了块级作用域，明确容许在块级作用域之中申明函数。ES6 规定，块级作用域之中，函数申明语句的行为相似于let，在块级作用域之外不可援用。
function f() { console.log("I am outside!");}(function () { if (false) { // 反复申明一次函数f function f() { console.log("I am inside!"); } } f();})();下面代码在 ES5 中运行，会失去“I am inside!”，因为在if内申明的函数f会被晋升到函数头部，理论运行的代码如下。
// ES5 环境function f() { console.log("I am outside!");}(function () { function f() { console.log("I am inside!"); } if (false) { } f();})();ES6 就齐全不一样了，实践上会失去“I am outside!”。因为块级作用域内申明的函数相似于let，对作用域之外没有影响。然而，如果你真的在 ES6 浏览器中运行一下下面的代码，是会报错的，这是为什么呢？
// 浏览器的 ES6 环境function f() { console.log("I am outside!");}(function () { if (false) { // 反复申明一次函数f function f() { console.log("I am inside!"); } } f();})();// Uncaught TypeError: f is not a function下面的代码在 ES6 浏览器中，都会报错。
原来，如果扭转了块级作用域内申明的函数的解决规定，显然会对老代码产生很大影响。为了加重因而产生的不兼容问题，ES6 在附录 B (opens new window)外面规定，浏览器的实现能够不恪守下面的规定，有本人的行为形式 (opens new window)。
容许在块级作用域内申明函数。
函数申明相似于var，即会晋升到全局作用域或函数作用域的头部。
同时，函数申明还会晋升到所在的块级作用域的头部。
留神，下面三条规定只对 ES6 的浏览器实现无效，其余环境的实现不必恪守，还是将块级作用域的函数申明当作let解决。
依据这三条规定，浏览器的 ES6 环境中，块级作用域内申明的函数，行为相似于var申明的变量。下面的例子理论运行的代码如下。
// 浏览器的 ES6 环境function f() { console.log("I am outside!");}(function () { var f = undefined; if (false) { function f() { console.log("I am inside!"); } } f();})();// Uncaught TypeError: f is not a function思考到环境导致的行为差别太大，应该防止在块级作用域内申明函数。如果的确须要，也应该写成函数表达式，而不是函数申明语句。
// 块级作用域外部的函数申明语句，倡议不要应用{ let a = "secret"; function f() { return a; }}// 块级作用域外部，优先应用函数表达式{ let a = "secret"; let f = function () { return a; };}另外，还有一个须要留神的中央。ES6 的块级作用域必须有大括号，如果没有大括号，JavaScript 引擎就认为不存在块级作用域。
// 第一种写法，报错if (true) let x = 1;// 第二种写法，不报错if (true) { let x = 1;}下面代码中，第一种写法没有大括号，所以不存在块级作用域，而let只能呈现在以后作用域的顶层，所以报错。第二种写法有大括号，所以块级作用域成立。
函数申明也是如此，严格模式下，函数只能申明在以后作用域的顶层。
// 不报错"use strict";if (true) { function f() {}}// 报错("use strict");if (true) function f() {}#const 命令#根本用法const申明一个只读的常量。一旦申明，常量的值就不能扭转。const PI = 3.1415;PI; // 3.1415PI = 3;// TypeError: Assignment to constant variable.下面代码表明扭转常量的值会报错。
const申明的变量不得扭转值，这意味着，const一旦申明变量，就必须立刻初始化，不能留到当前赋值。
const foo;
// SyntaxError: Missing initializer in const declaration
下面代码示意，对于const来说，只申明不赋值，就会报错。
const的作用域与let命令雷同：只在申明所在的块级作用域内无效。
if (true) { const MAX = 5;}MAX; // Uncaught ReferenceError: MAX is not definedconst命令申明的常量也是不晋升，同样存在暂时性死区，只能在申明的地位前面应用。if (true) { console.log(MAX); // ReferenceError const MAX = 5;}下面代码在常量MAX申明之前就调用，后果报错。
const申明的常量，也与let一样不可反复申明。
var message = "Hello!";let age = 25;// 以下两行都会报错const message = "Goodbye!";const age = 30;实质
const实际上保障的，并不是变量的值不得改变，而是变量指向的那个内存地址所保留的数据不得改变。对于简略类型的数据（数值、字符串、布尔值），值就保留在变量指向的那个内存地址，因而等同于常量。但对于复合类型的数据（次要是对象和数组），变量指向的内存地址，保留的只是一个指向理论数据的指针，const只能保障这个指针是固定的（即总是指向另一个固定的地址），至于它指向的数据结构是不是可变的，就齐全不能管制了。因而，将一个对象申明为常量必须十分小心。
const foo = {};// 为 foo 增加一个属性，能够胜利foo.prop = 123;foo.prop; // 123// 将 foo 指向另一个对象，就会报错foo = {}; // TypeError: "foo" is read-only下面代码中，常量foo贮存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把foo指向另一个地址，但对象自身是可变的，所以仍然能够为其增加新属性。
上面是另一个例子。
const a = [];a.push("Hello"); // 可执行a.length = 0; // 可执行a = ["Dave"]; // 报错下面代码中，常量a是一个数组，这个数组自身是可写的，然而如果将另一个数组赋值给a，就会报错。
如果真的想将对象解冻，应该应用Object.freeze办法。
const foo = Object.freeze({});
// 惯例模式时，上面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;
下面代码中，常量foo指向一个解冻的对象，所以增加新属性不起作用，严格模式时还会报错。
除了将对象自身解冻，对象的属性也应该解冻。上面是一个将对象彻底解冻的函数。
var constantize = (obj) => { Object.freeze(obj); Object.keys(obj).forEach((key, i) => { if (typeof obj[key] === "object") { constantize(obj[key]); } });};ES6 申明变量的六种办法
ES5 只有两种申明变量的办法：var命令和function命令。ES6 除了增加let和const命令，前面章节还会提到，另外两种申明变量的办法：import命令和class命令。所以，ES6 一共有 6 种申明变量的办法。
顶层对象的属性
顶层对象，在浏览器环境指的是window对象，在 Node 指的是global对象。ES5 之中，顶层对象的属性与全局变量是等价的。
window.a = 1;
a; // 1
a = 2;
window.a; // 2
下面代码中，顶层对象的属性赋值与全局变量的赋值，是同一件事。
顶层对象的属性与全局变量挂钩，被认为是 JavaScript 语言最大的设计败笔之一。这样的设计带来了几个很大的问题，首先是没法在编译时就报出变量未声明的谬误，只有运行时能力晓得（因为全局变量可能是顶层对象的属性发明的，而属性的发明是动静的）；其次，程序员很容易人不知;鬼不觉地就创立了全局变量（比方打字出错）；最初，顶层对象的属性是到处能够读写的，这十分不利于模块化编程。另一方面，window对象有实体含意，指的是浏览器的窗口对象，顶层对象是一个有实体含意的对象，也是不适合的。
ES6 为了扭转这一点，一方面规定，为了放弃兼容性，var命令和function命令申明的全局变量，仍旧是顶层对象的属性；另一方面规定，let命令、const命令、class命令申明的全局变量，不属于顶层对象的属性。也就是说，从 ES6 开始，全局变量将逐渐与顶层对象的属性脱钩。
var a = 1;
// 如果在 Node 的 REPL 环境，能够写成 global.a
// 或者采纳通用办法，写成 this.a
window.a; // 1
let b = 1;
window.b; // undefined
下面代码中，全局变量a由var命令申明，所以它是顶层对象的属性；全局变量b由let命令申明，所以它不是顶层对象的属性，返回undefined。
globalThis 对象
JavaScript 语言存在一个顶层对象，它提供全局环境（即全局作用域），所有代码都是在这个环境中运行。然而，顶层对象在各种实现外面是不对立的。
浏览器外面，顶层对象是window，但 Node 和 Web Worker 没有window。
浏览器和 Web Worker 外面，self也指向顶层对象，然而 Node 没有self。
Node 外面，顶层对象是global，但其余环境都不反对。
同一段代码为了可能在各种环境，都能取到顶层对象，当初个别是应用this变量，然而有局限性。
全局环境中，this会返回顶层对象。然而，Node.js 模块中this返回的是以后模块，ES6 模块中this返回的是undefined。
函数外面的this，如果函数不是作为对象的办法运行，而是单纯作为函数运行，this会指向顶层对象。然而，严格模式下，这时this会返回undefined。
不论是严格模式，还是一般模式，new Function('return this')()，总是会返回全局对象。然而，如果浏览器用了 CSP（Content Security Policy，内容安全策略），那么eval、new Function这些办法都可能无奈应用。
综上所述，很难找到一种办法，能够在所有状况下，都取到顶层对象。上面是两种勉强能够应用的办法。
// 办法一typeof window !== "undefined" ? window : typeof process === "object" && typeof require === "function" && typeof global === "object" ? global : this;// 办法二var getGlobal = function () { if (typeof self !== "undefined") { return self; } if (typeof window !== "undefined") { return window; } if (typeof global !== "undefined") { return global; } throw new Error("unable to locate global object");};ES2020 (opens new window)在语言规范的层面，引入globalThis作为顶层对象。也就是说，任何环境下，globalThis都是存在的，都能够从它拿到顶层对象，指向全局环境下的this。
垫片库global-this (opens new window)模仿了这个提案，能够在所有环境拿到globalThis。