/**
* 織入執(zhí)行前函數(shù)
* @param {*} fn 
*/
Function.prototype.aopBefore = function(fn){
 console.log(this)
 // 第一步：保存原函數(shù)的引用
 const _this = this
 // 第四步：返回包括原函數(shù)和新函數(shù)的“代理”函數(shù)
 return function() {
 // 第二步：執(zhí)行新函數(shù)，修正this
 fn.apply(this, arguments)
 // 第三步 執(zhí)行原函數(shù)
 return _this.apply(this, arguments)
 }
}
/**
* 織入執(zhí)行后函數(shù)
* @param {*} fn 
*/
Function.prototype.aopAfter = function (fn) {
 const _this = this
 return function () {
 let current = _this.apply(this,arguments)// 先保存原函數(shù)
 fn.apply(this, arguments) // 先執(zhí)行新函數(shù)
 return current
 }
}
/**
* 使用函數(shù)
*/
let aopFunc = function() {
 console.log('aop')
}
// 注冊切面
aopFunc = aopFunc.aopBefore(() => {
 console.log('aop before')
}).aopAfter(() => {
 console.log('aop after')
})
// 真正調(diào)用
aopFunc()

// 未柯里化的函數(shù)計算開銷
let totalCost = 0
const cost = function(amount, mounth = '') {
 console.log(`第${mounth}月的花銷是${amount}`)
 totalCost += amount
 console.log(`當(dāng)前總共消費：${totalCost}`)
}
cost(1000, 1) // 第1個月的花銷
cost(2000, 2) // 第2個月的花銷
// ...
cost(3000, 12) // 第12個月的花銷

// 部分柯里化完的函數(shù)
const curringPartCost = (function() {
 // 參數(shù)列表
 let args = []
 return function (){
 /**
 * 區(qū)分計算求值的情況
 * 有參數(shù)的情況下進行暫存
 * 無參數(shù)的情況下進行計算
 */
 if (arguments.length === 0) {
  let totalCost = 0
  args.forEach(item => {
  totalCost += item[0]
  })
  console.log(`共消費：${totalCost}`)
  return totalCost
 } else {
  // argumens并不是數(shù)組，是一個類數(shù)組對象
  let currentArgs = Array.from(arguments)
  args.push(currentArgs)
  console.log(`暫存${arguments[1] ? arguments[1] : '' }月，金額${arguments[0]}`)
 }
 }
})()
curringPartCost(1000,1)
curringPartCost(100,2)
curringPartCost()

// 通用curring函數(shù)
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)
  // 返回正被執(zhí)行的 Function 對象，也就是所指定的 Function 對象的正文，這有利于匿名函數(shù)的遞歸或者保證函數(shù)的封裝性
  return arguments.callee
 }
 }
}
// 求值函數(shù)
let costCurring = (function() {
 let totalCost = 0
 return function () {
 for (let i = 0; i < arguments.length; i++) {
  totalCost += arguments[i]
 }
 console.log(`共消費：${totalCost}`)
 return totalCost
 }
})()
// 執(zhí)行curring化
costCurring = curring(costCurring)
costCurring(2000, 1)
costCurring(2000, 2)
costCurring(9000, 12)
costCurring()

/**
* 節(jié)流函數(shù)
* @param {*} fn 
* @param {*} interval 
*/
const throttle = function (fn, interval = 500) {
 let timer = null, // 計時器 
  isFirst = true // 是否是第一次調(diào)用
 return function () {
 let args = arguments, _me = this
 // 首次調(diào)用直接放行
 if (isFirst) {
  fn.apply(_me, args)
  return isFirst = false
 }
 // 存在計時器就攔截
 if (timer) {
  return false
 }
 // 設(shè)置timer
 timer = setTimeout(function (){
 console.log(timer)
 window.clearTimeout(timer)
 timer = null
 fn.apply(_me, args)
 }, interval)
 }
}
// 使用節(jié)流
window.onresize = throttle(function() {
 console.log('throttle')
},600)

/**
* 分時函數(shù)
* @param {*創(chuàng)建節(jié)點需要的數(shù)據(jù)} list 
* @param {*創(chuàng)建節(jié)點邏輯函數(shù)} fn 
* @param {*每一批節(jié)點的數(shù)量} count 
*/
const timeChunk = function(list, fn, count = 1){
 let insertList = [], // 需要臨時插入的數(shù)據(jù)
  timer = null // 計時器
 const start = function(){
 // 對執(zhí)行函數(shù)逐個進行調(diào)用
 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)
 }
}
// 分時函數(shù)測試
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()

// 常用的事件兼容
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)
 }
}
復(fù)制代碼這個函數(shù)存在一個缺點，它每次執(zhí)行的時候都會去執(zhí)行if條件分支。雖然開銷不大，但是這明顯是多余的，下面我們優(yōu)化一下， 提前一下嗅探的過程：
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)
 }
 }
})()

// 惰性加載函數(shù)
let addEventLazy = function(el, type, handler) {
 if (window.addEventListener) {
 // 一旦進入分支，便在函數(shù)內(nèi)部修改函數(shù)的實現(xiàn)
 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 ')
})