js中Function的apply方法与call方法理解
调试的时候走的是标红的这段代码，然后用到了callback.call这个函数，于是翻看了一下《js高级程序设计》，其中有比较深的解释。
首先，function是一个指向Function对象，函数名是一个指向函数的指针。那么在函数体内，就会有一个作用域，即this关键字。
this关键字指的是函数运行的作用域，举个例子来说，
&script type=&text/javascript&&
& & & & function funcA() {
& & & & & & alert(this);
& & & & & & alert(&Function A&);
上面这段代码中的函数funcA定义在全局环境中，那么函数体内的this即window对象。
下面该到call和apply的说明了。以call函数为例，call的第一个参数，就是改变函数的作用域，后面的参数为传入函数的所需的参数，必须与原函数的参数一直，举例说明：
&script type=&text/javascript&&
& & & & var testO = { name: &Lily& };
& & & & function funcA(a,b) {
& & & & & & alert(this);
& & & & & & alert(&Function A&);
& & & & function funcB(a, b) {
& & & & & & funcA.call(testO, a, b);
& & & & funcB(1,2); &//this变成了testO
& & &/script&
我们定义funcB函数的中，调用了funcA的call函数，这个时候我们改变了funcA中this的指向，原本指向window的，现在指向了call的第一个参数testO这个对象。而且调用call时，因为funcA函数有两个参数，所以如果要想funcA传递参数，必须一一指出参数，即后面的两个参数a和b，或者可以只穿第一个参数
即：funcA.call(testO)；或者只传a，即：funcA.call(testO,a);
而apply与call的区别仅在于，apply的第二个参数可以是数组形式，而且不必一一指出参数，funcA.apply(testO,[a,b])
介绍完call与apply的基本用法，该说说他哥俩真正的用武之地了，扩充函数赖以运行的作用域。
&script type=&text/javascript&&
& & & & window.color = &透明&;
& & & & var testObj = { color: &红色& };
& & & & function testFuc() {
& & & & & & alert(this.color);
& & & & $(function () {
& & & & & & 1.testFuc(); //弹出&透明&
& & & & & & 2.testFuc(this); //弹出&undefined&
& & & & & & 3.testFuc.call(this.parent); //弹出&透明&
& & & & & & 4.testFuc.call(window); //弹出&透明&
& & & & & & 5.testFuc.call(testObj); //弹出&红色&
& & & & });
上面这段代码演示了call的作用。第一个函数调用，this指向了window，所以弹出了window的color属性。
第二个函数可能有些朋友以为也会弹出透明，但是请先确定我们的函数运行在$(function(){});中，这个jQuery的函数，了解jQuery的朋友都很清楚，在
$(function(){});中this的作用域指向的是document，然后我们调用testFunc，要弹出document的color，当然是未定义的。
第三个函数将testFunc的this指向了document的亲爹window，弹出window的color当然也是没有问题的。
第四个函数就更加直白了，把window传进去了
第五个函数，将testFunc的this指向了testObj，弹出了红色。
讲到这里，用法大家应该都有所了解了，但是具体怎么去理解怎么去使用还是看自己的套路。
我是这么理解的，可以把这种用法看成是C#或者java中的泛型方法。比如一个C#方法的定义
public void Test&T&(T a, T b) { }
这样我们就可以实现对方法的扩展，实现通用的目的。快速理解JavaScript中apply()和call()的用法和用途 - 推酷
快速理解JavaScript中apply()和call()的用法和用途
之前，我们必须对
的作用和使用方法有所了解，可以参考我前一篇文章
。当然如果你已经熟悉
的相关知识，那么请直接往下看。
的作用十分相似，只是参数类型上的差别，以适应不同的使用场景。它们都是为了改变函数运行时的 context（上下文）而存在的，再说的直白一点，就是为了改变函数内部
恩？什么？我似乎听到你说改变this的指向？？那就是说。。。
没错！这样就可以实现继承啦！Exciting！
看下面的代码：
以下代码必须看过《疯狂动物城》才可看懂（逃）
function animal(name,food) {
this.name = name,
this.food = food,
this.say = function() {
console.log(name +& likes & + this.food + '.');
function rabbit(name,food) {
animal.call(this,name,food);
var Judy = new rabbit('Judy','carrot');
Judy.say();// &&& Judy likes carrot.
可以看出，我们声明了一个叫
的对象，我们并没有在
对象里添加任何属性和方法，但是我们使用
继承了原本属于
的属性和方法。就可以做到
函数所有能做到的事情。
这到底是怎么做到的呢？让我们来看看call()的参数：
第一个是一个对象，这个对象将代替
类里原本的
对象，我们传入的是
，记住，这个
函数里指的是
未来将要实例化这个函数的对象
（我知道这有些拗口），当声明了
的时候，这个
除了第一个参数，后面所有的参数都是传给
本身使用的参数。
功能几乎一样，唯一的区别就是
第二个参数只能是数组，这个数组将作为参数传给原函数的参数列表
其实在实际开发中，JS 继承的方法并不止这一种，使用
原型链继承
是更加常用的方式，此外还有
构造函数继承
，这里不展开。而apply使用的场景，更多的使用在这样一个场景：
需要将数组转化为参数列表。
的这个把数组转化为参数列表的特性，可以让它做一些有趣的事情。
方法的参数只能是一个或者多个参数，而不能是一个数组，当我们想要将
后面时，传统的做法是遍历
，每循环一次就push进
后面，这样就浪费了
可以传多个参数的功能。
我们可以这样做：
var list1 = [0,1,2];
var list2 = [3,4,5];
[].push.apply(list1,list2);
console.log(list1);// &&& [0,1,2,3,4,5]
看起来有点糊涂吗？可以这样理解：
list1调用了属于数组对象的push方法，这个push方法需要传入一个参数列表，而恰好我们有了list2这个数组类型的参数列表，实现了拼接操作。
第三行就相当于：
list1.push(3,4,5);
多么神奇！同样的，
等方法都只支持参数列表而不是数组，能做什么事情，你应该猜到了吧？
此外还有许多地方
的这个特性带来很多便利：比如函数式编程中的
currying（柯里化）
都有着不可或缺的作用。
既然说到这，那下一篇文章我就带大家认识
函数柯里化
。今天有点晚了，先休息啦~
已发表评论数()
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
没有分页内容
图片无法显示
视频无法显示
与原文不一致JS中的call()和apply()方法_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
JS中的call()和apply()方法
上传于||文档简介
&&J​S​中​的​c​a​l​l​(​)
阅读已结束，如果下载本文需要使用1下载券
想免费下载本文？
你可能喜欢最近用js的类写东西，发现一个无比蛋疼的事，那就是封装的类方法中的this指针经常会改变指向，失去上下文，导致错误或崩溃。比如:function Obj(){ 　　this.type = "obj";}Obj.prototype = { 　　show : function (){
　　etTimeout(function (){
　　　　console.log(this.type);
　　},300) }var obj = new Obj();obj.show(); &//undefined所幸伟大的js有多种方法可以解决这个问题。我们可以直接保存上下文的指针指向 比如 &var self = 然后用缓存的 self指针，但是js里面有 bind，apply，call等比较好用的方法，来指定上下文。语法：fn.bind(obj,arguments)　　　fn.apply(obj,arguments)　　　fn.call(obj,arguments)区别：　　1.bind返回一个方法，而其余两个都直接调用了函数；　　2.第一个参数都一样，指定上下文对象，第二个参数apply是数组，而call则对应形参call和apply方法
call方法可改变上下文this指针，类似的方法还有apply，主要用在js对象各方法互相调用的时候，使当前this实例指针保持一致,或在特殊情况下需要改变this指针。
obj1.method1.call(obj2,argument1,argument2)
如上，call的作用就是把obj1的方法放到obj2上使用，后面的argument1…这些做为参数传入。
举一个具体的例子
function add(a, b) {
alert(a + b);
function sub(a, b) {
alert(a - b);
add.call(sub, 3, 1);
这个例子中的意思就是用 add 来替换 sub，add.call(sub,3,1) == add(3,1) ，所以运行结果为：alert(4); // 注意：js 中的函数其实是对象，函数名是对 Function 对象的引用。
看一个稍微复杂一点的例子
function Class1() {
this.name = &class1&;
this.showNam = function() {
alert(this.name);
function Class2() {
this.name = &class2&;
var c1 = new Class1();
var c2 = new Class2();
c1.showNam.call(c2);
注意，call 的意思是把 c1 的方法放到c2上执行，原来c2是没有showNam() 方法，现在是把c1 的showNam()方法放到 c2 上来执行，所以this.name 应该是 class2，执行的结果就是：alert（&class2&）;
另外可以用 call 来实现继承
function Class1() {
this.showTxt = function(txt) {
alert(txt);
function Class2() {
Class1.call(this);
var c2 = new Class2();
c2.showTxt(&cc&);
这样 Class2 就继承Class1了，Class1.call(this) 的 意思就是使用 Class1 对象代替this对象，那么 Class2 中不就有Class1 的所有属性和方法了吗，c2 对象就能够直接调用Class1 的方法以及属性了，执行结果就是：alert（“cc”）;
这就是 javaScript 如何来模拟面向对象中的继承的，还可以实现多重继承。
function Class10() {
this.showSub = function(a, b) {
alert(a - b);
function Class11() {
this.showAdd = function(a, b) {
alert(a + b);
function Class2() {
Class10.call(this);
Class11.call(this);
1.call方法 调用一个对象的一个方法，以另一个对象替换当前对象。
call([thisObj[,arg1[, arg2[, [,.argN]]]]])
thisObj 可选项。将被用作当前对象的对象。
arg1, arg2, , argN 可选项。将被传递方法参数序列。
2.apply方法 应用某一对象的一个方法，用另一个对象替换当前对象。
apply([thisObj[,argArray]])
thisObj 可选项。将被用作当前对象的对象。
argArray 可选项。将被传递给该函数的参数数组。
两者的区别：
两者实现的功能是完全一样的，只是参数传递方式不一样，call是将各个参数以逗号（,）隔开，而apply是将所有参数组成一个数组进行传递。
call和apply的第一个实参是要调用函数的母对象，它是调用上下文，在函数体内通过this来获得对它的引用。 例如，如果要想以对象o的方法来调用函数f，可以按如下的方式使用call和apply方法：
　　f.call(o); 　　f.apply(o);
可以按如下的代码来理解：
　　o.m =　　//将f存储为o的临时方法 　　o.m();　
先看MDN中对于call的解释 call() 方法在使用一个指定的this值和若干个指定的参数值的前提下调用某个函数或方法. 注:该方法的作用和 apply() 方法类似，只有一个区别，就是call()方法接受的是若干个参数的列表，而apply()方法接受的是一个包含多个参数的数组。 语法
fun.call(thisArg[, arg1[, arg2[, ...]]])
参数 thisAr
一、call和apply的说明 1、call，apply都属于Function.prototype的一个方法，它是JavaScript引擎内在实现的，因为属于Function.prototype，所以每个Function对象实例(就是每个方法)都有call，apply属性。既然作为方法的属性，那它们的使用就当然是针对方法的了，这两个方法是容易混淆的，因为它们的作用一样，只是使用方式不同。 2、语法
1、每个函数都包含两个非继承而来的方法：apply()和call()。 2、他们的用途相同，都是在特定的作用域中调用函数。 3、接收参数方面不同，apply()接收两个参数，一个是函数运行的作用域(this)，另一个是参数数组。 call()方法第一个参数与apply()方法相同，但传递给函数的参数必须列举出来。 　　例1：
window.firstName = &
第一次翻译技术文章，见笑了！ 翻译原文： Function.apply and Function.call in JavaScript 第一段略。 每个JavaScript函数都会有很多附属的（attached）方法，包括toString()、call()以及apply()。听起来，你是否会感到奇怪，一个函数可能会有属于它自己的方法，但是记住，JavaScript中的每个函数都是一个对象。看一下
一、方法的定义call方法: 语法：fun.call(thisArg[, arg1[, arg2[, ...]]])定义：调用一个对象的一个方法，以另一个对象替换当前对象。说明：call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisArg 指定的新对象。如果没有提供 thisArg参数，那么 Global 对象被用作 thisArg
1、call call 方法 调用一个对象的一个方法，以另一个对象替换当前对象。 call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 参数 thisObj 可选项。将被用作当前对象的对象。 arg1, arg2, , argN 可选项。将被传递方法参数序列。 说明 call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下
简单的说就是改变函数执行的上下文，这是最基本的用法。两个方法基本区别在于传参不同。 call(obj,arg1,arg2,arg3);call第一个参数传对象，可以是null。参数以逗号分开进行传值，参数可以是任何类型。 apply(obj,[arg1,arg2,arg3]);apply第一个参数传对象，参数可以是数组或者arguments 对象。 这两个方法通常被用来类的继承和回调函数：
之前我们说过 Javascript Call 方法，这次我们就说说和Call方法类似的apply方法。 apply vs call 两者间的不同在于:传递的是参数，还是参数数组 这个是call的用法
theFunction.call(valueForThis, arg1, arg2, ...)
而这个则是apply
theFunction.ap
&!DOCTYPE HTML PUBLIC &-//W3C//DTD HTML 4.0 Transitional//EN&& &HTML& &HEAD& &TITLE& How to - Javascript Call, apply, caller - http://www.never-online.net &/tITLE&
&script& /** *动物 */ function Animal(){ this.name='Amimal'; this.showName=function(){ alert(this.name); }; } /* *猫 */ function Cat(){ this.name='cat'; } var animal=new A//创
先来看看现象：
&html& &head& &title&apply_and_call&/title& &/head& &body onload=&init()&& &div id=&testDiv& style=&position: absolut
首先想说说javascript中函数的隐含参数：arguments Arguments 该对象代表正在执行的函数和调用它的函数的参数。 [function.]arguments[n] 参数function ：选项。当前正在执行的 Function 对象的名字。 n ：选项。要传递给 Function 对象的从0开始的参数值索引。 说明 Arguments是进行函数调用时，除了指定的参数外，还另外创
最近在使用jQuery的$.each方法时很，突然想到$.each($(‘div'),function(index,entity){});中的这个index和entity是哪冒出来的，而且可有可无的，而且这么高大上的能告诉我们当前遍历的下标和实例。所以看了一下jQuery源代码，是这么写的：
调试的时候走的是标红的这段代码，然后用到了callback.call这个函数，于是翻看了一下《js高级程
首先，有个单例对象，它上面挂了很多静态工具方法。其中有一个是each，用来遍历数组或对象。
var nativeForEach = [].forEach var nativeMap = [].map var util = {
each: function (obj, iterator, context) { &nb
call() 方法call() 方法是与经典的对象冒充方法最相似的方法。它的第一个参数用作 this 的对象。其他参数都直接传递给函数自身。例如：
function sayHello(sPrefix,sSuffix) {
alert(this.name + ”says“ + sPrefix + sSuffix); };
在ECMAScript v3中，给Function原型定义了这两个方法，这两个方法的作用都是一样的：使用这两个方法可以像调用其他对象方法一样调用函数，这句话是从书上抄的，至少我是没读明白这是什么意思。 下面说简单易懂的，先看段代码：
function Introduce(name,age) {
document.write(&
如果在学JavaScript这自由而变幻无穷的语言过程中遇到这种感觉,那么就从现在形始,请放下的您的&偏见&,因为这对您来说绝对是一片新大陆,让JavaScrip慢慢融化以前一套凝固的编程意识,注入新的生机! 好,言归正传,先理解JavaScrtipt动态变换运行时上下文特性,这种特性主要就体现在apply, call两个方法的运用上. 区分apply,call就一句话,
一. 基础篇
Javascript学习笔记1 数据类型
Javascript学习笔记2 函数
Javascript学习笔记3 作用域
Javascript学习笔记4 Eval函数
Javascript学习笔记5 类和对象
Javascript学习笔记6 prototype的提出
Javascript学习笔记7 原型链的原理
二. 实战篇Javascript学习笔记8 用JSON做原
在提到上述的概念之前，首先想说说javascript中函数的隐含参数：arguments arguments 该对象代表正在执行的函数和调用它的函数的参数。 [function.]arguments[n] 参数function：选项。当前正在执行的Function对象的名字。n：选项。要传递给Function对象的
在使用面向对象编程时，对象间的继承关系自然少不了！而原型正是实现javascript继承的很重要的一种方法！ 我们首先来看以下代码：
function person(name, age) { this.name = this.age = } person.prototype.getInfo = function() { alert(&My na
在提到上述的概念之前，首先想说说javascript中函数的隐含参数：arguments
Arguments 该对象代表正在执行的函数和调用它的函数的参数。
[function.]arguments[n] 参数function ：选项。当前正在执行的 Function 对象的名字。 n ：选项。要传递给 Function 对象的从0开始的参数值索引。 说明
Arguments是进行函数调用时
本地对象 ①Array类 ②Date类 对象的类型 内置对象 ①Global对象 ②Math对象 宿主对象 今天继续学习JS中的对象，昨天学完了本地对象中的两个重要对象Array和Date。今天看下内置对象Global对象和Math对象。 Global对象 encodeURI()方法用于处理完整的URI，去除一些空格等字符。 eval()方法可计算某个字符串，并执行其中的的 JavaScript
1、关于javascript的apply和call函数 prototype.js中用了大量的apply和call函数，不注意会造成理解偏差。 官方解释：应用某一对象的一个方法，用另一个对象替换当前对象。 apply与call的区别是第二个参数不同。apply是数组或者arguments对象。而call是逗号隔开的任何类型。
apply,call方法最让人混淆的
面向对象语言三大特点：继承，多态，封装，这三点虽然Javascript没有提供天然的语法实现，但是我们都可以通过prototype等技巧来实现，因此这种说法似乎不过分。 在Javascript中，构造对象有三种方式： 1. 首先，我们要明确一个概念，Javascript是一种弱类型的语言，一方面体现在Javascript的变量，返回类型都是没有强类型约束的，另一方面，Javascript可以为对象
&script type=&text/javascript&& //使用apply方法实现对象继承
function Parent(username) { this.username = this.sayHello = function() { alert(this.username); } }
function Child(
apply和call，它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数的方式有所区别： Function.prototype.apply(thisArg,argArray); Function.prototype.call(thisArg[,arg1[,arg2…]]); 从函数原型可以看到，第一个参数都被取名为thisArg，即所有函数内部的this指针都会被赋值为thisArg
1,javascript的原型模型：prototype 在实现面向对象，（像是定义一个类的时候）需要一个构造函数来定义对象的成员，而方法去依附在该构造函数的原型上．
2,javascript中，为了实现继承，必须将子类构造函数的prototype设置为一个父类的对象实例．
3,css的方块套方块模型： 最外是margin 是用来设置一个元素所占的空间的边缘到相邻元素的距离 边框：border
在Mozilla的官网中对于call()的介绍是:
call() 方法在使用一个指定的this值和若干个指定的参数值的前提下调用某个函数或方法.
Call() 语法
fun.call(thisArg[, arg1[, arg2[, ...]]])
Call() 参数 thisArg
在fun函数运行时指定的this
1、javascript中的内置对象 javascript中除了本身的内置对象，如以下我们所熟悉的对象： oArray oDate oMath oString oRegExp o…… 各个对象都有自己的属性及方法，比如我们经常使用属性及方法 属性：stringObject. arrayObject.…… 方法：stringObject.indexOf(); string
什么是JSON JSON：JavaScript 对象表示法（JavaScript Object Notation）。 JSON的形式是用大括号“{}”包围起来的项目列表，每一个项目间用逗号（,）分隔，而项目就是用冒号（:）分隔的属性名和属性值。这是典型的字典表示形式，也再次表明javascript里的对象就是字典结构。不管多么复杂的对象，都可以用一句JSON代码来创建并赋值。 JSON 结构 JS
javascript对象部分 一：基础部分 1.JavaScript 中所有变量都是对象，除了两个例外 null 和 undefined。 2.Jscript 支持四种类型的对象：内部对象、生成的对象、宿主给出的对象（所有BOM和DOM对象都是宿主对象。）以及 ActiveX 对象（外部组件）。 3.Microsoft Jscript 提供了 11 个内部（或“内置”）对象。它们是Array、Bo
私有变量和函数 在函数内部定义的变量和函数，如果不对外提供接口，外部是无法访问到的，也就是该函数的私有的变量和函数。
&script type=&text/javascript&&
function Test(){
&!doctype html& &html& &head& &meta http-equiv=&content-type& content=&text/ charset=UTF-8&& &title&javascript之null和undefined&/title&g
先看一下官方的解释： call 方法 请参阅 应用于：Function 对象 要求 版本 5.5 调用一个对象的一个方法，以另一个对象替换当前对象。 call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 参数 thisObj 可选项。将被用作当前对象的对象。 arg1, arg2, , argN 可选项。将被传递方法参数序列。 说明 call 方法可以用来代替另一个
本地对象 ①Array类 ②Date类
对象的类型 内置对象 ①Global对象 ②Math对象
宿主对象 今天继续学习JS中的对象，昨天内置对象Global对象和Math对象，今天继续。
宿主对象 所有非本地对象都是宿主对象host object，即由ECMAScript实现的宿主环境提供的对象。所有BOM和DOM对象都是宿主对象，书上说将在后面的章节讨论。-_-|||
作用域 JS中只
js组成 我们都知道， javascript 有三部分构成，ECMAScript，DOM和BOM，根据宿主（浏览器）的不同，具体的表现形式也不尽相同，ie和其他的浏览器风格迥异。
1. DOM 是 W3C 的标准； [所有浏览器公共遵守的标准] 2. BOM 是 各个浏览器厂商根据 DOM 在各自浏览器上的实现;[表现为不同浏览器定义有差别,实现方式不同] 3. window 是 BOM 对象，
一、 工厂方式 自己的理解：要创建很多个对象的实例，这些实例有相同的属性，但是有不同的属性值。这个时候就需要创个工厂函数（factory function）。 工厂函数（factory function）：创建并返回特定类型的对象。 工厂函数中如果一个属性是方法的话，可以在工厂函数的外面定义对象的方法，然后通过属性指向该方法，从而可以避开每次都调用自己的属性方法，这样做使得每个对象都共享了同一个函
事件 事件是DOM（文档对象模型）的一部分。事件流就是事件发生顺序，这是IE和其他浏览器在事件支持上的主要差别。
一、事件流 1、冒泡型事件 IE上的解决方案就是冒泡型事件，它的基本思想是从最特定的目标到最不特定的事件目标（document对象）的顺序触发。 过程：按照DOM的层次结构像水泡一样不断上升至顶端。（从里面的div触发事件再到body，到html最后直到document最顶端）。
先看看关于call()的官方解释，“调用一个对象的一个方法，以另一个对象替换当前对象。”，看了这样的解释，或许让你更摸不着头脑了。看例子：
var x = &我是全局变量&;　　　　//定义全局变量x
function a(){　　　　　　　　　//定义函数类结构a　　
this.x = &我是在函数类