Javascript中call，apply，bind方法的详解与总结

 

 

在 javascript之 this 关键字详解 文章中，谈及了以下内容，作一个简单的回顾：

1.this对象的涵义就是指向当前对象中的属性和方法。

2.this指向的可变性。当在全局做用域时，this指向全局；当在某个对象中使用this时，this指向该对象；当把某个对象的方法赋值给另一个对象时，this会指向后一个对象。

3.this的使用场合有：在全局环境中使用；在构造函数中使用，在对象的方法中使用。

4.this的使用注意点，最重要的一点就是要避免多层嵌套使用this对象。

 

对this关键字有了稍稍了解便知道，this对象指向会常常改变的，这会形成一些意想不到的影响。JavaScript提供了call、apply、bind这三个方法，来切换/固定this的指向。

 

如下内容会分为以下小节：

1.call/apply/bind方法的来源

2.Function.prototype.call()

3.Function.prototype.apply()

　　3.1：找出数组中的最大数

　　3.2：将数组的空元素变为undefined

　　3.3：转换相似数组的对象

4.Function.prototype.bind()

5.绑定回调函数的对象

6.call，apply，bind方法的联系和区别

 

1.call/apply/bind方法的来源

　　首先，在使用call，apply，bind方法时，咱们有必要知道这三个方法到底是来自哪里？为何可使用的到这三个方法？

　　call，apply，bind这三个方法其实都是继承自Function.prototype中的，属于实例方法。

1     console.log(Function.prototype.hasOwnProperty('call')) //true
2     console.log(Function.prototype.hasOwnProperty('apply')) //true
3     console.log(Function.prototype.hasOwnProperty('bind')) //true

　　上面代码中，都返回了true，代表三种方法都是继承自Function.prototype的。固然，普通的对象，函数，数组都继承了Function.prototype对象中的三个方法，因此这三个方法均可以在对象，数组，函数中使用。

　　关于继承的概念，会在之后与你们分享。

 

2.Function.prototype.call()

　　函数实例的call方法，能够指定该函数内部this的指向（即函数执行时所在的做用域），而后在所指定的做用域中，调用该函数。而且会当即执行该函数。

　　看个例子来好好理解这段话。

 1     var keith = {
 2         rascal: 123
 3     };
 4 
 5     var rascal = 456;
 6 
 7     function a() {
 8         console.log(this.rascal);
 9     }
10 
11     a(); //456
12     a.call(); //456
13     a.call(null); //456
14     a.call(undefined); //456
15     a.call(this); //456
16     a.call(keith); //123

　　上面代码中，a函数中的this关键字，若是指向全局对象，返回结果为456。能够看到，若是call方法没有参数，或者参数为null或undefined或者this，则等同于指向全局对象。若是使用call方法将this关键字指向keith对象，也就是将该函数执行时所在的做用域为keith对象，返回结果为123。

　　call()方法能够传递两个参数。第一个参数是指定函数内部中this的指向（也就是函数执行时所在的做用域），第二个参数是函数调用时须要传递的参数。

1     function keith(a, b) {
2         console.log(a + b);
3     }
4 
5     keith.call(null, 1, 2); //3

　　第一个参数是必须的，能够是null，undefined，this，可是不能为空。设置为null，undefined，this代表函数keith此时处于全局做用域。第二个参数中必须一个个添加。而在apply中必须以数组的形式添加。

　　call方法的一个应用是调用对象的原生方法。也能够用于将类数组对象转换为数组。

 1     var obj = {};
 2     console.log(obj.hasOwnProperty('toString')); //false
 3 
 4     obj.hasOwnProperty = function() {
 5         return true;
 6     }
 7 
 8     console.log(obj.hasOwnProperty('toString')); //true
 9 
10     console.log(Object.prototype.hasOwnProperty.call(obj, 'toString')); //false

　　上面代码中，hasOwnProperty是obj对象继承的方法，若是这个方法一旦被覆盖，就不会获得正确结果。call方法能够解决这个方法，它将hasOwnProperty方法的原始定义放到obj对象上执行，这样不管obj上有没有同名方法，都不会影响结果。要注意的是，hasOwnProperty是Object.prototype原生对象的方法，而call是继承自Function.prototype的方法。

　　

3.Function.prototype.apply()

　　apply方法的做用与call方法相似，也是改变this指向（函数执行时所在的做用域），而后在指定的做用域中，调用该函数。同时也会当即执行该函数。惟一的区别就是，它接收一个数组做为函数执行时的参数。

　　apply方法的第一个参数也是this所要指向的那个对象，若是设为null或undefined或者this，则等同于指定全局对象。第二个参数则是一个数组，该数组的全部成员依次做为参数，在调用时传入原函数。原函数的参数，在call方法中必须一个个添加，可是在apply方法中，必须以数组形式添加。

　　看一下call，apply的细微差异。

1     function keith(a, b) {
2         console.log(a + b);
3     }
4 
5     keith.call(null, 2, 3); //5
6     keith.apply(null, [2, 3]); //5

　　上面代码中，第一个参数为null，指向全局做用域；第二个参数传入的形式稍稍不一样。

　　apply方法有如下应用。

 

　　3.1：找出数组中的最大数

1     var a = [2, 4, 5, 7, 8, 10];
2 
3     console.log(Math.max.apply(null, a)); //10
4     console.log(Math.max.call(null,2, 4, 5, 7, 8, 10)); //10

　　Javascript中是没有提供找出数组中最大值的方法的，结合使用继承自Function.prototype的apply和Math.max方法，就能够返回数组的最大值。

　　

　　3.2：将数组的空元素变为undefined

　　经过apply方法，利用Array构造函数将数组的空元素变成undefined。

1 console.log(Array.apply(null, [1, , 3])); // [1, undefined, 3]

　　空元素与undefined的差异在于，数组的forEach方法会跳过空元素，可是不会跳过undefined和null。所以，遍历内部元素的时候，会获得不一样的结果。

    var a = [1, , 3];
    a.forEach(function(index) {
        console.log(index); //1,3 ，跳过了空元素。
    })

    Array.apply(null,a).forEach(function(index){
        console.log(index);    ////1,undefined,3  ，将空元素设置为undefined
    })

 

　　3.3：转换相似数组的对象

　　另外，利用数组对象的slice方法，能够将一个相似数组的对象（好比arguments对象）转为真正的数组。固然，slice方法的一个重要应用，就是将相似数组的对象转为真正的数组。call和apply均可以实现该应用。

1     console.log(Array.prototype.slice.apply({0:1,length:1}));    //[1]
2     console.log(Array.prototype.slice.call({0:1,length:1}));    //[1]
3     console.log(Array.prototype.slice.apply({0:1,length:2}));    //[1,undefined]
4     console.log(Array.prototype.slice.call({0:1,length:2}));    //[1,undefined]

1     function keith(a,b,c){
2         return arguments;
3     }
4 
5     console.log(Array.prototype.slice.call(keith(2,3,4)));    //[2,3,4]

　　上面代码的call，apply方法的参数都是对象，可是返回结果都是数组，这就起到了将对象转成数组的目的。从上面代码能够看到，这个方法起做用的前提是，被处理的对象必须有length属性，以及相对应的数字键。

 

　　

4.Function.prototype.bind()

　　bind方法用于指定函数内部的this指向（执行时所在的做用域），而后返回一个新函数。bind方法并不是当即执行一个函数。

 1     var keith = {
 2         a: 1,
 3         count: function() {
 4             console.log(this.a++);
 5         }
 6     };
 7 
 8     keith.count(); //1
 9     keith.count(); //2
10     keith.count(); //3

　　上面代码中，若是this.a指向keith对象内部的a属性，若是这个方法赋值给另一个变量，调用时就会出错。

1     var keith = {
2         a: 1,
3         count: function() {
4             console.log(this.a++);
5         }
6     };
7 
8     var f = keith.count;
9     f(); //NaN

　　上面代码中，若是把count方法赋值给f变量，那么this对象指向再也不是keith对象了，而是window对象。而window.a默认为undefined，进行递增运算以后undefined++就等于NaN。

　　为了解决这个问题，可使用bind方法，将keith对象里的this绑定到keith对象上，或者是直接调用。

1     var f = keith.count.bind(keith);
2     f(); //1
3     f(); //2
4     f(); //3

1     keith.count.bind(keith)() //1
2     keith.count.bind(keith)() //2
3     keith.count.bind(keith)() //3

　　固然，this也能够绑定到其余对象上。

1     var obj = {
2         a: 100
3     };
4     var f = keith.count.bind(obj);
5     f(); //100
6     f(); //101
7     f(); //102

　　一样，咱们也能够给bind方法传递参数，第一个参数若是为null或者undefined或者this，会将函数内部的this对象指向全局环境；第二个为调用时须要的参数，而且传递参数的形式与call方法相同。

1     function keith(a, b) {
2         return a + b;
3     }
4     console.log(keith.apply(null,[1,4])); //5
5     console.log(keith.call(null,1,4)); //5
6     console.log(keith.bind(null, 1, 4)); //keith()
7     console.log(keith.bind(null, 1, 4)()); //5

　　上面代码中，能够看出call，apply，bind三者的区别：call和apply方法都是在调用以后当即执行的。而bind调用以后是返回原函数，须要再调用一次才行，有点像闭包的味道，若是对闭包概念不熟悉，能够浏览这两篇文章：javascript--函数参数与闭包--详解，javascript中重要概念-闭包-深刻理解。

 

5.绑定回调函数的对象

　　在这篇文章javascript之 this 关键字详解中，有谈及到若是在回掉函数中使用this对象，那么this对象是会指向DOM对象，也就是button对象。若是要解决回调函数中this指向问题，能够用以下方法。

 1     var o = {
 2         f: function() {
 3             console.log(this === o);
 4         }
 5     }
 6 
 7     $('#button').on('click', function() {
 8         o.f.apply(o);
 9         //或者 o.f.call(o);
10         //或者 o.f.bind(o)();
11     });

　　点击按钮之后，控制台将会显示true。因为apply方法（或者call方法）不只绑定函数执行时所在的对象，还会当即执行函数（而bind方法不会当即执行，注意区别），所以不得不把绑定语句写在一个函数体内。

 

6.call，apply，bind方法的联系和区别

　　其实用于指定函数内部的this指向的问题，这三个方法都差很少，只是存在形式上的差异。读者能够将以上的例子用三种方法尝试用三种方法实现。

　　总结一下call，apply，bind方法：

　　a：第一个参数都是指定函数内部中this的指向（函数执行时所在的做用域），而后根据指定的做用域，调用该函数。

　　b：均可以在函数调用时传递参数。call，bind方法须要直接传入，而apply方法须要以数组的形式传入。

　　c：call，apply方法是在调用以后当即执行函数，而bind方法没有当即执行，须要将函数再执行一遍。有点闭包的味道。

　　d：改变this对象的指向问题不只有call，apply，bind方法，也可使用that变量来固定this的指向。若有疑问，请访问 javascript之 this 关键字详解

 

完。

 

感谢你们的阅读。

转载请注明出处：http://www.cnblogs.com/Uncle-Keith/p/5822549.html