（1）函数参数的默认值
ES6之前不能为函数的参数指定默认值，ES6允许，直接将参数默认值直接写在参数定义的后面。
function log(x, y = 'World') {
console.log(x, y);
}
这种写法除了简洁，还有两个好处，阅读代码的人不用看函数体或文档就知道，哪些参数可以
省略，其次，利用将来代码的优化，即使未来的版本在对外接口中，彻底拿掉这个参数，也不会导致以前的代码无法运行。
有几个需要注意的地方：
1.参数变量默认是声明的，所以不能再用let或const声明
function foo(x = 5) {
let x = 1; // error
const x = 2; // error
}
2.使用参数默认值时，函数不能有同名的参数
// 报错
function foo(x, x, y = 1) {
// ...
}
但是下面的不报错
// 不报错
function foo(x, x, y) {
// ...
}
3.参数默认值不是传值的，而是每次都重新计算默认值表达式的值，也就是说参数默认值是
惰性求值的。
let x = 99;
function foo(p = x + 1) {
console.log(p);
}
foo() // 100
x = 100;
foo() // 101
（2）与解构赋值默认值结合使用
function foo({x, y = 5}) {
console.log(x, y);
}
foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined
注意：如果函数foo调用时没提供参数，变量x和y就不会生成，从而报错。通过提供函数参数的默认值，就可以避免这种情况。
function foo({x, y = 5} = {}) {
console.log(x, y);
}
foo() // undefined 5
作为练习，请问下面两种写法有什么差别？
// 写法一
function m1({x = 0, y = 0} = {}) {
return [x, y];
}
// 写法二
function m2({x, y} = { x: 0, y: 0 }) {
return [x, y];
}
// 函数没有参数的情况
m1() // [0, 0]
m2() // [0, 0]
// x 和 y 都有值的情况
m1({x: 3, y: 8}) // [3, 8]
m2({x: 3, y: 8}) // [3, 8]
// x 有值，y 无值的情况
m1({x: 3}) // [3, 0]
m2({x: 3}) // [3, undefined]
// x 和 y 都无值的情况
m1({}) // [0, 0];
m2({}) // [undefined, undefined]
m1({z: 3}) // [0, 0]
m2({z: 3}) // [undefined, undefined]
（3）参数默认值的位置
通常，定义了默认值的参数，应该是函数的尾参数，这样不仅是容易看出来，
而是如果非尾部参数设置了默认值，这个参数没法省略。
function f(x = 1, y) {
return [x, y];
}
f() // [1, undefined]
f(2) // [2, undefined])
f(, 1) // 报错
f(undefined, 1) // [1, 1] 显式输入undefined，触发该参数的默认值
（4）函数的length属性
指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。
也就是说，指定了默认值后，length属性将失真。
如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。
(function (a, b, c = 5) {}).length // 2
(function(...args) {}).length // 0
(function (a = 0, b, c) {}).length // 0
（5）作用域
一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域。
等到初始化结束，之歌作用域就会消失，这种语法行为，在不设置参数默认值时，时不会出现的。
看看下面的例子：
例子1：
var x = 1;
function f(x, y = x) {
console.log(y);
}
f(2) // 2
例子2：
let x = 1;
function f(y = x) {
let x = 2;
console.log(y);
}
f() // 1
例子3：var x = 1;
function foo(x, y = function() { x = 2; }) {
var x = 3;
y();
console.log(x);
}
foo() // 3
x // 1
（6）函数参数默认值的应用
利用参数默认值，可以指定某个参数不得省略，否则就抛出一个错误
function throwIfMissing() {
throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()) {
return mustBeProvided;
}
foo()
// Error: Missing parameter
另外，可以将参数默认值设置为undefined，表明这个参数是可以省略的。
（7）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
下面这个例子用rest参数代替了arguments变量
// arguments变量的写法
function sortNumbers() {
return Array.prototype.slice.call(arguments).sort();
}
// rest参数的写法
const sortNumbers = (...numbers) => numbers.sort();
说明：1.arguments对象不是数组，而是一个类似数组的对象，所以为了使用数组的方法，
必须使用Array.prototype.slice.call先将其转为数组。而rest参数就不存在这个问题，
它是一个真正的数组，数组特有的方法都可以使用。
注意：rest参数之后不能再有其他参数（即只能作为最后一个参数），否则会报错。
2.函数的length属性，不包括 rest 参数。
（8）严格模式
从es5开始，函数内部就可以设定为严格模式，ES2016做了修改，规定只要函数参数使用了
默认值，解构赋值或扩展运算符，那么函数内部就不能显示设定为严格模式，否则报错。
这样规定的原因是，函数内部的严格模式，同时适用于函数体和函数参数。但是，函数执行的时候，先执行函数参数，然后再执行函数体。这样就有一个不合理的地方，只有从函数体之中，
才能知道参数是否应该以严格模式执行，但是参数却应该先于函数体执行。
有两种方法可以规避这种限制：1.设定全局性的严格模式，这是合法的。
2.把函数包在一个无参数的立即执行函数里面。
（9）name属性
函数的name属性返回该函数的函数名。
说明：这个属性很早就被浏览器广泛支持，但知道ES6才写入了标准。
ES6对这个属性行为做了一些修改：
1.将匿名函数赋值给一个变量，ES5返回空字符串，而ES6返回实际的函数名。
例子：
var f = function () {};
// ES5
f.name // ""
// ES6
f.name // "f"
注：将一个具名函数赋值给一个变量，则 ES5 和 ES6 的name属性都返回这个具名函数原本的名字。
2.Function构造函数返回的函数实例，name属性的值为anonymous。
(new Function).name // "anonymous"
3.bind返回的函数，name属性值会加上bound前缀。
function foo() {};
foo.bind({}).name // "bound foo"
(function(){}).bind({}).name // "bound "
(10)箭头函数
最简单的例子：
var f = v => v;
// 等同于
var f = function (v) {
return v;
};
1.如果箭头函数不需要参数或需要多个参数，就是用一个圆括号代表参数部分。
例如：
var f = () => 5;
var sum = (num1, num2) => num1 + num2;
2.如果箭头函数的代码块部分多于一条语句，则需要使用大括号将他们括起来，并且使用return返回
例如：var sum = (num1, num2) => { return num1 + num2; }
3.如果箭头函数只有一行代码，且不需要返回值，则可以采用下面的写法，就不用写大括号了
let fn = () => void doesNotReturn();
4.箭头函数可以与变量解构结合使用
const full = ({ first, last }) => first + ' ' + last;
const numbers = (...nums) => nums;
numbers(1, 2, 3, 4, 5)
// [1,2,3,4,5]
箭头函数的使用注意点：
1.函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
2.不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
3.不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
4.不可以使用yield命令，因此箭头函数不能用作 Generator 函数。
在这4点中，第一点尤其值得注意：
this对象的指向是可变的，但是在箭头函数中，它是固定的。
this指向的固定化，并不是因为箭头函数内部有绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数。
除了this，以下三个变量在箭头函数之中也是不存在的，指向外层函数的对应变量：arguments、super、new.target。
另外，由于箭头函数没有自己的this，所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向。
不要使用箭头函数的场合：
1.定义对象的方法，且该方法内部包括this
2.需要动态this的时候，也不应该使用箭头函数
3.函数体很复杂，有许多行，或函数内部有大量读写操作，不单纯是为了计算值，也不该使用箭头函数。
嵌套的箭头函数
（11）尾调用优化
1.尾调用的概念：某个函数的最后一步是调用另一个函数。
例子：这是尾调用
function f(x){
return g(x);
}
这些都不是尾调用
// 情况一
function f(x){
let y = g(x);
return y;
}
// 情况二
function f(x){
return g(x) + 1;
}
// 情况三
function f(x){
g(x);//这相当于，调用完函数后返回undefined
}
尾调用不一定出现在函数尾部，只要是最后一步操作即可。
2.尾调用优化
由于函数调用会形成一个调用栈，而尾调用是函数的最后一步，所以不需要保留外层函数的
调用帧，只需直接用内层函数的调用帧取代外层函数的调用帧即可。
这就叫做“尾调用优化”（Tail call optimization），即只保留内层函数的调用帧。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存。这就是“尾调用优化”的意义。
注意，只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。
3.尾递归
函数调用自身，称为递归，如果尾调用自身，则称为尾递归。
递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误
例子：
阶乘函数
function factorial(n) {
if (n === 1) return 1;
return n * factorial(n - 1);
}
factorial(5) // 120
改写成尾递归
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total);
}
factorial(5, 1) // 120
4.递归函数的改写
尾递归的实现，需要改写递归函数，确保最后一步只调用自身，做到这一点的方法，就是
把所有用到的内部变量改写成函数的参数。
这样做的缺点是不直观，例如为什么计算5的阶乘，需要传入两个参数？
解决这个问题有两个方法：a.在尾递归的函数之外，再提供一个正常形式的函数。
5.采用ES6的函数默认值
注：尾调用模式仅在严格模式下生效，但是在正常模式或不支持该功能的环境中我们可以自己
实现尾递归优化
它的原理非常简单。尾递归之所以需要优化，原因是调用栈太多，造成溢出，那么只要减少调用栈，就不会溢出。怎么做可以减少调用栈呢？就是采用“循环”换掉“递归”。
（12）尾逗号
ES2017 允许函数的最后一个参数有尾逗号（trailing comma）。
此前，函数定义和调用时，都不允许最后一个参数后面出现逗号。
方便修改代码参数，或调整参数次序时，来回修改逗号。