JavaScript中高階函式的魅力

MarkMan發表於2018-09-03
JavaScript函式

高階函式是指至少滿足下列條件之一的函式 1：函式可以作為引數被傳遞 2：函式可以作為返回值輸出

JavaScript語言中的函式顯然的是滿足了高階函式的條件，下面我們一起來探尋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 ')
})
複製程式碼

一旦進入分支，便在函式內部修改函式的實現，重寫之後函式就是我們期望的函式，在下一次進入函式的時候就不再存在條件分支語句。

總結

該文章主要是讀《Javascript設計模式》的總結。

程式碼地址

原文地址 如果覺得有用得話給個⭐吧

相關文章