《ES6标准入门》第二章：let 和 const 命令

下面的代码如果使用var，最后输出的是10。

var a = []; for (var i = 0; i < 10; i++) {
a[i] = function () { console.log(i);
};
}
a[6](); // 10

var a = []; for (let i = 0; i < 10; i++) {
        a[i] = function () { console.log(i);
};
}
a[6](); // 6

“暂时性死区”也意味着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(); // 报错

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 是很常见的，现在有了这种规定，避免此类错误就很容易了。

总之，暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。

不允许重复声明

// 报错
function () { 
let a = 10; 
var a = 1;
} 
// 报错 
function () {
let a = 10; 
let a = 1;
}

function func(arg) {
let arg; // 报错
 } 
function func(arg) {
{
let arg; // 不报错
 }
}

块级作用域

为什么需要块级作用域？

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 的块级作用域

function f1() {
let n = 5; 
if (true) { 
let n = 10;
} 
console.log(n); // 5
 }

上面的函数有两个代码块，都声明了变量n，运行后输出5。这表示外层代码块不受内层代码块的影响。如果使用var定义变量n，最后输出的值就是10。

{{{{{let insane = 'Hello World'}}}}};

{{{{
{
let insane = 'Hello World'
} 
console.log(insane); // 报错 
}}}};
内层作用域可以定义外层作用域的同名变量。
{{{{ 
let insane = 'Hello World';
 {
let insane = 'Hello World'
}
}}}};

// IIFE 写法
 (function () {
var tmp = ...;
...
}());
// 块级作用域写法 
{ 
let tmp = ...;
 ...
}

块级作用域与函数声明

函数能不能在块级作用域之中声明？这是一个相当令人混淆的问题。

// 情况一 
if (true) {
function f() 
{
}
} 
// 情况二 
try { function f()
{
}
} catch(e) { 
// ... 
}

上面两种函数声明，根据 ES5 的规定都是非法的。

但是，浏览器没有遵守这个规定，为了兼容以前的旧代码，还是支持在块级作用域之中声明函数，因此上面两种情况实际都能运行，不会报错。

function f() { 
console.log('I am outside!');
 }
(function () {
if (false) { 
// 重复声明一次函数f
function f() { 
console.log('I am inside!');
 }
 }
 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在附录B里面规定，浏览器的实现可以不遵守上面的规定，有自己的行为方式。

• 允许在块级作用域内声明函数。
• 函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
• 同时，函数声明还会提升到所在的块级作用域的头部。

注意，上面三条规则只对 ES6 的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作let处理。

// 浏览器的 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 环境 
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;
};
}

// 不报错
'use strict'; if (true) {
function f()
{
}
} 
// 报错
'use strict';
if (true) 
function f() 
{
}

do 表达式

{ 
let t = f();
 t = t * t + 1;
}

上面代码中，块级作用域将两个语句封装在一起。但是，在块级作用域以外，没有办法得到t的值，因为块级作用域不返回值，除非t是全局变量。

let x = do {
let t = f();
t * t + 1;
};

上面代码中，变量x会得到整个块级作用域的返回值。

const 命令

基本用法

const PI = 3.1415;
PI // 3.1415 
PI = 3; // TypeError: Assignment to constant variable.

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

上面代码表示，对于const来说，只声明不赋值，就会报错。

if (true) { 
const MAX = 5; 
} 
MAX // Uncaught ReferenceError: MAX is not defined 

if (true) { 
  console.log(MAX); // ReferenceError  
const MAX = 5; 
}

上面代码在常量MAX声明之前就调用，结果报错。

var message = "Hello!";
let age = 25; 
// 以下两行都会报错
const message = "Goodbye!"; 
const age = 30;

本质

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，就会报错。

const foo = Object.freeze({}); 
// 常规模式时，下面一行不起作用； 
// 严格模式时，该行会报错 
foo.prop = 123;

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.a = 1;
a // 1 
a = 2; 
window.a // 2

上面代码中，顶层对象的属性赋值与全局变量的赋值，是同一件事。

顶层对象的属性与全局变量挂钩，被认为是JavaScript语言最大的设计败笔之一。这样的设计带来了几个很大的问题，首先是没法在编译时就报出变量未声明的错误，只有运行时才能知道（因为全局变量可能是顶层对象的属性创造的，而属性的创造是动态的）；其次，程序员很容易不知不觉地就创建了全局变量（比如打字出错）；最后，顶层对象的属性是到处可以读写的，这非常不利于模块化编程。另一方面，window对象有实体含义，指的是浏览器的窗口对象，顶层对象是一个有实体含义的对象，也是不合适的。

var a = 1;
  // 如果在Node的REPL环境，可以写成global.a 
  // 或者采用通用方法，写成this.a  
window.a // 1 
let b = 1;  
window.b // undefined

上面代码中，全局变量a由var命令声明，所以它是顶层对象的属性；全局变量b由let命令声明，所以它不是顶层对象的属性，返回undefined。

global 对象

ES5的顶层对象，本身也是一个问题，因为它在各种实现里面是不统一的。

• 浏览器里面，顶层对象是window，但 Node 和 Web Worker 没有window。
• 浏览器和 Web Worker 里面，self也指向顶层对象，但是Node没有self。
• Node 里面，顶层对象是global，但其他环境都不支持。

同一段代码为了能够在各种环境，都能取到顶层对象，现在一般是使用this变量，但是有局限性。

• 全局环境中，this会返回顶层对象。但是，Node模块和ES6模块中，this返回的是当前模块。
• 函数里面的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');
  };

现在有一个提案，在语言标准的层面，引入global作为顶层对象。也就是说，在所有环境下，global都是存在的，都可以从它拿到顶层对象。

// CommonJS的写法
require('system.global/shim')(); 
// ES6模块的写法 
import shim from 'system.global/shim'; shim();

// CommonJS的写法
varglobal =require('system.global')(); 
// ES6模块的写法
importgetGlobalfrom 'system.global'; 
constglobal = getGlobal();

上面代码将顶层对象放入变量global。