一個函數可以接收另一個函數作為參數。總之一個函數的參數可以接收其他函數, 這種函數被稱為高階函數。
常見的高階函數有:Map、Reduce、Filter、 Sort。高階函數是至少滿足以下條件之一的函數:
1:函數可以作為參數傳遞
2:函數可以作為傳回值輸出
JavaScript 語言中的函數顯然滿足高階函數的條件。讓我們來探索高階函數的好處和使用場景。
高階函數實作AOP
AOP(面向切面程式設計)的主要作用就是把一些和核心業務邏輯子產品無關的功能抽取出來,然後再通過“動态織入”的方式摻到業務子產品種。
這些功能一般包括日志統計,安全控制,異常處理等。
AOP是Java Spring架構的核心。下面我們就來探索一下再JavaScript種如何實作AOP
在JavaScript種實作AOP,都是指把一個函數“動态織入”到另外一個函數中,具體實作的技術有很多,我們使用Function.prototype來做到這一點。代碼如下:
/**
* 織入執行前函數
* @param {*} fn
*/
Function.prototype.aopBefore = function(fn){
console.log(this)
// 第一步:儲存原函數的引用
const _this = this
// 第四步:傳回包括原函數和新函數的“代理”函數
return function() {
// 第二步:執行新函數,修正this
fn.apply(this, arguments)
// 第三步 執行原函數
return _this.apply(this, arguments)
}
}
/**
* 織入執行後函數
* @param {*} fn
*/
Function.prototype.aopAfter = function (fn) {
const _this = this
return function () {
let current = _this.apply(this,arguments)// 先儲存原函數
fn.apply(this, arguments) // 先執行新函數
return current
}
}
/**
* 使用函數
*/
let aopFunc = function() {
console.log('aop')
}
// 注冊切面
aopFunc = aopFunc.aopBefore(() => {
console.log('aop before')
}).aopAfter(() => {
console.log('aop after')
})
// 真正調用
aopFunc()
currying(柯裡化)
關于curring我們首先要聊的是什麼是函數柯裡化。
curring又稱部分求值。一個curring的函數首先會接受一些參數,接受了這些參數之後,該函數并不會立即求值,二十繼續傳回另外一個函數,剛才傳入的參數在函數形成的閉包中被儲存起來。待到函數中被真正的需要求值的時候,之前傳入的所有參數被一次性用于求值。
生硬的看概念不太好了解,我們來看接下來的例子
我們需要一個函數來計算一年12個月的消費,在每個月月末的時候我們都要計算消費了多少錢。正常代碼如下:
// 未柯裡化的函數計算開銷
let totalCost = 0
const cost = function(amount, mounth = '') {
console.log(`第${mounth}月的花銷是${amount}`)
totalCost += amount
console.log(`目前總共消費:${totalCost}`)
}
cost(1000, 1) // 第1個月的花銷
cost(2000, 2) // 第2個月的花銷
// ...
cost(3000, 12) // 第12個月的花銷
總結一下不難發現,如果我們要計算一年的總消費,沒必要計算12次。隻需要在年底執行一次計算就行,接下來我們對這個函數進行部分柯裡化的函數幫助我們了解。
// 部分柯裡化完的函數
const curringPartCost = (function() {
// 參數清單
let args = []
return function (){
/**
* 區分計算求值的情況
* 有參數的情況下進行暫存
* 無參數的情況下進行計算
*/
if (arguments.length === 0) {
let totalCost = 0
args.forEach(item => {
totalCost += item[0]
})
console.log(`共消費:${totalCost}`)
return totalCost
} else {
// argumens并不是數組,是一個類數組對象
let currentArgs = Array.from(arguments)
args.push(currentArgs)
console.log(`暫存${arguments[1] ? arguments[1] : '' }月,金額${arguments[0]}`)
}
}
})()
curringPartCost(1000,1)
curringPartCost(100,2)
curringPartCost()
接下來我們編寫一個通用的curring, 以及一個即将被curring的函數。代碼如下:
// 通用curring函數
const curring = function(fn) {
let args = []
return function () {
if (arguments.length === 0) {
console.log('curring完畢進行計算總值')
return fn.apply(this, args)
} else {
let currentArgs = Array.from(arguments)[0]
console.log(`暫存${arguments[1] ? arguments[1] : '' }月,金額${arguments[0]}`)
args.push(currentArgs)
// 傳回正被執行的 Function 對象,也就是所指定的 Function 對象的正文,這有利于匿名函數的遞歸或者保證函數的封裝性
return arguments.callee
}
}
}
// 求值函數
let costCurring = (function() {
let totalCost = 0
return function () {
for (let i = 0; i < arguments.length; i++) {
totalCost += arguments[i]
}
console.log(`共消費:${totalCost}`)
return totalCost
}
})()
// 執行curring化
costCurring = curring(costCurring)
costCurring(2000, 1)
costCurring(2000, 2)
costCurring(9000, 12)
costCurring()
函數節流
JavaScript中的大多數函數都是使用者主動觸發的,一般情況下是沒有性能問題,但是在一些特殊的情況下不是由使用者直接控制。容易大量的調用引起性能問題。畢竟DOM操作的代價是非常昂貴的。下面将列舉一些這樣的場景:
- window.resise事件。
- mouse, input等事件。
- 上傳進度
- ...
下面通過高階函數的方式我們來實作函數節流
/**
* 節流函數
* @param {*} fn
* @param {*} interval
*/
const throttle = function (fn, interval = 500) {
let timer = null, // 計時器
isFirst = true // 是否是第一次調用
return function () {
let args = arguments, _me = this
// 首次調用直接放行
if (isFirst) {
fn.apply(_me, args)
return isFirst = false
}
// 存在計時器就攔截
if (timer) {
return false
}
// 設定timer
timer = setTimeout(function (){
console.log(timer)
window.clearTimeout(timer)
timer = null
fn.apply(_me, args)
}, interval)
}
}
// 使用節流
window.onresize = throttle(function() {
console.log('throttle')
},600)
分時函數
節流函數為我們提供了一種限制函數被頻繁調用的解決方案。下面我們将遇到另外一個問題,某些函數是使用者主動調用的,但是由于一些客觀的原因,這些操作會嚴重的影響頁面性能,此時我們需要采用另外的方式去解決。
如果我們需要在短時間内才頁面中插入大量的DOM節點,那顯然會讓浏覽器吃不消。可能會引起浏覽器的假死,是以我們需要進行分時函數,分批插入。
/**
* 分時函數
* @param {*建立節點需要的資料} list
* @param {*建立節點邏輯函數} fn
* @param {*每一批節點的數量} count
*/
const timeChunk = function(list, fn, count = 1){
let insertList = [], // 需要臨時插入的資料
timer = null // 計時器
const start = function(){
// 對執行函數逐個進行調用
for (let i = 0; i < Math.min(count, list.length); i++) {
insertList = list.shift()
fn(insertList)
}
}
return function(){
timer = setInterval(() => {
if (list.length === 0) {
return window.clearInterval(timer)
}
start()
},200)
}
}
// 分時函數測試
const arr = []
for (let i = 0; i < 94; i++) {
arr.push(i)
}
const renderList = timeChunk(arr, function(data){
let div =document.createElement('div')
div.innerhtml = data + 1
document.body.appendChild(div)
}, 20)
renderList()
惰性加載函數
在Web開發中,因為一些浏覽器中的差異,一些嗅探工作總是不可避免的。
因為浏覽器的差異性,我們要常常做各種各樣的相容,舉一個非常簡單常用的例子:在各個浏覽器中都能夠通用的事件綁定函數。
常見的寫法是這樣的:
// 常用的事件相容
const addEvent = function(el, type, handler) {
if (window.addEventListener) {
return el.addEventListener(type, handler, false)
}
// for IE
if (window.attachEvent) {
return el.attachEvent(`on${type}`, handler)
}
}
這個函數存在一個缺點,它每次執行的時候都會去執行if條件分支。雖然開銷不大,但是這明顯是多餘的,下面我們優化一下, 提前一下嗅探的過程:
const addEventOptimization = (function() {
if (window.addEventListener) {
return (el, type, handler) => {
el.addEventListener(type, handler, false)
}
}
// for IE
if (window.attachEvent) {
return (el, type, handler) => {
el.attachEvent(`on${type}`, handler)
}
}
})()
這樣我們就可以在代碼加載之前進行一次嗅探,然後傳回一個函數。但是如果我們把它放在公共庫中不去使用,這就有點多餘了。下面我們使用惰性函數去解決這個問題:
// 惰性加載函數
let addEventLazy = function(el, type, handler) {
if (window.addEventListener) {
// 一旦進入分支,便在函數内部修改函數的實作
addEventLazy = function(el, type, handler) {
el.addEventListener(type, handler, false)
}
} else if (window.attachEvent) {
addEventLazy = function(el, type, handler) {
el.attachEvent(`on${type}`, handler)
}
}
addEventLazy(el, type, handler)
}
addEventLazy(document.getElementById('eventLazy'), 'click', function() {
console.log('lazy ')
})