国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JavaScript中高階函數的魅力

Tony_Zby / 675人閱讀

摘要:上傳進度下面通過高階函數的方式我們來實現函數節流節流函數計時器是否是第一次調用首次調用直接放行存在計時器就攔截設置使用節流分時函數節流函數為我們提供了一種限制函數被頻繁調用的解決方案。

高階函數是指至少滿足下列條件之一的函數 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設計模式》的總結。

代碼地址

原文地址

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/97313.html

相關文章

  • Javascript函數作為對象魅力

    摘要:賦予了函數非常多的特性,其中最重要的特性之一就是將函數作為第一型的對象。那就意味著在中函數可以有屬性,可以有方法,可以享有所有對象所擁有的特性。參考資料忍者秘籍關于函數我之前還寫過一篇中高階函數的魅力有興趣的話可以看一看。 Javascript賦予了函數非常多的特性,其中最重要的特性之一就是將函數作為第一型的對象。那就意味著在javascript中函數可以有屬性,可以有方法, 可以享有...

    morgan 評論0 收藏0
  • Javascript函數式編程小結

    摘要:源起函數式編程近幾年非常流行經常可以在網上看到別人討論相關話題我機緣巧合之下在上看到有人提到一個講函數式編程的視頻看過之后突然茅塞頓開瞬間把之前零碎的關于函數式編程的知識一下子都聯系了起來于是自己希望趁有空把這些知識總結一下這樣既可以回顧下 源起 函數式編程近幾年非常流行,經常可以在網上看到別人討論相關話題. 我機緣巧合之下在github上看到有人提到一個講js函數式編程的視頻,看過之...

    zengdongbao 評論0 收藏0
  • javascript 函數式編程思想

    摘要:今天這篇文章主要介紹函數式編程的思想。函數式編程通過最小化變化使得代碼更易理解。在函數式編程里面,組合是一個非常非常非常重要的思想。可以看到函數式編程在開發中具有聲明模式。而函數式編程旨在盡可能的提高代碼的無狀態性和不變性。 最開始接觸函數式編程的時候是在小米工作的時候,那個時候看老大以前寫的代碼各種 compose,然后一些 ramda 的一些工具函數,看著很吃力,然后極力吐槽函數式...

    YPHP 評論0 收藏0
  • Javascript異步編程 - 函數式編程 - Javascript核心

    摘要:不少第三方模塊并沒有做到異步調用,卻裝作支持回調,堆棧的風險就更大。我們可以編寫一個高階函數,讓傳入的函數順序執行還是我們之前的例子看起來還是很不錯的,簡潔并且清晰,最終的代碼量也沒有增加。 原文: http://pij.robinqu.me/JavaScript_Core/Functional_JavaScript/Async_Programing_In_JavaScript....

    hlcc 評論0 收藏0
  • 【進階 6-1 期】JavaScript 高階函數淺析

    摘要:引言本期開始介紹中的高階函數,在中,函數是一種特殊類型的對象,它們是。簡單來說,高階函數是一個接收函數作為參數傳遞或者將函數作為返回值輸出的函數。我們來看看使用它們與不使用高階函數的方案對比。引言 本期開始介紹 JavaScript 中的高階函數,在 JavaScript 中,函數是一種特殊類型的對象,它們是 Function objects。那什么是高階函數呢?本節將通過高階函數的定義來展...

    yiliang 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<