资讯专栏INFORMATION COLUMN

Javascript高阶函数

史占广 / 3145人阅读

摘要:判断数据的类型输出高阶函数实现面向切面编程的主要作用是把一些核心业务逻辑模块无关的功能抽离出来,这些无关的模块包括日志统计,安全控制,异常处理。

高阶函数是指至少满足以下条件之一的函数:

函数可以作为参数被传递

函数可以作为返回值输出

函数作为参数传递
把参数当作参数传递, 抽离出一部分容易变化的业务逻辑,将它放在函数参数中,这样可以分离业务代码中变化与不变的部分。其中一个重要的应用场景就是回调函数。
1. 回调函数
var appendDiv = function() {
    for (var i = 0; i < 100; i++) {
        var div = document.createElement("div")
            div.innerHTML = i
            document.body.appendChild(div)
            div.style.display = "none"
    }
}
appendDiv()

div.style.display = "none"这种硬编码放在appendDiv里显然是不合理的,appendDiv未免有点个性化了,成为一个难复用的函数,于是我们将div.style.display = "none这行代码抽离出来,用回调函数的形式调用

var appendDiv = function(callback) {
    for (var i = 0; i < 100; i++) {
        var div = document.createElement("div")
            div.innerHTML = i
            document.body.appendChild(div)
            if (typeof callback === "function") {
                callback(div)
            }
    }
}
appendDiv(function(node){
    node.style.display = "none"
})
2. Array.prototype.sort

Array.prototype.sort接受一个函数当作参数,这个函数里封装里数组元素的排序规则。
其中数组是不变,而排序规则是可变的,将可变的部分封装在函数里。

[1,4,5].sort(function(a, b){
    return a - b    
})

// 输出 [1,3,4]
函数作为返回值输出
相比把函数作为参数传递,函数当作返回值输出的应用场景也许更多,也更能体现出函数式编程的巧妙。让函数返回一个可执行的函数,意味着运算过程是可延续。
判断数据的类型
var type = function(data) {
    if(arguments.length === 0) return;
    var typeStr = Object.prototype.toString.call(data)
    return typeStr.match(/[object (.*?)]/)[1].toLowerCase()
}
console.log(type("Array"))

//输出 string
高阶函数实现AOP
AOP(面向切面编程) 的主要作用是把一些核心业务逻辑模块无关的功能抽离出来,这些无关的模块包括日志统计,安全控制,异常处理。把这些功能抽离之后,再通过动态织入的方式掺入业务逻辑中。这样做的好处是保持业务逻辑模块的纯净和高内聚性,其次是可以很方便的复用次用模块。在JavaScript中AOP的实现非常简单,这是与生俱来的能力。
Function.prototype.before = function(beforefn) {
    var _self = this // 保存原函数的引用
    return function() { // 返回包含了原函数和新函数的"代理"函数                
        beforefn.apply(this, arguments) // 执行新函数,修正this
        return _self.apply(this, arguments) // 执行原函数
    }
}

Function.prototype.after = function(afterfn) {
    var _self = this
    return function() {
        var ret = _self.apply(this, arguments) //修正this值,并且执行原函数
        afterfn.apply(this, arguments) //执行新函数
        return ret
    }
}

var fnc = function(){
    console.log(2)
}
fnc = fnc.before(function(){
    console.log(1)
}).after(function(){
    console.log(3)
})

fnc()

// 输出 1  2  3
高阶函数的其他应用 1. 函数柯里化

函数柯里化(function currying)又称部分求值。一个currying的函数首先会接受一些参数,接受了这些参数之后,该函数不会立即求值,而是继续返回另外一个函数,刚才传入的参数在函数中形成的闭包中被保存起来。待到函数被真正需要求值的时候,之前传入的所有参数都会被一次性用于求值。

// 通用currying函数,接受一个参数,即将要被currying的函数
var currying = function(fn) {
    var args = []
    return function() {
        if (arguments.length === 0) {
            return fn.apply(this, args)
        } else {
            [].push.apply(args, arguments)
            return arguments.callee
        }
    }
}


// 被currying的函数
var cost = (function(){
    var money = 0
    return function() {
        for (var i = 0, l= arguments.length; i < l; i++) {
            money += arguments[i]
        }
        return money
    }
})()

var cost = currying(cost)

cost(100) //未真正求值
cost(200) //未真正求值
cost(300) //未真正求值

console.log(cost()) // 求值并输出:600
2. uncurrying
>`uncurrying`的目的是将泛化this的过程提取出来,将`fn.call`或者`fn.apply`抽象成通用的函数。


在javascript中,当我们调用对象的某个方法时,其实不用关心该对象原本是否拥有这个方法,这也是动态类型语言的特点。可以用`call`和`apply`去借用一个原本不属于它的方法

var obj1 = {
    name: "sven"
}

var obj2 = {
    getName: function() {
        return this.name
    }
}

console.log(obj2.getName.call(obj1)) // 输出: sven

通过uncurrying的方式,我们可以把Array.prototype上的方法"复制"到array对象上,同样这些方法可操作的对象也不仅仅只是array对象

// uncurrying实现
Function.prototype.uncurrying = function() {
    var self = this;
    return function() {
        return Function.prototype.call.apply(self, arguments);
    }
};

// 将Array.prototype.push进行uncurrying,此时push函数的作用就跟Array.prototype.push一样了,且不仅仅局限于只能操作array对象。
var push = Array.prototype.push.uncurrying();

var obj = {
    "length": 1,
    "0": 1
};

push(obj, 2);
console.log(obj);   // 输出:{0: 1, 1: 2, length: 2}
3. 函数节流
当一个函数被频繁调用时,如果会造成很大的性能问题的时候,这个时候可以考虑函数节流,降低函数被调用的频率。

throttle函数的原理是,将即将被执行的函数用setTimeout延迟一段时间执行。如果该次延迟执行还没有完成,则忽略接下来调用该函数的请求。throttle函数接受2个参数,第一个参数为需要被延迟执行的函数,第二个参数为延迟执行的时间。

var throttle = function(fn, interval) {
    var _self = fn, // 保存需要被延时执行的函数引用
        timer,        // 定时器
        firstTime = true // 是否是第一次调用
    
    return function() {
        var args = arguments,
            _me = this
        
        if (firstTime) { // 如果是第一次调用,不延时执行
            _self.apply(_me, args)
            return firstTime = false
        }
        
        if (timer) {  // 如果定时器还在,说明前一次延时执行还没有完成
            return false
        }
        
        timer = setTimeout(function(){ //延时执行
            clearTimeout(timer)
            timer = null
            _self.apply(_me, args)
        }, interval || 500)
        
    }
}

window.onresize = throttle(function(){
    console.log(1)
}, 500)
4. 分时函数

当一次的用户操作会严重地影响页面性能,如在短时间内往页面中大量添加DOM节点显然也会让浏览器吃不消,我们看到的结果往往就是浏览器的卡顿甚至假死。

这个问题的解决方案之一是下面的timeChunk函数,timeChunk函数让创建节点的工作分批进行,比如把1秒钟创建1000个节点,改为每隔200毫秒创建8个节点。

var timeChunk = function(ary, fn, count) {
    var t;
    
    var start = function() {
        for ( var i = 0; i < Math.min( count || 1, ary.length ); i++ ){
            var obj = ary.shift();
            fn( obj );
        }
     };
    
     return function() {
        t = setInterval(function() {
          if (ary.length === 0) {  // 如果全部节点都已经被创建好
              return clearInterval(t);
          }
          start();
        }, 200);    // 分批执行的时间间隔,也可以用参数的形式传入
    };
};
5. 惰性加载
在Web开发中,因为浏览器之间的实现差异,一些嗅探工作总是不可避免。比如我们需要一个在各个浏览器中能够通用的事件绑定函数addEvent,常见的写法如下:

方案一:

var addEvent = function(elem, type, handler) {
    if (window.addEventListener) {
       return elem.addEventListener(type, handler, false)
    }
    
    if (window.attachEvent) {
          return elem.attachEvent("on" + type, handler)
    }
}

缺点:当它每次被调用的时候都会执行里面的if条件分支,虽然执行这些if分支的开销不算大,但也许有一些方法可以让程序避免这些重复的执行过程。

方案二:

var addEvent = (function() {
    if (window.addEventListener) {
        return function(elem, type, handler) {
            elem.addEventListener(type, handler, false)
        }
    }
    if (window.attachEvent) {
        return function(elem, type, handler) {
            elem.attachEvent("on" + type, handler)
        }
    }
})()

缺点:也许我们从头到尾都没有使用过addEvent函数,这样看来,一开始的浏览器嗅探就是完全多余的操作,而且这也会稍稍延长页面ready的时间。

方案三:

var addEvent = function(elem, type, handler) {
    if (window.addEventListener) {
       addEvent = function(elem, type, handler) {
           elem.addEventListener(type, handler, false)
       }
    } else if (window.attachEvent) {
        addEvent = function(elem, type, handler) {
            elem.attachEvent("on" + type, handler)
        }
    }
    addEvent(elem, type, handler)
}

此时addEvent依然被声明为一个普通函数,在函数里依然有一些分支判断。但是在第一次进入条件分支之后,在函数内部会重写这个函数,重写之后的函数就是我们期望的addEvent函数,在下一次进入addEvent函数的时候,addEvent函数里不再存在条件分支语句。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/99146.html

相关文章

  • 【进阶 6-1 期】JavaScript 高阶函数浅析

    摘要:引言本期开始介绍中的高阶函数,在中,函数是一种特殊类型的对象,它们是。简单来说,高阶函数是一个接收函数作为参数传递或者将函数作为返回值输出的函数。我们来看看使用它们与不使用高阶函数的方案对比。引言 本期开始介绍 JavaScript 中的高阶函数,在 JavaScript 中,函数是一种特殊类型的对象,它们是 Function objects。那什么是高阶函数呢?本节将通过高阶函数的定义来展...

    yiliang 评论0 收藏0
  • JavaScript 高阶函数快速入门

    摘要:高阶函数接受和或返回另外一个函数的函数被称为高阶函数。之所以是高阶,是因为它并非字符串数字或布尔值,而是从更高层次来操作函数。更高的可重用性高阶函数的最大好处可能是更高的可重用性。如果没有高阶函数,我们需要用循环来模仿的功能。 翻译:疯狂的技术宅原文:https://medium.freecodecamp.o... 本文首发微信公众号:jingchengyideng欢迎关注,每天都...

    nanfeiyan 评论0 收藏0
  • 高阶函数实现地址的延迟搜索

    摘要:原文高阶函数在中高阶函数实际上就是控制函数的函数,有别于普通函数传递变量,高阶函数传递的是函数,并且输出函数这对于初学者来说足够烧脑,也足够惊艳。初识时常常会被被震撼了,原来函数还可以这么用这是设计模式与开发实践的单例模式的一个高阶函数。 原文 高阶函数 在javascript中高阶函数实际上就是控制函数的函数,有别于普通函数传递变量,高阶函数传递的是函数,并且输出函数 这对于js初学...

    Nosee 评论0 收藏0
  • 一文带你了解什么是JavaScript 函数式编程?

    摘要:前言函数式编程在前端已经成为了一个非常热门的话题。整个过程就是体现了函数式编程的核心思想通过函数对数据进行转换。高阶函数函数式编程倾向于复用一组通用的函数功能来处理数据,它通过使用高阶函数来实现。 前言 函数式编程在前端已经成为了一个非常热门的话题。在最近几年里,我们看到非常多的应用程序代码库里大量使用着函数式编程思想。 本文将略去那些晦涩难懂的概念介绍,重点展示在 JavaScrip...

    acrazing 评论0 收藏0
  • 学习React之前你需要知道的的JavaScript基础知识

    摘要:和类在开始时遇到类组件,只是需要有关类的基础。毕竟,中的条件呈现仅再次显示大多数是而不是特定的任何内容。 在我的研讨会期间,更多的材料是关于JavaScript而不是React。其中大部分归结为JavaScript ES6以及功能和语法,但也包括三元运算符,语言中的简写版本,此对象,JavaScript内置函数(map,reduce,filter)或更常识性的概念,如:可组合性,可重用...

    bitkylin 评论0 收藏0

发表评论

0条评论

史占广

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<