let, const

Note ES6 ECMAScript6

函数作用域，块级作用域

ES5 只有全局作用域和函数作用域，没有块级作用域

函数作用域

定义在函数中的参数和变量在函数外部是不可见的

#include <stdio.h> 
void main() { 
    int i=2; 
    i--; 
    if(i) 
    { 
        int j=3; 
    } 
    printf("%d/n",j); // use an undefined variable:j
}

块级作用域

任何一对花括号 {} 中的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的

ES6 的块级作用域允许声明函数的规则，只在使用大括号的情况下成立，如果没有使用大括号，就会报错。

/* -------------------------------------------- */
// 在块外，块中定义的变量i仍然是可以访问的。也就是说，JS并不支持块级作用域。
for(var i=0;i<3;i++){
    // do something
}
alert(i); // 3
/* -------------------------------------------- */
// 利用 JS 的闭包特性使 JS 支持块级作用域
(function (){ 
    for(var i=0;i<4;i++){ 
    } 
})(); 
alert(i); // i is not defined

函数声明

ES5 规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。考虑到环境导致的行为差异太大，应该避免在块级作用域内声明函数。如果确实需要，也应该写成函数表达式，而不是函数声明语句。

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

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

// Browser with ES6 environment
function f() { console.log('I am outside!'); }
(function () {
  //// var f = undefined;
  if (false) {
    function f() { console.log('I am inside!'); }
  }
  f(); // TypeError: f is not a function
}());

let

ES6 新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。

{
  let a = 1;
  var b = 1;
}
a // ReferenceError: a is not defined.
b // 1

for 循环有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。

for (let i = 0; i < 3; i++) {
  let i = 'x';
  console.log(i); // x
}

变量提升，暂时性死区(temporal dead zone | TDZ)

var命令会发生”变量提升“现象，即变量可以在声明之前使用，值为undefined。ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错，在语法上，称为暂时性死区（temporal dead zone，简称 TDZ），此时，typeof不再是一个百分之百安全的操作。

console.log(a); // undefined
var a = 2;
console.log(b); // ReferenceError: c is not defined
let b = 2;

if (true) {
  // TDZ Start
  tmp = 'abc'; // ReferenceError: tmp is not defined
  console.log(tmp); // ReferenceError: tmp is not defined
  let tmp; 
  // TDZ End
  console.log(tmp); // undefined
  tmp = 123;
  console.log(tmp); // 123
}
let x = x; // ReferenceError: x is not defined
typeof x; // ReferenceError: x is not defined
let x;

不允许重复声明

let不允许在相同作用域内，重复声明同一个变量。

function func() {
  let a = 1;
  var a = 1;
}
func(); // SyntaxError: Identifier 'a' has already been declared
function func() {
  let a = 1;
  let a = 1;
}
func(); // SyntaxError: Identifier 'a' has already been declared
function func(arg) {
  let arg;
}
func(); // SyntaxError: Identifier 'arg' has already been declared

const

const声明一个只读的常量。一旦声明，常量的值就不能改变。并且，const一旦声明变量，就必须立即初始化，不能留到以后赋值。

const A = 1;
A // 1
A = 2; // TypeError: Assignment to constant variable.
const B; // SyntaxError: Missing initializer in const declaration

本质

const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址所保存的数据不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指向实际数据的指针，const只能保证这个指针是固定的（即总是指向另一个固定的地址），至于它指向的数据结构是不是可变的，就完全不能控制了。

const foo = {};
// 为 foo 添加一个属性，可以成功
foo.prop = 123;
foo.prop // 123
// 将 foo 指向另一个对象，就会报错
foo = {}; // TypeError: "foo" is read-only

如果真的想将对象冻结，应该使用Object.freeze方法。

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] );
    }
  });
};

顶层对象的属性

JavaScript 语言中，顶层对象的属性与全局变量挂钩，是一大设计败笔。

ES6 规定，为了保持兼容性，var命令和function命令声明的全局变量，依旧是顶层对象的属性；另一方面规定，let命令、const命令、class命令声明的全局变量，不属于顶层对象的属性

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

参考

• ECMAScript® 2015 Language Specification
• let 和 const 命令