es6学习一

es6 学习笔记


一。let
ES6新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。
{let a=0;}
1.for循环的计数器，就很合适使用let命令。
2.let 有作用于的概念 ，不存在变量提升；
3.暂时性死区 只要块级作用域内存在let 命令，它所声明的变量就"绑定"这个区域，不在受外部的影响；
 注：ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错
 你
 在let命令声明变量tmp之前，都属于变量tmp的“死区”。
 function bar(x = y, y = 2) {
 return [x, y];
}


bar(); // 报错
因为参数x默认值等于另一个参数y，而此时y还没有声明，属于”死区“。如果y的默认值是x，就不会报错，因为此时x已经声明了。


function bar(x = 2, y = x) {
 return [x, y];
}
bar(); // [2, 2]


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


二。块级作用域
1.ES5只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。
第一种场景，内层变量可能会覆盖外层变量。
var tmp = new Date();


function f() {
 console.log(tmp);
 if (false) {
   var tmp = "hello world";
 }
}
f(); // undefined


函数f执行后，输出结果为undefined，原因在于变量提升，导致内层的tmp变量覆盖了外层的tmp变量。




第二种场景，用来计数的循环变量泄露为全局变量。
var s = 'hello';


for (var i = 0; i < s.length; i++) {
 console.log(s[i]);
}


console.log(i); // 5


变量i只用来控制循环，但是循环结束后，它并没有消失，泄露成了全局变量。


2.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'}}}}};
使用了一个五层的块级作用域。外层作用域无法读取内层作用域的变量




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


// 函数声明语句
{
 let a = 'secret';
 function f() {
   return a;
 }
}


// 函数表达式
{
 let a = 'secret';
 let f = function () {
   return a;
 };
}
三。cost命令
1.const声明一个只读的常量。一旦声明，常量的就不能改变了。
const PI = 3.1415926;
//PI 3.1415926


PI = 3;
会报错


2.const一旦声明变量，就必须立即初始化，不能留到以后赋值。


3.const的作用域与let命令相同：只在声明所在的块级作用域内有效。


4.const命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用。


5.const声明的常量，也与let一样不可重复声明。;


const foo = {};
foo.prop = 123;


foo.prop
// 123


foo = {}; // TypeError: "foo" is read-only
常量foo储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把foo指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性。


const a = [];
a.push('Hello'); // 可执行
a.length = 0;    // 可执行
a = ['Dave'];    // 报错


常量a是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给a，就会报错。


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


onst foo = Object.freeze({});


// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;
常量foo指向一个冻结的对象，所以添加新属性不起作用，严格模式时还会报错。


6.除了将对象本身冻结，对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。


var constantize = (obj) => {
 Object.freeze(obj);
 Object.keys(obj).forEach( (key, value) => {
   if ( typeof obj[key] === 'object' ) {
     constantize( obj[key] );
   }
 });
};


ES5只有两种声明变量的方法：var命令和function命令。ES6除了添加let和const命令，后面章节还会提到，另外两种声明变量的方法：import命令和class命令。所以，ES6一共有6种声明变量的方法。


四。顶层对象的属性


在浏览器环境值得是window对象，在node指的是global对象，ES5中，顶层对象的属性与全局变量是等价的，
顶层对象的属性复制与全局对象的赋值，是同一件事。
window.a = 1 == a = 1;


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


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


五。顶层对象


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();
上面代码可以保证各种环境里面，global对象都是存在的。