let 命令
基本用法
ES6 新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效
{
let a = 10;
var b = 1;
}
console.log(a); // ReferenceError: a is not defined.
console.log(b); // 1
// for循环的计数器，就很合适使用let命令 循环为访问不到
for (let i = 0; i < 10; i++) {
// ...
}
console.log(i);
// ReferenceError: i is not defined
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10
变量i是var命令声明的，在全局范围内都有效，所以全局只有一个变量i。
// 声明的变量仅在块级作用域内有效
var a = [];
for (let i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 6
// babel 在线转换
var a = [];
var _loop = function _loop(i) {
a[i] = function () {
console.log(i);
};
};
for (var i = 0; i < 10; i++) {
_loop(i);
}
a[6]();
for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域
// 这表明函数内部的变量i与循环变量i不在同一个作用域，有各自单独的作用域
for (let i = 0; i < 3; i++) {
let i = 'abc';
console.log(i);
}
// abc
// abc
// abc
不存在变量提升
-
var：命令会发生”变量提升“现象，即变量可以在声明之前使用，值为undefined。按照一般的逻辑，变量应该在声明语句之后才可以使用 -
let：命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错
// var 的情况
console.log(foo); // 输出undefined
var foo = 2;
// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;
暂时性死区
使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）
// 存在全局变量tmp，但是块级作用域内let又声明了一个局部变量tmp，
// 导致后者绑定这个块级作用域，所以在let声明变量前，对tmp赋值会报错。
var tmp = 123;
if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}
// 在let命令声明变量tmp之前，都属于变量tmp的“死区”。
if (true) {
// TDZ开始
tmp = 'abc'; // ReferenceError
console.log(tmp); // ReferenceError
let tmp; // TDZ结束
console.log(tmp); // undefined
tmp = 123;
console.log(tmp); // 123
}
// “暂时性死区”也意味着typeof不再是一个百分之百安全的操作
// 变量x使用let命令声明，所以在声明之前，都属于x的“死区”，只要用到该变量就会报错
typeof x; // ReferenceError
let x;
// 如果一个变量根本没有被声明，使用typeof反而不会报错
typeof undeclared_variable // "undefined"
变量一定要在声明之后使用，否则就报错
// 隐蔽的死区
// 参数x默认值等于另一个参数y，而此时y还没有声明，属于”死区“。
function bar(x = y, y = 2) {
return [x, y];
}
bar(); // 报错
// 正确方式
function bar(x = 2, y = x) {
return [x, y];
}
bar(); // [2, 2]
// 不报错
var x = x;
// 报错
let x = x;
// ReferenceError: x is not defined
代码报错，也是因为暂时性死区。使用let声明变量时，只要变量在还没有声明完成前使用，就会报错。上面这行就属于这个情况，在变量x的声明语句还没有执行完成前，就去取x的值，导致报错”x 未定义“
ES6 规定暂时性死区和let、const语句不出现变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导致意料之外的行为。这样的错误在 ES5 是很常见的，现在有了这种规定，避免此类错误就很容易了
不允许重复声明
let不允许在相同作用域内，重复声明同一个变量。
// 报错
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 只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景
为什么需要块级作用域
- 内层变量可能会覆盖外层变量
// 原因在于变量提升，导致内层的tmp变量覆盖了外层的tmp变量
var tmp = new Date();
function f() {
console.log(tmp);
if (false) {
var tmp = 'hello world';
}
}
f(); // undefined
- 用来计数的循环变量泄露为全局变量
// 变量i只用来控制循环，但是循环结束后，它并没有消失，泄露成了全局变量
var s = 'hello';
for (var i = 0; i < s.length; i++) {
console.log(s[i]);
}
console.log(i); // 5
ES6 的块级作用域
let实际上为 JavaScript 新增了块级作用域
块级作用域与函数声明
// 如果两次都使用var定义变量n，最后输出的值才是10
function f1() {
let n = 5;
if (true) {
let n = 10;
}
console.log(n); // 5
}
- ES6 允许块级作用域的任意嵌套
- 外层作用域无法读取内层作用域的变量
- 内层作用域可以定义外层作用域的同名变量
- 广泛应用的立即执行函数表达式（IIFE）不再必要
{{{{{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 = ...;
...
}
块级作用域与函数声明
- 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 环境
// 因为在if内声明的函数f会被提升到函数头部
function f() { console.log('I am outside!'); }
(function () {
function f() { console.log('I am inside!'); }
if (false) {
}
f();
}());
ES6 浏览器中运行一下上面的代码，是会报错的，这是为什么呢？
原来，如果改变了块级作用域内声明的函数的处理规则，显然会对老代码产生很大影响。为了减轻因此产生的不兼容问题，ES6在附录B里面规定，浏览器的实现可以不遵守上面的规定，有自己的行为方式
- 允许在块级作用域内声明函数。
- 函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
- 同时，函数声明还会提升到所在的块级作用域的头部。
- 在浏览器的 ES6 环境中，块级作用域内声明的函数，行为类似于var声明的变量
- 环境导致的行为差异太大，应该避免在块级作用域内声明函数
// 应该写成函数表达式，而不是函数声明语句
// 函数声明语句
{
let a = 'secret';
function f() {
return a;
}
}
// 函数表达式
{
let a = 'secret';
let f = function () {
return a;
};
}
- ES6 的块级作用域允许声明函数的规则，只在使用大括号的情况下成立，如果没有使用大括号，就会报错
// 不报错
'use strict';
if (true) {
function f() {}
}
// 报错
'use strict';
if (true)
function f() {}
do 表达式
本质上，块级作用域是一个语句，将多个操作封装在一起，没有返回值
{
let t = f();
t = t * t + 1;
}
提案 do 表达式
// 变量x会得到整个块级作用域的返回值
let x = do {
let t = f();
t * t + 1;
};
const 命令
基本用法
const声明一个只读的常量。一旦声明，常量的值就不能改变。且必须立即初始化，不能留到以后赋值
// 改变常量的值会报错
const PI = 3.1415;
PI // 3.1415
PI = 3;
// TypeError: Assignment to constant variable.
// 只声明不赋值，就会报错。
const foo;
// SyntaxError: Missing initializer in const declaration
const的作用域与let命令相同：只在声明所在的块级作用域内有效
if (true) {
const MAX = 5;
}
MAX // Uncaught ReferenceError: MAX is not defined
const命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用
// 常量MAX声明之前就调用，结果报错
if (true) {
console.log(MAX); // ReferenceError
const MAX = 5;
}
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指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性
// 数组本身是可写的，但是如果将另一个数组赋值给a，就会报错
const a = [];
a.push('Hello'); // 可执行
a.length = 0; // 可执行
a = ['Dave']; // 报错
对象冻结
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命令
- var命令
- function命令
- import命令
- class命令
顶层对象的属性
顶层对象，在浏览器环境指的是window对象，在Node指的是global对象。
ES5之中，顶层对象的属性与全局变量是等价的
顶层对象的属性与全局变量挂钩的几大问题
- 没法在编译时就报出变量未声明的错误，只有运行时才能知道
- 容易不知不觉地就创建了全局变量
- 顶层对象的属性是到处可读写 非常不利于模块化编程
- window对象有实体含义，顶层对象是有实体含义的对象
ES6 的实现
- var 和 function 声明全局变量 依旧是顶层对象的属性
- let、const、class声明的全局变量，不属于顶层对象
var a = 1;
// 如果在Node的REPL环境，可以写成global.a
// 或者采用通用方法，写成this.a
window.a // 1
let b = 1;
window.b // 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();
// 顶层对象放入变量global。
// CommonJS 的写法
var global = require('system.global')();
// ES6 模块的写法
import getGlobal from 'system.global';
const global = getGlobal();