前言
一個函數就可以接收另一個函數作為參數,簡言之,函數的參數能夠接收別的函數,這種函數就稱之為高階函數
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 = 0const 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操作的代價是非常昂貴的。下面將列舉一些這樣的場景：
下面通過高階函數的方式我們來實現函數節流
/*** 節流函數* @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設計模式》的總結。
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對VeVb武林網的支持。
新聞熱點
疑難解答
