關于JavaScript中高階函數的魅力詳解

來源：懂視網責編：小采時間：2020-11-27 22:08:08

關于JavaScript中高階函數的魅力詳解

關于JavaScript中高階函數的魅力詳解:前言一個函數就可以接收另一個函數作為參數,簡言之,函數的參數能夠接收別的函數,這種函數就稱之為高階函數 JavaScript 的高階函數跟 Swift 的高階函數類似常見的高階函數有: Map、Reduce、Filter、Sort 高階函數是指至少滿足下列條件之一的函數 1：函

推薦度：

點擊下載本文 文檔為doc格式

導讀關于JavaScript中高階函數的魅力詳解:前言一個函數就可以接收另一個函數作為參數,簡言之,函數的參數能夠接收別的函數,這種函數就稱之為高階函數 JavaScript 的高階函數跟 Swift 的高階函數類似常見的高階函數有: Map、Reduce、Filter、Sort 高階函數是指至少滿足下列條件之一的函數 1：函

生硬的看概念不太好理解，我們來看接下來的例子

我們需要一個函數來計算一年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設計模式》的總結。

代碼地址

好了，

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com