关于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 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设计模式》的总结。

好了，以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，如果有疑问⼤家可以留⾔交流，谢谢⼤家对的⽀持。