apply call this arguments caller callee
JavaScript为函数对象定义了两个方法：apply和call，它们的作用都是将函数绑定到另
外一个对象上去运行，两者仅在定义参数的方式有所区别：
Function.prototype.apply(thisArg,argArray);
Function.prototype.call(thisArg[,arg1[,arg2…]]);
从函数原型可以看到，第一个参数都被取名为thisArg，也就是说，所有函数内部的this
指针都会被赋值为thisArg，这就达到了将函数作为另外一个对象的方法运行的目的。两个
方法除了thisArg 参数，都是为Function 对象传递的参数。
<script type="text/javascript"> //定义一个函数func1，具有属性p和方法A function func1() { this.p = "func1-"; this.A = function (arg) { alert(this.p + arg); } } //定义一个函数func2，具有属性p和方法B function func2() { this.p = "func2-"; this.B = function (arg) { alert(this.p + arg); } } var obj1 = new func1(); var obj2 = new func2(); obj1.A("byA"); //显示func1-byA obj2.B("byB"); //显示func2-byB obj1.A.apply(obj2, ["byA"]); //显示func2-byA，其中[“byA”]是仅有一个元素的数组，下同 obj2.B.apply(obj1, ["byB"]); //显示func1-byB obj1.A.call(obj2, "byA"); //显示func2-byA obj2.B.call(obj1, "byB"); //显示func1-byB </script>
可以看出，obj1的方法A被绑定到obj2运行后，整个函数A的运行环境就转移到了obj2，
即this指针指向了obj2。同样obj2 的函数B也可以绑定到obj1 对象去运行。代码的最后4
行显示了apply和call函数参数形式的区别。
与 arguments 的length属性不同，函数对象的还有一个参数相关的属性length，它表示
函数定义时所指定参数的个数，而非调用时实际传递的参数个数。例如下面的代码将显示2：
function sum(a,b){ return a+b; } alert(sum.length);
call,apply都是Function的原型的方法，其他function继承
this
和传统意义的面向对象的语言不同，JavaScript 中的this 指针是一个动态的变量，一个
方法内的this指针并不是始终指向定义该方法的对象的，在上一节讲函数的apply和call方
法时已经有过这样的例子。
<script type="text/javascript"> <!-- //创建两个空对象 var obj1 = new Object(); var obj2 = new Object(); //给两个对象都添加属性p，并分别等于1和2 obj1.p = 1; obj2.p = 2; //给obj1添加方法，用于显示p的值 obj1.getP = function () { alert(this.p); //表面上this指针指向的是obj1 } //调用obj1的getP方法 obj1.getP(); //使obj2的getP方法等于obj1的getP方法 obj2.getP = obj1.getP; //调用obj2的getP方法 obj2.getP(); //--> </script>
从代码的执行结果看，分别弹出对话框1 和2。由此可见，getP函数仅定义了一次，在
不同的场合运行，显示了不同的运行结果，这是有this指针的变化所决定的。在obj1 的getP
方法中，this就指向了obj1 对象，而在obj2 的getP 方法中，this就指向了obj2 对象，并通
过this指针引用到了两个对象都具有的属性p。
由此可见，JavaScript 中的this 指针是一个动态变化的变量，它表明了当前运行该函数
的对象。由this指针的性质，也可以更好的理解JavaScript中对象的本质：一个对象就是由
一个或多个属性（方法）组成的集合。每个集合元素不是仅能属于一个集合，而是可以动态
的属于多个集合。这样，一个方法（集合元素）由谁调用，this指针就指向谁。实际上，前
面介绍的apply方法和call方法都是通过强制改变this指针的值来实现的，使this指针指向
参数所指定的对象，从而达到将一个对象的方法作为另一个对象的方法运行的效果。
this的范围
var user={ name:"jack", //定义了name属性，初始化为jack favoriteColor:["red","green","black","white"],//定义了颜色喜好数组 hello:function(){ //定义了方法hello alert("hello,"+this.name); }, sex:"male" //定义了性别属性sex，初始化为sex } user.hello(); //"hello,jack"
var user={ name:"jack", //定义了name属性，初始化为jack favoriteColor:["red","green","black","white"],//定义了颜色喜好数组 hello:function(){ //定义了方法hello alert("hello,"+name); }, sex:"male" //定义了性别属性sex，初始化为sex } user.hello(); //"hello,"
name="hongda"; var user={ name:"jack", //定义了name属性，初始化为jack favoriteColor:["red","green","black","white"],//定义了颜色喜好数组 hello:function(){ //定义了方法hello alert("hello,"+name); }, sex:"male" //定义了性别属性sex，初始化为sex } user.hello(); //"hello,hongda"
name = "hongda"; var user = { name: "jack", //定义了name属性，初始化为jack favoriteColor: ["red", "green", "black", "white"], //定义了颜色喜好数组 hello: function () { //定义了方法hello name = "hongdadada"; alert("hello," + name); }, sex: "male" //定义了性别属性sex，初始化为sex } user.hello(); //"hello,hongdadada"
一个对象内部的方法调用该对象的属性时要指明this,该属性不是某个范围内的变量。
function fun() { name = "hongdada"; function show() { //没有意义 alert(name); } } var f = new fun(); console.dir(f);
function fun() { this.name = "hongdada"; this.show=function show() { alert(name); } } var f = new fun(); console.dir(f);
function中没有this时，它就是个方法，只有有this时它才类似一个类
传递给函数的隐含参数：arguments
当进行函数调用时，除了指定的参数外，还创建一个隐含的对象——arguments。
arguments是一个类似数组但不是数组的对象，说它类似是因为它具有数组一样的访问性质，
可以用arguments[index]这样的语法取值，拥有数组长度属性length。arguments 对象存储的
是实际传递给函数的参数，而不只局限于函数声明所定义的参数列表，
function func(a,b){ alert(a); alert(b); for(var i=0;i<arguments.length;i++){ alert(arguments[i]); } } func(1,2,3); //1,2,1,2,3
代码：
<script type="text/javascript"> function dwn(s) { document.write(s + "<br/>"); } //定义一个多边形（Polygon）类型 function Polygon() { //存放多边形的顶点 var m_points = []; m_points = Array.apply(m_points, arguments); //用上面介绍的那种方式定义getter function GETTER() { }; GETTER.prototype = m_points[0]; this.firstPoint = new GETTER(); //公有属性 this.length = { valueOf: function () { return m_points.length }, toString: function () { return m_points.length } } //添加一个或多个顶点 this.add = function () { m_points.push.apply(m_points, arguments); } //取得序号为idx 的顶点 this.getPoint = function (idx) { return m_points[idx]; } //设置特定需要的顶点 this.setPoint = function (idx, point) { if (m_points[idx] == null) { m_points[idx] = point; } else { m_points[idx].x = point.x; m_points[idx].y = point.y; } } } //构造一个三角形p var p = new Polygon({ x: 1, y: 2 }, { x: 2, y: 4 }, { x: 2, y: 6 }); dwn(p.length); //3 dwn(p.firstPoint.x); //1 dwn(p.firstPoint.y); //2 p.firstPoint.x = 100; //不小心写了它的值 dwn(p.getPoint(0).x); //1 不会影响到实际的私有成员 delete p.firstPoint.x; //恢复 dwn(p.firstPoint.x); //1 p.setPoint(0, { x: 3, y: 4 }); //通过setter 改写了实际的私有成员 dwn(p.firstPoint.x); //3 getter 的值发生了改变 dwn(p.getPoint(0).x); //3 </script>
应用例子：
function dwn(s) { document.write(s + "<br/>"); } function App() { var fun={}; var arr = Array.apply(null, arguments); var arr2 = Array.apply(arr2, arguments); var arr3 = Array.apply(fun, arguments); var arr4 = Array.apply(window, arguments); dwn(arr); dwn(arr2); dwn(arr3); dwn(arr4); } App(1, 2, 3, 4, 5, 6, 7, 8);
Array这个function方法对象初始化中没有使用this，所有thisArg不管填什么都没影响。
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); //class2
call也可以形成继承
function Class1() { this.showTxt = function (txt) { alert(txt); } } function Class2() { Class1.call(this); } var c2 = new Class2(); c2.showTxt("cc"); //cc
class2继承class1
多继承
function Class1() { this.showTxt1 = function (txt) { alert("Class1:"+txt); } } function Class0() { this.showTxt0 = function (txt) { alert("Class0:"+txt); } } function Class2() { Class0.call(this); Class1.call(this); } var c2 = new Class2(); c2.showTxt0("cc"); c2.showTxt1("cccc");
在javascript框架prototype里就使用apply来创建一个定义类的模式
var Class = { create: function() { return function() { this.initialize.apply(this, arguments); } } }
解析：从代码看,该对象仅包含一个方法：Create，其返回一个函数，即类。但这也同时是类的
构造函数，其中调用initialize，而这个方法是在类创建时定义的初始化函数。通过如此途径，
就可以实现prototype中的类创建模式
var vehicle=Class.create(); vehicle.prototype = { initialize: function (type) { this.type = type; }, showSelf: function () { alert("this vehicle is " + this.type); } } var moto=new vehicle("Moto"); moto.showSelf();
