====箭头函数(重点)
-----ES6 允许使用“箭头”（=>）定义函数。
var f = v => v;
f(20)//20
等同于：
var f = function(v) {
return v;
};
f(20)//20
-----如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
var f = () => 5;
// 等同于
var f = function () { return 5 };
var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {
return num1 + num2;
};
-----如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。
var sum = (num1, num2) => { return num1 + num2; }
-----由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号。
var getTempItem = id => ({ id: id, name: "Temp" });
-----箭头函数可以与变量解构结合使用。
const full = ({ first, last }) => first + 'xxxx ' + last;
// 等同于
function full(person) {
return person.first + ' xxxx' + person.last;
}
箭头函数使得表达更加简洁,下面代码只用了两行，就定义了两个简单的工具函数。如果不用箭头函数，可能就要占用多行，而且还不如现在这样写醒目。
const isEven = n => n % 2 == 0;
const square = n => n * n;
-----箭头函数的一个用处是简化回调函数。
function fn(a,b,f){
return f(a,b)
}
// 正常函数写法
fn(10,20,function(n1,n2){
return n1*n2
})
// 箭头函数写法
fn(10,20,(n1,n2)=>n1*n2)
-----rest 参数箭头函数结合
const numbers = (...nums) => nums;
numbers(1, 2, 3, 4, 5)// [1,2,3,4,5]
const mustAndOption= (head, ...tail) => [head, tail];
mustAndOption(1, 2, 3, 4, 5)// [1,[2,3,4,5]]
=====箭头使用注意点!!!!
函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
//----对比1
function foo1(n) {
this.tool=n
}
var f1=new foo1(function(){this.b=10})
f1.tool()
console.log(window.b)
console.log(f1.b)
//----对比2
function foo(n) {
this.tool=n
}
var f=new foo(() => this.a=10)
f.tool()
console.log(window.a)
console.log(f.a)
不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
var a=()=>console.log(666)
new a()//Uncaught TypeError: a is not a constructor
除了this，arguments也是不是它自己的
function foo() {
setTimeout(() => {
console.log(arguments);
}, 100);
}
foo(2, 4, 6, 8)// [2, 4, 6, 8]
上面代码中，箭头函数内部的变量arguments，其实是函数foo的arguments变量。
长期以来，JavaScript 语言的this对象一直是一个令人头痛的问题,初学者们不必着急,慢慢来必定走向人生巅峰
====嵌套的箭头函数:箭头函数内部，还可以再使用箭头函数。
----前一个函数的输出是后一个函数的输入。
const p1= a => a + 1;
const p2= a => a * 2;
p2(p1(5))
----下面是一个 ES5 语法的多重嵌套函数。
function insert(value) {
return {into: function (array) {
return {after: function (afterValue) {
array.splice(array.indexOf(afterValue) + 1, 0, value);
return array;
}};
}};
}
insert(2).into([1, 3]).after(1); //[1, 2, 3]
使用箭头函数改写。
let insert = (value) => ({into: (array) => ({after: (afterValue) => {
array.splice(array.indexOf(afterValue) + 1, 0, value);
return array;
}})});
insert(2).into([1, 3]).after(1); //[1, 2, 3]
====尾调用优化
什么是尾调用？
尾调用（Tail Call）是函数式编程的一个重要概念，本身非常简单，一句话就能说清楚，就是指某个函数的最后一步是调用另一个函数。
function f(x){
return g(x);
}
上面代码中，函数f的最后一步是调用函数g，这就叫尾调用。
以下三种情况，都不属于尾调用。
// 情况一
function f(x){
let y = g(x);
return y;
}
// 情况二
function f(x){
return g(x) + 1;
}
// 情况三
function f(x){
g(x);
}
上面代码中，情况一是调用函数g之后，还有赋值操作，所以不属于尾调用，就算语义完全一样。情况二也属于调用后还有操作，即使写在一行内。情况三等同于下面的代码。
function f(x){
g(x);
return undefined;
}
尾调用不一定出现在函数尾部，只要是最后一步操作即可。
function f(x) {
if (x > 0) {
return m(x)
}
return n(x);
}
上面代码中，函数m和n都属于尾调用，因为它们都是函数f的最后一步操作。
----尾调用优化
尾调用之所以与其他调用不同，就在于它的特殊的调用位置。
尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用
function f() {
let m = 1;
let n = 2;
return g(m + n);
}
f();
// 等同于
function f() {
return g(3);
}
f();
// 等同于
g(3);
上面代码中，如果函数g不是尾调用，函数f就需要保存内部变量m和n的值、g的调用位置等信息。但由于调用g之后，函数f就结束了，所以执行到最后一步，完全可以删除f(x)的调用，只保留g(3)的调用。
这就叫做“尾调用优化”（Tail call optimization），即引擎执行过程中只保留内层函数的调用。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用只有一项，这将大大节省内存。这就是“尾调用优化”的意义。
注意，只有不再用到外层函数的内部变量，内层函数的调用才会取代外层函数的调用，否则就无法进行“尾调用优化”。
function addOne(a){
var one = 1;
function inner(b){
return b + one;
}
return inner(a);
}
上面的函数不会进行尾调用优化，因为内层函数inner用到了外层函数addOne的内部变量one。
====尾递归
函数调用自身，称为递归。如果尾调用自身，就称为尾递归。
递归非常耗费内存，因为需要同时保存成千上百个调用，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误。
----下面是一个正常的递归函数。
function sum(x, y) {
if (y > 0) {
return sum(x + 1, y - 1);
} else {
return x;
}
}
sum(1, 100000)
// Uncaught RangeError: Maximum call stack size exceeded(…)
上面代码中，sum是一个递归函数，参数x是需要累加的值，参数y控制递归次数。一旦指定sum递归100000次，就会报错，提示超出调用栈的最大次数。
-----阶乘优化
function factorial(n) {
if (n === 1) return 1;
return n * factorial(n - 1);
}
factorial(5) // 120
上面代码是一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录，复杂度 n
如果改写成尾递归，只保留一个调用记录，复杂度1
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total);
}
factorial(5, 1) // 120
由此可见，“尾调用优化”对递归操作意义重大，所以一些函数式编程语言将其写入了语言规格。ES6 是如此，第一次明确规定，所有 ECMAScript 的实现，都必须部署“尾调用优化”。这就是说，只要使用尾递归，就不会发生栈溢出，相对节省内存。
====函数参数的尾逗号
ES2017 允许函数的最后一个参数有尾逗号（trailing comma）。
此前，函数定义和调用时，都不允许最后一个参数后面出现逗号。
function clownsEverywhere(
param1,
param2
) { }
clownsEverywhere(
'foo',
'bar'
);
上面代码中，如果在param2或bar后面加一个逗号，就会报错。
如果像上面这样，将参数写成多行（即每个参数占据一行），以后修改代码的时候，想为函数clownsEverywhere添加第三个参数，或者调整参数的次序，就势必要在原来最后一个参数后面添加一个逗号。这对于版本管理系统来说，就会显示添加逗号的那一行也发生了变动。这看上去有点冗余，因此新的语法允许定义和调用时，尾部直接有一个逗号。
function clownsEverywhere(
param1,
param2,
) { }
clownsEverywhere(
'foo',
'bar',
);