一、箭头函数形式
箭头函数用
=>符号表示，相当于匿名函数，箭头左边是传入函数的参数，右边是函数中执行的语句
// js原始写法
var sum = function(x, y){
return x+y
}
// 箭头函数写法
var sum = (x, y) => {
return x+y
}
例子：
var arr = [1,2,3]
var res = arr.map(x => x*x)
简写方式：
（1）当要执行的代码只有一条语句且为return语句时，可以省略大括号和return关键字
var sum = (x, y) => x+y
（2）当传入的参数只有一个时，可以省略小括号
var sum = x => x*2
（3）当不需要参数时，使用空的圆括号
var one = () => 1
二、箭头函数基本特点
（1）箭头函数this为父作用域的this，不是调用时的this
箭头函数的this永远指向其父作用域，任何方法都改变不了，包括call，apply，bind
普通函数的this指向调用它的对象
// 例子一：
let person = {
name:'jike',
init:function(){
// 为body添加一个点击事件
document.body.onclick = ()=>{
alert(this.name);
}
}
}
person.init();
上例中，init是function，是person.init()调用，其内部this就是person本身，而onclick回调是箭头函数，其内部this就是父作用域的this，即person，此时this.name 为jike
// 例子二：
let person = {
name:'jike',
init:()=>{
//为body添加一个点击事件
document.body.onclick = ()=>{
alert(this.name);
}
}
}
person.init();
上例中，init为箭头函数，其内部的this为全局window，onclick的this也就是init函数的this，也是window，得到的this.name为undefined。
（2）箭头函数不能作为构造函数，不能使用new
//构造函数如下：
function Person(p){
this.name = p.name;
}
//如果用箭头函数作为构造函数，则如下
var Person = (p) => {
this.name = p.name;
}
由于this必须是对象实例，而箭头函数是没有实例的，此处的this指向别处，不能产生person实例，自相矛盾。
（3）箭头函数没有arguments, caller, callee
箭头函数本身arguments，如果箭头函数在一个function内部，它会将外部函数的arguments拿过来使用。
箭头函数中要想接收不定参数，应该使用rest参数解决
let B = (b) => {
console.log(arguments)
}
B(2, 92, 32, 32) // Uncaught ReferenceError: argument is no defined
let C = (...c) => {
console.log(c)
}
C(3, 82, 32, 11) // [3, 82, 32, 11]
（4）箭头函数通过call和apply调用，不会改变this指向，只会传入参数
let obj2 = {
a: 10,
b: function(n) {
let f = (n) => n + this.a;
return f(n);
},
c: function(n) {
let f = (n) => n + this.a;
let m = {
a: 20
};
return f.call(m,n);
}
};
console.log(obj2.b(1)); // 11
console.log(obj2.c(1)); // 11
（5）箭头函数没有原型属性
var a = ()=>{
return 1;
}
function b(){
return 2;
}
console.log(a.prototype); // undefined
console.log(b.prototype); // {constructor: ƒ}
（6）箭头函数不能作为Generator函数，不能使用yield关键字
（7）箭头函数返回对象时，要加一个小括号
var func = () => ({ foo: 1 }); //正确
var func = () => { foo: 1 }; //错误
（8）箭头函数在ES6 class中声明的方法为实例方法，不是原型方法
// 例子1
class Super{
sayName(){
// do some thing
}
}
var a = new Super()
var b = new Super()
a.sayName === b.sayName //true
上例中，通过Super.prototype可以访问到sayName方法，即该方法定义在prototype上，所有实例化之后的对象共享prototype上的sayName
// 例子2
class Super{
sayName =()=>{
//do some thing here
}
}
var a = new Super()
var b = new Super()
a.sayName === b.sayName //false
上例中，通过Super.prototype访问不到sayName方法，该方法没有定义在prototype上，实例化之后的对象各自拥有自己的sayName方法，比例子1需要更多的内存空间
因此，在class中尽量少用箭头函数声明方法
（9）多重箭头函数就是一个高阶函数，相当于内嵌函数
const add = x => y => y+x
// 相当于
function add(x){
return function(y){
return y+x
}
}
（10）箭头函数常见错误
let a = {
foo: 1,
bar: () => console.log(this.foo)
}
a.bar() //undefined，bar函数中的this指向父作用域（window），而a对象没有作用域，因此this不是a，打印结果为undefined
function A() {
this.foo = 1
}
A.prototype.bar = () => console.log(this.foo)
let a = new A()
a.bar() //undefined，原型上使用箭头函数，this指向是其父作用域，并不是对象a，而是window