JavaScript中高階函數的介紹（程式碼範例）

這篇文章帶給大家的內容是關於JavaScript中高階函數的介紹（程式碼範例），有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。

一個函數就可以接收另一個函數作為參數,簡言之,函數的參數能夠接收別的函數,這種函數就稱之為高階函數

JavaScript 的高階函數跟Swift 的高階函數類似

常見的高階函數有: Map、Reduce、Filter、Sort

高階函數是指至少符合下列條件之一的函數

  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 p =document.createElement(&#39;p&#39;)
 p.innerHTML = data + 1
 document.body.appendChild(p)
}, 20)
renderList()

惰性載入函數

在網路開發中，因為一些瀏覽器中的差異，一些嗅探工作總是不可避免的。

因為瀏覽器的差異性，我們要常常做各種各樣的兼容，舉一個非常簡單常用的例子：在各個瀏覽器中都能夠通用的事件綁定函數。
常見的寫法是這樣的：

// 常用的事件兼容
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 ')
})

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

最後

為了幫助大家讓學習變得輕鬆、高效，給大家免費分享一大批資料，幫助大家在成為全棧工程師，甚至架構師的路上披荊斬棘。這裡給大家推薦一個前端全端學習交流圈：866109386.歡迎大家進群交流討論，學習交流，共同進步。

當真正開始學習的時候難免不知道從哪入手，導致效率低下影響繼續學習的信心。

但最重要的是不知道哪些技術需要重點掌握，學習時頻繁踩坑，最終浪費大量時間，所以有有效資源還是很有必要的。

最後祝福所有遇到瓶疾、不知道怎麼辦的前端程式設計師們，祝福大家在往後的工作與面試中一切順利。

##

以上是JavaScript中高階函數的介紹（程式碼範例）的詳細內容。更多資訊請關注PHP中文網其他相關文章！