javascript-函数的5个高级技巧

时间 2019-12-06

原文原文链接

函数对任何一门语言来讲都是一个核心的概念，在javascript中更是如此。本文将介绍函数的5个高级技巧javascript

做用域安全的构造函数前端

构造函数其实就是一个使用new操做符调用的函数java

function Person(name,age,job){    this.name=name;    this.age=age;    this.job=job;
}var person=new Person('match',28,'Software Engineer');
console.log(person.name);//match

若是没有使用new操做符，本来针对Person对象的三个属性被添加到window对象算法

function Person(name,age,job){    this.name=name;    this.age=age;    this.job=job;
}          
var person=Person('match',28,'Software Engineer');
console.log(person);//undefinedconsole.log(window.name);//match

window的name属性是用来标识连接目标和框架的，这里对该属性的偶然覆盖可能会致使页面上的其它错误，这个问题的解决方法就是建立一个做用域安全的构造函数数组

function Person(name,age,job){    if(this instanceof Person){        this.name=name;        this.age=age;        this.job=job;
    }else{        return new Person(name,age,job);
    }
}var person=Person('match',28,'Software Engineer');
console.log(window.name); // ""console.log(person.name); //'match'var person= new Person('match',28,'Software Engineer');
console.log(window.name); // ""console.log(person.name); //'match'

可是，对构造函数窃取模式的继承，会带来反作用。这是由于，下列代码中，this对象并不是Polygon对象实例，因此构造函数Polygon()会建立并返回一个新的实例浏览器

function Polygon(sides){    if(this instanceof Polygon){        this.sides=sides;        this.getArea=function(){            return 0;
        }
    }else{        return new Polygon(sides);
    }
}function  Rectangle(wifth,height){
    Polygon.call(this,2);    this.width=this.width;    this.height=height;    this.getArea=function(){        return this.width * this.height;
    };
}var rect= new Rectangle(5,10);
console.log(rect.sides); //undefined

若是要使用做用域安全的构造函数窃取模式的话，须要结合原型链继承，重写Rectangle的prototype属性，使它的实例也变成Polygon的实例安全

function Polygon(sides){    if(this instanceof Polygon){        this.sides=sides;        this.getArea=function(){            return 0;
        }
    }else{        return new Polygon(sides);
    }
}function  Rectangle(wifth,height){
    Polygon.call(this,2);    this.width=this.width;    this.height=height;    this.getArea=function(){        return this.width * this.height;
    };
}
Rectangle.prototype= new Polygon();var rect= new Rectangle(5,10);
console.log(rect.sides); //2

惰性载入函数闭包

由于各浏览器之间的行为的差别，咱们常常会在函数中包含了大量的if语句，以检查浏览器特性，解决不一样浏览器的兼容问题。好比，咱们最多见的为dom节点添加事件的函数app

function addEvent(type, element, fun) {    if (element.addEventListener) {
        element.addEventListener(type, fun, false);
    }    else if(element.attachEvent){
        element.attachEvent('on' + type, fun);
    }    else{
        element['on' + type] = fun;
    }
}

每次调用addEvent函数的时候，它都要对浏览器所支持的能力进行检查，首先检查是否支持addEventListener方法，若是不支持，再检查是否支持attachEvent方法，若是还不支持，就用dom0级的方法添加事件。这个过程，在addEvent函数每次调用的时候都要走一遍，其实，若是浏览器支持其中的一种方法，那么他就会一直支持了，就没有必要再进行其余分支的检测了。也就是说，if语句没必要每次都执行，代码能够运行的更快一些。框架

　　解决方案就是惰性载入。所谓惰性载入，指函数执行的分支只会发生一次，有两种实现惰性载入的方式

　　一、第一种是在函数被调用时，再处理函数。函数在第一次调用时，该函数会被覆盖为另一个按合适方式执行的函数，这样任何对原函数的调用都不用再通过执行的分支了

　　咱们能够用下面的方式使用惰性载入重写addEvent()

function addEvent(type, element, fun) {    if (element.addEventListener) {
        addEvent = function (type, element, fun) {
            element.addEventListener(type, fun, false);
        }
    }    else if(element.attachEvent){
        addEvent = function (type, element, fun) {
            element.attachEvent('on' + type, fun);
        }
    }    else{
        addEvent = function (type, element, fun) {
            element['on' + type] = fun;
        }
    }    return addEvent(type, element, fun);
}

在这个惰性载入的addEvent()中，if语句的每一个分支都会为addEvent变量赋值，有效覆盖了原函数。最后一步即是调用了新赋函数。下一次调用addEvent()时，便会直接调用新赋值的函数，这样就不用再执行if语句了

　　可是，这种方法有个缺点，若是函数名称有所改变，修改起来比较麻烦

　　二、第二种是声明函数时就指定适当的函数。这样在第一次调用函数时就不会损失性能了，只在代码加载时会损失一点性能

　　如下就是按照这一思路重写的addEvent()。如下代码建立了一个匿名的自执行函数，经过不一样的分支以肯定应该使用哪一个函数实现

var addEvent = (function () {    if (document.addEventListener) {        return function (type, element, fun) {
            element.addEventListener(type, fun, false);
        }
    }    else if (document.attachEvent) {        return function (type, element, fun) {
            element.attachEvent('on' + type, fun);
        }
    }    else {        return function (type, element, fun) {
            element['on' + type] = fun;
        }
    }
})();

函数绑定

在javascript与DOM交互中常常须要使用函数绑定，定义一个函数而后将其绑定到特定DOM元素或集合的某个事件触发程序上，绑定函数常常和回调函数及事件处理程序一块儿使用，以便把函数做为变量传递的同时保留代码执行环境

<button id="btn">按钮</button><script>            
    var handler={
        message:"Event handled.",
        handlerFun:function(){
            alert(this.message);
        }
    };
btn.onclick = handler.handlerFun;</script>

上面的代码建立了一个叫作handler的对象。handler.handlerFun()方法被分配为一个DOM按钮的事件处理程序。当按下该按钮时，就调用该函数，显示一个警告框。虽然貌似警告框应该显示Event handled，然而实际上显示的是undefiend。这个问题在于没有保存handler.handleClick()的环境，因此this对象最后是指向了DOM按钮而非handler

　　可使用闭包来修正这个问题

<button id="btn">按钮</button><script>            var handler={
    message:"Event handled.",
    handlerFun:function(){
        alert(this.message);
    }
};
btn.onclick = function(){
    handler.handlerFun();    
}</script>

固然这是特定于此场景的解决方案，建立多个闭包可能会令代码难以理解和调试。更好的办法是使用函数绑定

　　一个简单的绑定函数bind()接受一个函数和一个环境，并返回一个在给定环境中调用给定函数的函数，而且将全部参数原封不动传递过去

function bind(fn,context){    return function(){        return fn.apply(context,arguments);
    }
}

这个函数彷佛简单，但其功能是很是强大的。在bind()中建立了一个闭包，闭包使用apply()调用传入的函数，并给apply()传递context对象和参数。当调用返回的函数时，它会在给定环境中执行被传入的函数并给出全部参数

<button id="btn">按钮</button><script>  function bind(fn,context){    return function(){        return fn.apply(context,arguments);
    }
}          
var handler={
    message:"Event handled.",
    handlerFun:function(){
        alert(this.message);
    }
};
btn.onclick = bind(handler.handlerFun,handler);</script>

ECMAScript5为全部函数定义了一个原生的bind()方法，进一步简化了操做

　　只要是将某个函数指针以值的形式进行传递，同时该函数必须在特定环境中执行，被绑定函数的效用就突显出来了。它们主要用于事件处理程序以及setTimeout()和setInterval()。然而，被绑定函数与普通函数相比有更多的开销，它们须要更多内存，同时也由于多重函数调用稍微慢一点，因此最好只在必要时使用

函数柯里化

与函数绑定紧密相关的主题是函数柯里化(function currying)，它用于建立已经设置好了一个或多个参数的函数。函数柯里化的基本方法和函数绑定是同样的：使用一个闭包返回一个函数。二者的区别在于，当函数被调用时，返回的函数还须要设置一些传入的参数

function add(num1,num2){    return num1+num2;
}function curriedAdd(num2){    return add(5,num2);
}
console.log(add(2,3));//5console.log(curriedAdd(3));//8

这段代码定义了两个函数：add()和curriedAdd()。后者本质上是在任何状况下第一个参数为5的add()版本。尽管从技术来讲curriedAdd()并不是柯里化的函数，但它很好地展现了其概念

　　柯里化函数一般由如下步骤动态建立：调用另外一个函数并为它传入要柯里化的函数和必要参数。下面是建立柯里化函数的通用方式

function curry(fn){    var args = Array.prototype.slice.call(arguments, 1);    return function(){        var innerArgs = Array.prototype.slice.call(arguments),
        finalArgs = args.concat(innerArgs);        return fn.apply(null, finalArgs);
    };
}

curry()函数的主要工做就是将被返回函数的参数进行排序。curry()的第一个参数是要进行柯里化的函数，其余参数是要传入的值。为了获取第一个参数以后的全部参数，在arguments对象上调用了slice()方法，并传入参数1表示被返回的数组包含从第二个参数开始的全部参数。而后args数组包含了来自外部函数的参数。在内部函数中，建立了innerArgs数组用来存放全部传入的参数(又一次用到了slice())。有了存放来自外部函数和内部函数的参数数组后，就可使用concat()方法将它们组合为finalArgs，而后使用apply()将结果传递给函数。注意这个函数并无考虑到执行环境，因此调用apply()时第一个参数是null。curry()函数能够按如下方式应用

function add(num1, num2){    return num1 + num2;
}var curriedAdd = curry(add, 5);
alert(curriedAdd(3)); //8

在这个例子中，建立了第一个参数绑定为5的add()的柯里化版本。当调用cuurriedAdd()并传入3时，3会成为add()的第二个参数，同时第一个参数依然是5，最后结果即是和8。也能够像下例这样给出全部的函数参数：

function add(num1, num2){    return num1 + num2;
}var curriedAdd2 = curry(add, 5, 12);
alert(curriedAdd2()); //17

在这里，柯里化的add()函数两个参数都提供了，因此之后就无需再传递给它们了

函数柯里化还经常做为函数绑定的一部分包含在其中，构造出更为复杂的bind()函数

function bind(fn, context){    var args = Array.prototype.slice.call(arguments, 2);    return function(){        var innerArgs = Array.prototype.slice.call(arguments),
        finalArgs = args.concat(innerArgs);        return fn.apply(context, finalArgs);
    };
}

对curry()函数的主要更改在于传入的参数个数，以及它如何影响代码的结果。curry()仅仅接受一个要包裹的函数做为参数，而bind()同时接受函数和一个object对象。这表示给被绑定的函数的参数是从第三个开始而不是第二个，这就要更改slice()的第一处调用。另外一处更改是在倒数第3行将object对象传给apply()。当使用bind()时，它会返回绑定到给定环境的函数，而且可能它其中某些函数参数已经被设好。要想除了event对象再额外给事件处理程序传递参数时，这很是有用

var handler = {
    message: "Event handled",
    handleClick: function(name, event){
        alert(this.message + ":" + name + ":" + event.type);
    }
};var btn = document.getElementById("my-btn");
EventUtil.addHandler(btn, "click", bind(handler.handleClick, handler, "my-btn"));

handler.handleClick()方法接受了两个参数：要处理的元素的名字和event对象。做为第三个参数传递给bind()函数的名字，又被传递给了handler.handleClick()，而handler.handleClick()也会同时接收到event对象

ECMAScript5的bind()方法也实现函数柯里化，只要在this的值以后再传入另外一个参数便可

var handler = {
    message: "Event handled",
    handleClick: function(name, event){
        alert(this.message + ":" + name + ":" + event.type);
    }
};var btn = document.getElementById("my-btn");
EventUtil.addHandler(btn, "click", handler.handleClick.bind(handler, "my-btn"));

javaScript中的柯里化函数和绑定函数提供了强大的动态函数建立功能。使用bind()仍是curry()要根据是否须要object对象响应来决定。它们都能用于建立复杂的算法和功能，固然二者都不该滥用，由于每一个函数都会带来额外的开销

函数重写

因为一个函数能够返回另外一个函数，所以能够用新的函数来覆盖旧的函数

function a(){
    console.log('a');
    a = function(){
        console.log('b');
    }
}

这样一来，当咱们第一次调用该函数时会console.log('a')会被执行；全局变量a被重定义，并被赋予新的函数

当该函数再次被调用时， console.log('b')会被执行

再复杂一点的状况以下所示

var a = (function(){
    function someSetup(){        var setup = 'done';
    }
    function actualWork(){
        console.log('work');
    }
    someSetup();    return actualWork;
})()

咱们使用了私有函数someSetup()和actualWork()，当函数a()第一次被调用时，它会调用someSetup()，并返回函数actualWork()的引用

前端技术分享点击：加入