2)深入认识JavaScript中的函数

   1)概述
   函数是进行模块化程序设计的基础,编写复杂的Ajax应用程序,必须对函数有更深入的理解.
   JavaScript中的函数不同于其他的语言,每个函数都是作为一个对象被维护和运行的.
   通过函数对象的性质,可以很方便的将一个函数赋值给一个变量或者将函数作为参数传递.
   先看一下函数的使用语法:

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

   这些都是声明函数的正确语法.它们和其他语言中常见的函数或之前介绍的函数定义方式有着很大的区别.
   
   2)认识函数对象
   可以用function关键字定义一个函数,并为每个函数指定一个函数名,通过函数名来进行调用.
   在JavaScript解释执行时,函数都是被维护成一个对象,这就是要介绍的函数对象--Function Object.
   函数对象与其他用户所定义的对象有本质的区别,这一类对象被称为内部对象.例如日期对象(Date),数组对象(Array),字符串对象(String)都属于内部对象.
   内部对象的构造器是由JavaScript本身所定义的:通过执行new Array()这样的语句返回一个对象,JavaScript内部有一套机制来初始化返回的对象,而不是由用户来指定对象的构造方式.
   在JavaScript中,函数对象对应的类型是Function,正如数组对象对应的类型是Array,日期对象是Date一样,可以通过new Function()来创建一个函数对象,也可以通过function关键字来创建一个函数对象.
   为了便于理解,下面比较函数对象的创建和数组对象的创建.如下:

//创建数组对象
var myArray = [];
//等价于   
var myArray = new Array();
//--------------------------//
//创建函数对象
function myFunction(a,b){
    return a + b;
}
//等价于
var myFunction = new Function(
    "a",
    "b",
    "return a + b"
);

   第一个函数声明方式,在解释执行时,由解释器自动构造一个Function对象,将函数作为一个内部的对象来存储和运行.
   从这里也可以看到,一个函数对象名称(函数变量)和一个普通变量名称具有同样的规范,都可以通过变量名来引用这个变量,但是函数变量名后面可以跟上括号和参数列表来进行函数调用.
   用new Function()的形式来创建一个函数不常见,因为一个函数体通常会有多条语句,如果将它们以一个字符串的形式作为参数传递,代码的可读性极差.下面介绍一下其使用语法:
            var functionName = new Functin(p1,p2...pn,body);
   参数的类型都是字符串,p1到pn表示所创建函数的参数名称列表,body表示所创建函数的函数体语句,functionName就是所创建函数的名称.可不指定任何参数创建一个空函数.
   需要注意的是,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){  //这里的i不是函数,而是2+4=6
        return a+b;
    }(2,4);
    alert(i);//i = 6

   需要注意的是,如下两种创建函数的方法是等价的:

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()形式定义的才会有效,而不能是匿名函数.

3)函数对象与其他内部对象的关系
   除了函数对象,还有很多内部对象,比如:Object,Array,Date,RegExp,Math,Error等.
   这些名称事实上表示一个类型,可以通过new操作符来返回对象实例.
   但是函数对象和其他对象不同,当用typeof得到一个函数对象的类型时,它依然返回字符串"function",而typeof一个数组对象或其他的对象时,它会返回字符串"object".如下:

alert(typeof(Function));        //function
alert(typeof(new Function()));  //function
alert(typeof(Array));           //function
alert(typeof(Object));          //function
alert(typeof(new Array()));     //object
alert(typeof(new Date()));      //object
alert(typeof(new Object()));    //object

   运行这段代码可以发现,前4条语句都会显示"function",只有最后3条显示"object",可见new 一个function实际上是返回一个函数.这与其他对象有很大不同.其他的类型Array\Object等都会同new操作符返回一个普通对象.尽管函数本身也是一个对象,但它与普通的对象还是有区别的,因为它同时也是对象构造器,也就是说,可以new一个函数来返回一个对象.(即:Array本身只是一个函数,这个函数返回构造好的对象!)
   所有typeof返回"function"的对象都是函数对象,也称这样的对象为构造器(constructor),因此,所有的构造器都是对象,但不是所有的对象都是构造器.
   既然函数本身也是一个对象,它们的类型是function,联想到C++,JAVA等语言的类定义,可以猜测Function类型的作用所在,那就是可以给函数对象本身定义一些方法和属性,借助于函数的的prototype对象,可以很方便地修改和扩充Function类型的定义,如下,扩展了函数类型Function,为其增加了method1方法,作用是弹出对话框显示"function":

Function.prototype.method1=function(){  //扩展了function的方法
      alert("function");
}
function func1(a,b,c){
      return a+b+c;
}
func1.method1();        //func1是一个函数,由于其基类Function扩展了方法,就可以调用啦.
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;
}
var x = "ss";           //字符串
alert(array1.getType());
alert(func1.getType());
alert(x.getType());

   上面的代码为所有的对象添加了getType方法,作用是返回该对象的类型.

4)将函数作为参数传递
   每个函数都被表示为一个特殊的对象,可以方便地将其赋值给一个变量,再通过这个变量名进行函数调用.作为一个变量,它可以以参数的形式传递给另一个函数,如下:

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

   在最后一条语句中,func2作为一个对象传递给了func1的形参theFunc,再由func1内部进行theFunc的调用.
   事实上,将函数作为参数传递,或者是将函数赋值给其他变量是所有事件机制的基础!
   例如, 如果需要在页面载入时进行一些初始化工作，可以先定义一个init的初始化函数，再通过window.onload=init;语句将其绑定到页面载入完成的事件。这里的init就是一个函数对象，它可以加入window的onload的函数列表,排队调用.

   5)传递给函数的隐含参数:arguments
   当进行函数调用时,除了指定的参数外,还创建一个隐含的对象--arguments.
   arguments是一个类似数组但不是数组的对象,arguments对象存储的是实际传递给函数的参数,而不局限于函数声明所定义的参数列表,例如:

function func(a,b){
     alert(a);
     alert(b);
     
     for(var i=0;i<arguments.length;i++){//arguments包含了所有实际传入的参数.
           alert(arguments[i]);
     }
}
func(1,2,3);

   代码运行时会依次显示:1,2,1,2,3.
   在定义函数时,即使不指定参数列表,仍然可以通过arguments引用得到实际所传的参数,这给编程带来了很大的灵活性.
   arguments的另一个属性是callee,它表示对函数对象本身的引用,这有利于实现无名函数的递归或保证函数的封装性,例如使用递归来计算1到n的自然数之和:

function func(a,b){
     alert(a);
     alert(b);
     
     for(var i=0;i<arguments.length;i++){//arguments包含了所有实际传入的参数.
           alert(arguments[i]);
     }
}
func(1,2,3);

   其中函数内部包含了对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);  //1
function func(){
       alert(arguments.p1); //undefined
}
func();

    运行代码可以发现，第一个alert语句显示为1，即表示数组对象拥有属性p1，而func调用则显示为“undefined”，即p1不是arguments的属性，由此可见，arguments并不是一个数组对象。 
   
   6)函数的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");  
obj2.B("byB");  

//调用的方法是类func1的A,但是调用的对象是obj2,而obj2是func2的对象.
//不出错，是因为func2和func1具有相同的属性p
obj1.A.apply(obj2,["byA"]); //显示func2-byA,其中["byA"]是仅有一个元素的数组
obj2.B.apply(obj1,["byB"]);//

obj1.A.call(obj2,"byA");    //call传递参数的方式比较直观
obj2.B.call(obj1,"byB");

//小结:使用apply和call,需要理解,调用的方法是类的方法,这点不会变;但是调用的对象的this指针指向却改变了.
//如果不同的对象具有同名的属性,那么调用时不会发生任何错误.反之,会出现undefined的字符串.

   可以看到,obj1的方法A被绑定到obj2运行后,整个函数A的运行环境就转移到了obj2,即this指针指向了obj2(说穿了,使用apply和call,就是改变了函数内的this指针的指向!).
   这里,虽然类func2的实例obj2没有A方法,但是通过这样的方式,却变相使obj2具有了A方法,这算是方法共享的一种手段吧,节省了代码量,在func2类中不需要定义了.(感觉JavaScript为了减少代码量,什么事都做的出来 :(.)
   与arguments的length属性不同,函数对象还有一个属性length,它表示函数定义时所指定参数的个数,而非调用时实际传递的参数个数,例如:

function func(a,b){
    if (func.length >= arguments.length){
        alert(a);
        alert(b);
    }else{
        for (i=0; i<arguments.length; i++){
            alert(arguments[i]);
        }
    }
}

func(1,2,3);

   会显示:1,2,3.
   经过内部的判断处理,直接使用多参数的处理流程.

   7)深入认识this指针
   this指针是面向对象程序设计中的一项重要概念,它表示当前运行的对象.在实现对象的方法时,可以使用this指针来获得该对象自身的引用.
   和其他面向对象语言不同,JavaScript中的this指针是一个动态的变量,一个方法内的this指针并不是始终指向定义该方法的对性的,如上节的apply和call方法都可以改变this指针的指向.

var obj1 = new Object();
var obj2 = new Object();

obj1.p = 1;
obj2.p = 2;

obj1.getP = function(){
    alert(this.p);
}
obj1.getP();

obj2.getP = obj1.getP;
obj2.getP();

    从代码的执行结果看，分别弹出对话框显示1和2。由此可见，getP函数仅定义了一次，在不同的场合运行，显示了不同的运行结果，这是有this指针的变化所决定的。在obj1的getP方法中，this就指向了obj1对象，而在obj2的getP方法中，this就指向了obj2对象，并通过this指针引用到了两个对象都具有的属性p 
   由此可见,JavaSctipt的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的属性。