JS中的call()和apply()方法和bind()

1、方法定义

call方法: 
语法&＃xff1a;call([thisObj[,arg1[, arg2[,   [,.argN]]]]]) 
定义&＃xff1a;调用一个对象的一个方法&＃xff0c;以另一个对象替换当前对象。 
说明&＃xff1a; 
call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。 
如果没有提供 thisObj 参数&＃xff0c;那么 Global 对象被用作 thisObj。 

apply方法&＃xff1a; 
语法&＃xff1a;apply([thisObj[,argArray]]) 
定义&＃xff1a;应用某一对象的一个方法&＃xff0c;用另一个对象替换当前对象。 
说明&＃xff1a; 
如果 argArray 不是一个有效的数组或者不是 arguments 对象&＃xff0c;那么将导致一个 TypeError。 
如果没有提供 argArray 和 thisObj 任何一个参数&＃xff0c;那么 Global 对象将被用作 thisObj&＃xff0c; 并且无法被传递任何参数。

 2.bind() 是es5中的新方法&＃xff0c;可以改变函数的上下文this指向&＃xff1a;

 今天看到一个

Javascript中借用方法的不错&＃xff1a;

在Javascript中&＃xff0c;有时可以重用其它对象的函数或方法&＃xff0c;而不一定非得是对象本身或原型上定义的。通过 call()、apply() 和 bind() 方法&＃xff0c;我们可轻易地借用其它对象的方法&＃xff0c;而无须继承这些对象。这是专业 Javascript 开发者常用的手段。

前提

本文假设你已经掌握使用 call()、apply() 和 bind() 的相关知识和它们之间的区别。

原型方法

在 Javascript 中&＃xff0c;除了不可更改的原始数据类型&＃xff0c;如 string、number 和 boolean&＃xff0c;几乎所有的数据都是对象。Array 是一种适用于遍历和转换有序数列的对象&＃xff0c;其原型上有 slice、join、push 和 pop 等好用的方法。

一个常用的例子是&＃xff0c;当对象和数组都是列表类型的数据结构时&＃xff0c;对象可以从数组“借用”方法。最常借用的方法是 Array.prototype.slice。

function myFunc() {

 

    // error, arguments is an array like object, not a real array

    arguments.sort();

 

    // "borrow" the Array method slice from its prototype, which takes an array like object (key:value)

    // and returns a real array

    var args &＃61; Array.prototype.slice.call(arguments);

 

    // args is now a real Array, so can use the sort() method from Array

    args.sort();

 

}

 

myFunc(&＃39;bananas&＃39;, &＃39;cherries&＃39;, &＃39;apples&＃39;);

借用方法之所以可行&＃xff0c;是因为 call 和 apply 方法允许在不同上下文中调用函数&＃xff0c;这也是重用已有功能而不必继承其它对象的好方法。实际上&＃xff0c;数组在原型中定义了很多常用方法&＃xff0c;比如 join 和 filter 也是&＃xff1a;

// takes a string "abc" and produces "a|b|c

Array.prototype.join.call(&＃39;abc&＃39;, &＃39;|&＃39;);

 

// takes a string and removes all non vowels

Array.prototype.filter.call(&＃39;abcdefghijk&＃39;, function(val) {

    return [&＃39;a&＃39;, &＃39;e&＃39;, &＃39;i&＃39;, &＃39;o&＃39;, &＃39;u&＃39;].indexOf(val) !&＃61;&＃61; -1;

}).join(&＃39;&＃39;);

可以看出&＃xff0c;不仅对象可以借用数组的方法&＃xff0c;字符串也可以。但是因为泛型方法是在原型上定义的&＃xff0c;每次想要借用方法时都必须使用 String.prototype 或 Array.prototype。这样写很啰嗦&＃xff0c;很快就会令人生厌。更有效的方法是使用字面量来达到同样的目的。

使用字面量借用方法

字面量是一种遵循Javascript规则的语法结构&＃xff0c;MDN 这样解释&＃xff1a;

在Javascript中&＃xff0c;使用字面量可以代表值。它们是固定值&＃xff0c;不是变量&＃xff0c;就是在脚本中按字面给出的。

字面量可以简写原型方法&＃xff1a;

[].slice.call(arguments);

[].join.call(&＃39;abc&＃39;, &＃39;|&＃39;);

&＃39;&＃39;.toUpperCase.call([&＃39;lowercase&＃39;, &＃39;words&＃39;, &＃39;in&＃39;, &＃39;a&＃39;, &＃39;sentence&＃39;]).split(&＃39;,&＃39;);

这样看上去没有那么冗长了&＃xff0c;但是必须直接在 [] 和 "" 上操作以借用方法&＃xff0c;仍然有点丑。可以利用变量保存对字面量和方法的引用&＃xff0c;这样写起来更简便些&＃xff1a;

var slice &＃61; [].slice;

slice.call(arguments);

var join &＃61; [].join;

join.call(&＃39;abc&＃39;, &＃39;|&＃39;);

 

var toUpperCase &＃61; &＃39;&＃39;.toUpperCase;

toUpperCase.call([&＃39;lowercase&＃39;, &＃39;words&＃39;, &＃39;in&＃39;, &＃39;a&＃39;, &＃39;sentence&＃39;]).split(&＃39;,&＃39;);

有了借用方法的引用&＃xff0c;我们就可以轻松地使用 call() 调用它了&＃xff0c;这样也可以重用代码。秉着减少冗余的原则&＃xff0c;我们来看看可否借用方法却不用每次调用都要写 call() 或者 apply()&＃xff1a;

var slice &＃61; Function.prototype.call.bind(Array.prototype.slice);

slice(arguments);

 

var join &＃61; Function.prototype.call.bind(Array.prototype.join);

join(&＃39;abc&＃39;, &＃39;|&＃39;);

 

var toUpperCase &＃61; Function.prototype.call.bind(String.prototype.toUpperCase);

toUpperCase([&＃39;lowercase&＃39;, &＃39;words&＃39;, &＃39;in&＃39;, &＃39;a&＃39;, &＃39;sentence&＃39;]).split(&＃39;,&＃39;);

如你所见&＃xff0c;现在可以使用 Function.prototype.call.bind 来静态绑定从不同原型“借来的”方法了。但是 var slice &＃61; Function.prototype.call.bind(Array.prototype.slice) 这句话实际是如何起作用的呢&＃xff1f;

理解 Function.prototype.call.bind

Function.prototype.call.bind 乍一看有些复杂&＃xff0c;但是理解它是如何起作用的会非常有益。

• Function.prototype.call 是一种引用&＃xff0c;可以“call”函数并将设置其“this”值以在函数中使用。

• 注意“bind”返回一个存有其“this”值的新函数。因此 .bind(Array.prototype.slice) 返回的新函数的“this”总是 Array.prototype.slice 函数。

综上所述&＃xff0c;新函数会调用“call”函数&＃xff0c;并且其“this”为“slice”函数。调用 slice() 就会指向之前限定的方法。

自定义对象的方法

继承很棒&＃xff0c;但是开发者通常在想要重用一些对象或模块间的通用功能时才会使用。没必要仅为代码重用使用继承&＃xff0c;因为在多数情况下简单的借用方法会很复杂。

之前我们只讨论了借用原生方法&＃xff0c;但是借用任何方法都是可以的。比如下面的代码可以计算积分游戏的玩家分数&＃xff1a;

var scoreCalculator &＃61; {

    getSum: function(results) {

        var score &＃61; 0;

        for (var i &＃61; 0, len &＃61; results.length; i

            score &＃61; score &＃43; results[i];

        }

        return score;

    },

    getScore: function() {

        return scoreCalculator.getSum(this.results) / this.handicap;

    }

};

var player1 &＃61; {

    results: [69, 50, 76],

    handicap: 8

};

 

var player2 &＃61; {

    results: [23, 4, 58],

    handicap: 5

};

 

var score &＃61; Function.prototype.call.bind(scoreCalculator.getScore);

 

// Score: 24.375

console.log(&＃39;Score: &＃39; &＃43; score(player1));

 

// Score: 17

console.log(&＃39;Score: &＃39; &＃43; score(player2));

虽然上面的例子很生硬&＃xff0c;但是可以看出&＃xff0c;就像原生方法一样&＃xff0c;用户定义的方法也可以轻松借用。

总结

Call、bind 和 apply 可以改变函数的调用方式&＃xff0c;并且经常在借用函数时使用。多数开发者熟悉借用原生方法&＃xff0c;但是较少借用自定义的方法。

近几年 Javascript 的函数式编程发展不错&＃xff0c;怎样使用 Function.prototype.call.bind 借用方法才更加简便&＃xff1f;估计这样的话题会越来越常见。