ajax入门之深入理解javascript中的函数_ajax教程

函数是进行模块化程式设计的基础，编写复杂的Ajax应用程式，必须对函数有更深入的了解。JavaScript中的函数不同于其他的语言，每个函数都是作为一个对象被维护和运行的。通过函数对象的性质，能非常方便的将一个函数赋值给一个变量或将函数作为参数传递。在继续讲述之前，先看一下函数的使用语法：

function func1(…){…}
var func2=function(…){…};
var func3=function func4(…){…};
var func5=new Function();

　　这些都是声明函数的正确语法。他们和其他语言中常见的函数或之前介绍的函数定义方式有着非常大的差别。那么在JavaScript中为什么能这么写？他所遵循的语法是什么呢？下面将介绍这些内容。

　　认识函数对象（Function Object）

　　能用function关键字定义一个函数，并为每个函数指定一个函数名，通过函数名来进行调用。在JavaScript解释执行时，函数都是被维护为一个对象，这就是要介绍的函数对象（Function Object）。

　　函数对象和其他用户所定义的对象有着本质的差别，这一类对象被称之为内部对象，例如日期对象（Date）、数组对象（Array）、字符串对象（String）都属于内部对象。这些内置对象的构造器是由JavaScript本身所定义的：通过执行new Array()这样的语句返回一个对象，JavaScript内部有一套机制来初始化返回的对象，而不是由用户来指定对象的构造方式。

　　在JavaScript中，函数对象对应的类型是Function，正如数组对象对应的类型是Array，日期对象对应的类型是Date相同，能通过new Function()来创建一个函数对象，也能通过function关键字来创建一个对象。为了便于理解，我们比较函数对象的创建和数组对象的创建。先看数组对象：下面两行代码都是创建一个数组对象myArray：

var myArray=[];
//等价于
var myArray=new Array();
同样，下面的两段代码也都是创建一个函数myFunction：
function myFunction(a,b){
      return a+b;
}
//等价于
var myFunction=new Function("a","b","return a+b");

　　通过和构造数组对象语句的比较，能清晰的看到函数对象本质，前面介绍的函数声明是上述代码的第一种方式，而在解释器内部，当遇见这种语法时，就会自动构造一个Function对象，将函数作为一个内部的对象来存储和运行。从这里也能看到，一个函数对象名称（函数变量）和一个普通变量名称具有同样的规范，都能通过变量名来引用这个变量，不过函数变量名后面能跟上括号和参数列表来进行函数调用。

　　用new Function()的形式来创建一个函数不常见，因为一个函数体通常会有多条语句，如果将他们以一个字符串的形式作为参数传递，代码的可读性差。下面介绍一下其使用语法：

var funcName=new Function(p1,p2,...,pn,body);

　　参数的类型都是字符串，p1到pn表示所创建函数的参数名称列表，body表示所创建函数的函数体语句，funcName就是所创建函数的名称。能不指定所有参数创建一个空函数，不指定funcName创建一个无名函数，当然那样的函数没有所有意义。

　　需要注意的是，p1到pn是参数名称的列表，即p1不仅能代表一个参数，他也能是个逗号隔开的参数列表，例如下面的定义是等价的：

new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")

　　JavaScript引入Function类型并提供new Function()这样的语法是因为函数对象添加属性和方法就必须借助于Function这个类型。
函数的本质是个内部对象，由JavaScript解释器决定其运行方式。通过上述代码创建的函数，在程式中能使用函数名进行调用。本节开头列出的函数定义问题也得到了解释。注意可直接在函数声明后面加上括号就表示创建完成后即时进行函数调用，例如：

var i=function (a,b){
       return a+b;
}(1,2);
alert(i);

　　这段代码会显示变量i的值等于3。i是表示返回的值，而不是创建的函数，因为括号“(”比等号“=”有更高的优先级。这样的代码可能并不常用，但当用户想在非常长的代码段中进行模块化设计或想避免命名冲突，这是个不错的解决办法。

　　需要注意的是，尽管下面两种创建函数的方法是等价的：

function funcName(){
       //函数体
}
//等价于
var funcName=function(){
       //函数体
}

　　但前面一种方式创建的是有名函数，而后面是创建了一个无名函数，只是让一个变量指向了这个无名函数。在使用上仅有一点差别，就是：对于有名函数，他能出目前调用之后再定义；而对于无名函数，他必须是在调用之前就已定义。例如：

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var func=function(){
       alert(1)
}
//--＞
＜/script＞

　　这段语句将产生func未定义的错误，而：

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
function func(){
      alert(1)
}
//--＞
＜/script＞

　　则能够正确执行，下面的语句也能正确执行：

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var someFunc=function func(){
      alert(1)
}
//--＞
＜/script＞

　　由此可见，尽管JavaScript是一门解释型的语言，但他会在函数调用时，检查整个代码中是否存在相应的函数定义，这个函数名只有是通过function funcName()形式定义的才会有效，而不能是匿名函数。

　　函数对象和其他内部对象的关系

　　除了函数对象，更有非常多内部对象，比如：Object、Array、Date、RegExp、Math、Error。这些名称实际上表示一个类型，能通过new操作符返回一个对象。然而函数对象和其他对象不同，当用typeof得到一个函数对象的类型时，他仍然会返回字符串“function”，而typeof一个数组对象或其他的对象时，他会返回字符串“object”。下面的代码示例了typeof不同类型的情况：

alert(typeof(Function)));
alert(typeof(new Function()));
alert(typeof(Array));
alert(typeof(Object));
alert(typeof(new Array()));
alert(typeof(new Date()));
alert(typeof(new Object()));

　　运行这段代码能发现：前面4条语句都会显示“function”，而后面3条语句则显示“object”，可见new一个function实际上是返回一个函数。这和其他的对象有非常大的不同。其他的类型Array、Object等都会通过new操作符返回一个普通对象。尽管函数本身也是个对象，但他和普通的对象还是有差别的，因为他同时也是对象构造器，也就是说，能new一个函数来返回一个对象，这在前面已介绍。所有typeof返回“function”的对象都是函数对象。也称这样的对象为构造器（constructor），因而，所有的构造器都是对象，但不是所有的对象都是构造器。

　　既然函数本身也是个对象，他们的类型是function，联想到C++、Java等面向对象语言的类定义，能猜测到Function类型的作用所在，那就是能给函数对象本身定义一些方法和属性，借助于函数的prototype对象，能非常方便地修改和扩充Function类型的定义，例如下面扩展了函数类型Function，为其增加了method1方法，作用是弹出对话框显示"function"：

Function.prototype.method1=function(){
      alert("function");
}
function func1(a,b,c){
      return a+b+c;
}
func1.method1();
func1.method1.method1();

　　注意最后一个语句：func1.method1.mehotd1()，他调用了method1这个函数对象的method1方法。虽然看上去有点容易混淆，但仔细观察一下语法还是非常明确的：这是个递归的定义。因为method1本身也是个函数，所以他同样具有函数对象的属性和方法，所有对Function类型的方法扩充都具有这样的递归性质。

　　Function是所有函数对象的基础，而Object则是所有对象（包括函数对象）的基础。在JavaScript中，所有一个对象都是Object的实例，因此，能修改Object这个类型来让所有的对象具有一些通用的属性和方法，修改Object类型是通过prototype来完成的：

Object.prototype.getType=function(){
       return typeof(this);
}
var array1=new Array();
function func1(a,b){
      return a+b;
}
alert(array1.getType());
alert(func1.getType());

　　上面的代码为所有的对象添加了getType方法，作用是返回该对象的类型。两条alert语句分别会显示“object”和“function”。

　　将函数作为参数传递

　　在前面已介绍了函数对象本质，每个函数都被表示为一个特别的对象，能方便的将其赋值给一个变量，再通过这个变量名进行函数调用。作为一个变量，他能以参数的形式传递给另一个函数，这在前面介绍JavaScript事件处理机制中已看到过这样的用法，例如下面的程式将func1作为参数传递给func2：

function func1(theFunc){
      theFunc();
}
function func2(){
      alert("ok");
}
func1(func2);

　　在最后一条语句中，func2作为一个对象传递给了func1的形参theFunc，再由func1内部进行theFunc的调用。事实上，将函数作为参数传递，或是将函数赋值给其他变量是所有事件机制的基础。

　　例如，如果需要在页面载入时进行一些初始化工作，能先定义一个init的初始化函数，再通过window.onload=init;语句将其绑定到页面载入完成的事件。这里的init就是个函数对象，他能加入window的onload事件列表。

　　传递给函数的隐含参数：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。因此，在定义函数的时候，即使不指定参数列表，仍然能通过arguments引用到所获得的参数，这给编程带来了非常大的灵活性。arguments对象的另一个属性是callee，他表示对函数对象本身的引用，这有利于实现无名函数的递归或确保函数的封装性，例如使用递归来计算1到n的自然数之和：

var sum=function(n){
      if(1==n)return 1;
      else return n+sum(n-1);
}
alert(sum(100));

　　其中函数内部包含了对sum自身的调用，然而对于JavaScript来说，函数名仅仅是个变量名，在函数内部调用sum即相当于调用一个全局变量，不能非常好的体现出是调用自身，所以使用arguments.callee属性会是个较好的办法：

var sum=function(n){
      if(1==n)return 1;
      else return n+arguments.callee(n-1);
}
alert(sum(100));

　　callee属性并不是arguments不同于数组对象的惟一特征，下面的代码说明了arguments不是由Array类型创建：

Array.prototype.p1=1;
alert(new Array().p1);
function func(){
       alert(arguments.p1);
}
func();

　　运行代码能发现，第一个alert语句显示为1，即表示数组对象拥有属性p1，而func调用则显示为“undefined”，即p1不是arguments的属性，由此可见，arguments并不是个数组对象。
 

　　函数的apply、call方法和length属性

　　JavaScript为函数对象定义了两个方法：apply和call，他们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数的方式有所差别：

Function.prototype.apply(thisArg,argArray);
Function.prototype.call(thisArg[,arg1[,arg2…]]);

　　从函数原型能看到，第一个参数都被取名为thisArg，即所有函数内部的this指针都会被赋值为thisArg，这就实现了将函数作为另外一个对象的方法运行的目的。两个方法除了thisArg参数，都是为Function对象传递的参数。下面的代码说明了apply和call方法的工作方式：

//定义一个函数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

　　能看出，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);

　　深入认识JavaScript中的this指针

　　this指针是面向对象程式设计中的一项重要概念，他表示当前运行的对象。在实现对象的方法时，能使用this指针来获得该对象自身的引用。

　　和其他面向对象的语言不同，JavaScript中的this指针是个动态的变量，一个方法内的this指针并不是始终指向定义该方法的对象的，在上一节讲函数的apply和call方法时已有过这样的例子。为了方便理解，再来看下面的例子：

＜script language="JavaScript" 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指针指向参数所指定的对象，从而达到将一个对象的方法作为另一个对象的方法运行。

　　每个对象集合的元素（即属性或方法）也是个独立的部分，全局函数和作为一个对象方法定义的函数之间没有所有差别，因为能把全局函数和变量看作为window对象的方法和属性。也能使用new操作符来操作一个对象的方法来返回一个对象，这样一个对象的方法也就能定义为类的形式，其中的this指针则会指向新创建的对象。在后面能看到，这时对象名能起到一个命名空间的作用，这是使用JavaScript进行面向对象程式设计的一个技巧。例如：

var namespace1=new Object();
namespace1.class1=function(){
     //初始化对象的代码
}
var obj1=new namespace1.class1();

　　这里就能把namespace1看成一个命名空间。

　　由于对象属性（方法）的动态变化特性，一个对象的两个属性（方法）之间的互相引用，必须要通过this指针，而其他语言中，this关键字是能省略的。如上面的例子中：

obj1.getP=function(){
      alert(this.p); //表面上this指针指向的是obj1
}

　　这里的this关键字是不可省略的，即不能写成alert(p)的形式。这将使得getP函数去引用上下文环境中的p变量，而不是obj1的属性。