ES6

1、let 和 const

var 声明的变量全局范围内都有效。循环内return i 返回的最终i的值的引用
let 声明的变量只在它所在的代码块有效

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

2、变量的结构赋值

解构: ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值

数组的解构

es5: 
let a = 1;
let b = 2;
let c = 3;
es6: 
let [a, b, c] = [1, 2, 3];
let [head, ...tail] = [1, 2, 3, 4]
head // 1
tail // [2, 3, 4]
// 如果解构不成功，变量的值就等于undefined。
let [foo] = []; // foo = undefined
let [bar, foo] = [1]; //  foo = undefined

对象的解构

let { foo, bar } = { foo: "aaa", bar: "bbb" }
foo // "aaa"
bar // "bbb"

3、字符串扩展

4、正则的扩展

5、数值的扩展

6、函数的扩展

参数默认值

function (x = 1) {...}

与解构赋值结合使用

function foo({x, y = 5}) {
  console.log(x, y);
}
foo({}) // undefined 5

函数的length属性

指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，length属性将失真。

(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2

如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。

(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1

应用

可以通过设置参数的默认值判断一个这个函数被调用时是否有参数传递进来

function err() {
  throw new Error('Missing parameter');
}
function foo(arg = err()) {
  return arg;
}
foo()
// Error: Missing parameter

rest参数

ES6 引入 rest 参数（形式为...变量名），用于获取函数的多余参数，这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。

function add(...values) {
  let sum = 0;
  for (var val of values) {
    sum += val;
  }
  return sum;
}
add(2, 5, 3) // 10

严格模式

从 ES5 开始，函数内部可以设定为严格模式。ES2016 做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。

name属性

函数的name属性，返回该函数的函数名,这个属性早就被浏览器广泛支持，但是直到 ES6，才将其写入了标准

• Function构造函数返回的函数实例，name属性的值为anonymous。
• 如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名。
• Function构造函数返回的函数实例，name属性的值为anonymous。
• bind返回的函数，name属性值会加上bound前缀。

箭头函数

ES6 允许使用“箭头”（=>）定义函数。

• 函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
• 不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
• 不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
• 不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

::运算符

箭头函数可以绑定this对象，大大减少了显式绑定this对象的写法（call、apply、bind）。但是，箭头函数并不适用于所有场合，所以现在有一个提案，提出了“函数绑定”（function bind）运算符，用来取代call、apply、bind调用。
函数绑定运算符是并排的两个冒号（::），双冒号左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境（即this对象），绑定到右边的函数上面。箭头函数可以绑定this对象，大大减少了显式绑定this对象的写法（call、apply、bind）。但是，箭头函数并不适用于所有场合，所以现在有一个提案，提出了“函数绑定”（function bind）运算符，用来取代call、apply、bind调用。
函数绑定运算符是并排的两个冒号（::），双冒号左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境（即this对象），绑定到右边的函数上面。

foo::bar;
// 等同于
bar.bind(foo);
foo::bar(...arguments);
// 等同于
bar.apply(foo, arguments);
const hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn(obj, key) {
  return obj::hasOwnProperty(key);
}

尾调用优化

尾调用（Tail Call）是函数式编程的一个重要概念，本身非常简单，一句话就能说清楚，就是指某个函数的最后一步是调用另一个函数

尾调用优化：我们知道，函数调用会在内存形成一个“调用记录”，又称“调用帧”（call frame），保存调用位置和内部变量等信息。如果在函数A的内部调用函数B，那么在A的调用帧上方，还会形成一个B的调用帧。等到B运行结束，将结果返回到A，B的调用帧才会消失。如果函数B内部还调用函数C，那就还有一个C的调用帧，以此类推。所有的调用帧，就形成一个“调用栈”（call stack）。

尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用帧，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用帧，取代外层函数的调用帧就可以了。这就叫做“尾调用优化”（Tail call optimization），即只保留内层函数的调用帧。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存。这就是“尾调用优化”的意义。

注意，只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。所以闭包是不能进行尾调用优化的。