JavaScript箭頭函式
語法
基礎語法
(引數1, 引數2, ..., 引數N) => { 函式宣告 }
// 相當于：(引數1, 引數2, ..., 引數N) => { return 運算式; }
(引數1, 引數2, ..., 引數N) => 運算式(單一)
// 當只有一個引數時，圓括號是可選的:
(單一引數) => { 函式宣告 }
單一引數 => { 函式宣告 }
// 沒有引數的函式應該寫成一對圓括號
() => { 函式宣告 }
高級語法
//加括號的函式體回傳物件字面運算式:
引數=>({foo:bar})
//支持剩余引數和默認引數
(引數1, 引數2, ...rest) => { 函式宣告 }
//同樣支持引數串列解構
let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f() // 6
描述
引入箭頭函式有兩個方面的作用：更簡短的函式并且不系結this，
更短的函式
var materials = [
'Hydrogen',
'Helium',
'Lithium',
'Beryllium'
];
materials.map(function(material) {
return mateerial.length;
}); // [8, 6, 7, 9]
materials.map((material) => {
return material.length;
}); // [8, 6, 7, 9]
materials.map(material => material.length); // [8, 6, 7, 9]
不系結this
在箭頭函式出現之前，每個新定義的函式都有它自己的this值(在建構式的情況下是一個新物件，在嚴格模式的函式呼叫中為underfined，如果該函式被作為”物件方法“呼叫則為基礎物件等)，This被證明是令人厭煩的面向物件風格的編程，
function Person() {
// Person()建構式定義 'this'作為它自己的實體.
this.age = 0;
setInterval(function growUp(){
// 在非嚴格模式，growUp()函式定義 'this'作為全域物件，
// 與在Person()建構式中定義的'this'并不相同.
this.age++;
},1000)
}
var p = new Person();
在ECMAScript 3/5中，通過將this值分配給封閉的變數，可以解決this問題，
function Person() {
var that = this;
that.age = 0;
setInterval(function growUp(){
// 回呼參考的是'that'變數,其值是預期的物件.
that.age++;
},1000);
}
或者，可以創建系結函式，以便將預先分配的this值傳遞到系結的目標函式(上述示例中的growUp( )函式)，
箭頭函式不會創建自己的this，它只會從自己的作用域鏈的上一層繼承this，因此，在下面的代碼中，傳遞給setInterval的函式內的this與封閉函式中的this值相同:
function Person() {
this.age = 0;
setInterval(() => {
this.age++; // |this| 正確地指向 p 實體
},1000);
}
var p = new Person();
與嚴格模式的關系
鑒于this是詞法層面上的，嚴格模式中與this相關的規則都將被忽略，
function person() {
this.age = 0;
var closure = "123"
setInterval(function growUp(){
this.age++;
console.log(closure)
},1000);
}
var p = new Person();
function PersonX() {
'use strict'
this.age = 0;
var closure = "123"
setInterval(() => {
this.age++;
console.log(closure)
},1000);
}
var px = new PersonX();
嚴格模式的其它規則依然不變.
通過call或apply呼叫
由于箭頭函式沒有自己的this指標，通過call()或apply()方法呼叫一個函式時，只能傳遞引數(不能系結this)，他們的第一個引數會被忽略，(這種現象對于bind方法同樣成立)
var adder = {
base : 1,
add : function(a) {
var f = v => v + this.base;
return f(a);
},
addThruCall: function(a) {
var f = v => v + this.base;
var b = {
base : 2
};
return f.call(b, a);
}
};
console.log(adder.add(1)); // 輸出 2
console.log(adder.addThruCall(1)); // 仍然輸出 2（而不是3)
不系結arguments
箭頭函式不系結Arguments物件，因此，在本示例中，arguments只是參考了封閉作用域內的arguments:
var arguments = [1, 2, 3];
var arr = () => arguments[0];
arr(); // 1
function foo(n) {
var f = () => arguments[0] + n; // 隱式系結 foo 函式的 arguments 物件. arguments[0] 是 n
return f();
}
foo(1); // 2
在大多數情況下，使用剩余引數是相較使用arguments物件的更好選擇，
function foo(arg) {
var f = (...args) => args[0];
return f(arg);
}
foo(1); // 1
function foo(arg1,arg2) {
var f = (...args) => args[1];
return f(arg1,arg2);
}
foo(1,2); //2
像函式一樣使用箭頭函式
如上所述，箭頭函式運算式對非方法函式是最合適的，讓我們看看當我們試著把它們作為方法時發生了什么，
'use strict';
var obj = {
i: 10,
b: () => console.log(this.i, this),
c: function() {
console.log( this.i, this)
}
}
obj.b();
// undefined
obj.c();
// 10, Object {...}
箭頭函式沒有定義this系結，另一個涉及Object.defineProperty()的示例:
'use strict';
var obj = {
a: 10
};
Object.defineProperty(obj, "b", {
get: () => {
console.log(this.a, typeof this.a, this);
return this.a+10;
// 代表全域物件 'Window', 因此 'this.a' 回傳 'undefined'
}
});
obj.b; // undefined "undefined" Window {postMessage: ?, blur: ?, focus: ?, close: ?, frames: Window, …}
使用new運算子
箭頭函式不能用作構造器，和new一起用會拋出錯誤，
var Foo = () => {};
var foo = new Foo(); // TypeError: Foo is not a constructor
使用prototype屬性
箭頭函式沒有prototype屬性，
var Foo = () => {};
console.log(Foo.prototype); // undefined
使用yield關鍵字
yield 關鍵字通常不能在箭頭函式中使用（除非是嵌套在允許使用的函式內），因此，箭頭函式不能用作生成器，
函式體
箭頭函式可以有一個“簡寫體”或常見的“塊體”，
在一個簡寫體中，只需要一個運算式，并附加一個隱式的回傳值，在塊體中，必須使用明確的return陳述句，
var func = x => x * x;
// 簡寫函式 省略return
var func = (x, y) => { return x + y; };
//常規撰寫 明確的回傳值
回傳物件字面量
記住用params => {object:literal}這種簡單的語法回傳物件字面量是行不通的，
var func = () => { foo: 1 };
// Calling func() returns undefined!
var func = () => { foo: function() {} };
// SyntaxError: function statement requires a name
這是因為花括號（{} ）里面的代碼被決議為一系列陳述句（即 foo 被認為是一個標簽，而非物件字面量的組成部分），
所以，記得用圓括號把物件字面量包起來：
var func = () => ({foo: 1});
換行
箭頭函式在引數和箭頭之間不能換行，
var func = ()
=> 1;
// SyntaxError: expected expression, got '=>'
決議順序
雖然箭頭函式中的箭頭不是運算子，但箭頭函式具有與常規函式不同的特殊運算子優先級決議規則，
let callback;
callback = callback || function() {}; // ok
callback = callback || () => {};
// SyntaxError: invalid arrow-function arguments
callback = callback || (() => {}); // ok
更多實體
// 空的箭頭函式回傳 undefined
let empty = () => {};
(() => 'foobar')();
// Returns "foobar"
// (這是一個立即執行函式運算式,可參閱 'IIFE'術語表)
var simple = a => a > 15 ? 15 : a;
simple(16); // 15
simple(10); // 10
let max = (a, b) => a > b ? a : b;
// Easy array filtering, mapping, ...
var arr = [5, 6, 13, 0, 1, 18, 23];
var sum = arr.reduce((a, b) => a + b);
// 66
var even = arr.filter(v => v % 2 == 0);
// [6, 0, 18]
var double = arr.map(v => v * 2);
// [10, 12, 26, 0, 2, 36, 46]
// 更簡明的promise鏈
promise.then(a => {
// ...
}).then(b => {
// ...
});
// 無引數箭頭函式在視覺上容易分析
setTimeout( () => {
console.log('I happen sooner');
setTimeout( () => {
// deeper code
console.log('I happen later');
}, 1);
}, 1);
箭頭函式也可以使用條件(三元)運算子：
var simple = a => a > 15 ? 15: a;
simple(16); // 15
simple(10); // 10
let max = (a, b) => a > b ? a: b
箭頭函式內定義的變數及其作用域
// 常規寫法
var greeting = () => {let now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
greeting(); //"Good day."
console.log(now); // ReferenceError: now is not defined 標準的let作用域
// 引數括號內定義的變數是區域變數（默認引數）
var greeting = (now=new Date()) => "Good" + (now.getHours() > 17 ? " evening." : " day.");
greeting(); //"Good day."
console.log(now); // ReferenceError: now is not defined
// 對比：函式體內{}不使用var定義的變數是全域變數
var greeting = () => {now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
greeting(); //"Good day."
console.log(now); // Fri Dec 22 2017 10:01:00 GMT+0800 (中國標準時間)
// 對比：函式體內{} 用var定義的變數是區域變數
var greeting = () => {var now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
greeting(); //"Good day."
console.log(now); // ReferenceError: now is not defined
箭頭函式也可以使用閉包：
// 標準的閉包函式
function A(){
var i=0;
return function b(){
return (++i);
};
};
var v=A();
v(); //1
v(); //2
//箭頭函式體的閉包（ i=0 是默認引數）
var Add = (i=0) => {return (() => (++i) )};
var v = Add();
v(); //1
v(); //2
//因為僅有一個回傳，return 及括號（）也可以省略
var Add = (i=0)=> ()=> (++i);
箭頭函式遞回
var fact = (x) => ( x==0 ? 1 : x*fact(x-1) );
fact(5); // 120
此筆記忘了是從哪里保存的了，侵則刪
轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/83659.html
標籤：JavaScript
下一篇：Ajax的步驟