深入认识JS中的函数：
1.概述,认识函数对象
2.函数对象和其他内部对象的关系
3.将函数作为参数传递
4.传递给函数的隐含参数：arguments
5.函数的apply,call方法和length属性
6.深入认识JS中的this指针
1.概述,认识函数对象
JS中的函数不同于其他的语言，每个函数都是作为一个对象被维护和运行的。通过函数对象的性质，可以将一个函数赋值给一个变量或者将函数作为参数传递。
用法：
function Func1(...){......};
var Func2 = function(...){......};
var Func3 = function Func4(...){......};
var Func5 = new Function();
**函数对象！！
可以用function关键字定义一个函数，并为每个函数指定一个函数名，通过函数名来进行调用。在JS解释执行时，函数都是被维护为一个对象，这就是函数对象（function object）。
函数对象与其他用户所定义的对象有着本质的区别，这一类对象称之为内部对象，例如Date，Array，String 都属于内部对象。这些内置对象的构造器是由JS本身所定位的：通过执行 new Array() 这样的语句返回一个对象，JS内部有一套机制来初始化返回的对象，而不是由用户来指定对象的构造方式。
在JS中，函数对象对应的类型是Function，（数组对应Array，日期对应Date），可以通过 new Function() 来创建一个函数对象，也可以通过 function 关键字来创建一个对象。
var myArray = []; var myArray = new Array(); function myFunction1(a,b){ return a+b; }; var myFunction = new Function('a','b','return a+b');
以上代码，通过和构造数组对象语句的比较，可以清楚的看到函数对象本质。第一种方式，在解释器内部，当遇到这种语法时，就会自动构造一个Function对象，将函数作为一个内部的对象来存储和运行。（一个函数对象名称（函数变量）和一个普通变量名称具有同样的规范，都可以通过变量名来引用这个变量，但是函数变量名后面可以跟上括号和参数列表来进行函数的调用。var myFunction = new Function("a,b","return a+b")，这个方式可读性较差）。
** var funcName = new Function(P1,P2,P3...Pn,body) 参数的类型都是字符串，P1到Pn表示所创建函数的参数名称列表，body表示所创建函数的函数体语句。
**注意，P1到Pn是参数名称的列表，即P1不仅能代表一个参数，它也可以是一个逗号隔开的参数列表。
**JS导入Function类型并提供 new Function() 这样的语法是因为函数对象添加属性和方法就必须借助于Function这个类型。
**函数的本质是一个内部对象！由JS解释器决定其运行方式。**
**注意：直接在函数声明后面加上括号就表示创建完成后立即进行函数调用。返回一个number类型
var myfunc2= function(a,b){ return a+b; }(100,200);//优先级决定的，‘(’优先级大于‘=’,所以myfunc2是一个变量，而不是一个函数 alert(typeof(myfunc2));//number alert(myfunc2); alert(myfunc2(10,20));//报错，myfunc2不是一个函数！
**但是不直接调用，返回的是一个function类型
var Myfunc2=function(a,b){ return a+b; } alert(typeof(Myfunc2));//function alert(Myfunc2(1,2));
**注意有名函数和无名函数！
**区别：对于有名函数，它可以出现在调用之后再定义；而对于无名函数，必须在调用之前定义。
**因为JS是一门解释型语言，但它会在函数调用时，检查整个代码中是否存在相应的函数定义。只有通过function FuncName(...){...} 才有效，而不是无名函数。
function Myfunc1(a,b){//有名函数 return a+b; } alert(Myfunc2(1,2));//报错 var Myfunc2=function(a,b){//无名函数 return a+b; } alert(typeof(Myfunc2));//function
2.函数对象和其他内部对象的联系
除了函数对象，还有很多内部对象，比如：Object，Array，Date.....这些都表示一个类型，可以通过 new 操作符返回一个对象，然而函数对象和其他对象不同，当用typeof得到一个函数对象的类型时，它仍然会返回字符串“function”,而typeof一个数组对象或其他的对象时，它会返回字符串“Object”。
//function alert(typeof(Function)); alert(typeof(new Function())); alert(typeof(Array)); alert(typeof(Object)); //object alert(typeof(new Array())); alert(typeof(new Date())); alert(typeof(new Object())); if(typeof(tt)=="function"){//判断是function类型在运行，通常的做法 arg(); }
**new 一个Function，实际上是返回一个函数。这于其他的对象有很大的不同。其他的类型Array，Object等都会通过 new 操作符返回一个普通对象（Object）。
**尽管函数本身也是一个对象，但它与普通的对象还是有区别的，因为它同时也是对象构造器，也就是说，可以new 一个函数来返回一个对象，所有typeof返回‘function’的对象都是函数对象，也叫构造器（constructor）。所有的构造器都是对象，但不是所有的对象都是构造器。
**Function类型的作用，就是可以给函数对象本身定义一些方法和属性，借助于函数的prototype对象，可以方便地修改和扩充Function类型的定义。
**Function是所有函数对象的基础，而Object则是所有对象（包括函数对象）的基础。在JS中，任何一个对象都是Object的实例。因此，可以修改Object这个类型来让所有的对象具有一些通用的属性和方法，修改Object类型是通过prototype来完成的。
Function.prototype.Methods=function(){ alert('function'); } function tt(){ alert('tt'); } tt.Methods(); tt.Methods.Methods();//递归的定义。Methods本身也是一个函数，所以它同样具有函数对象的属性和方法，
//所有对Function类型的方法扩充都具有这样的递归性质。 Object.prototype.getType=function(){ return typeof(this); } var array1=new Array(); function func1(a,b){ return a+b; } alert(array1.getType()); alert(func1.getType());
3.将函数作为参数传递
函数对象的本质：就是一个内部对象！Function类型的对象，类型还是Function。
**每个函数都被表示为一个特殊的对象，可以方便地将其赋值一个变量，再通过这个变量名进行函数调用。作为一个变量，它可以以参数的形式传递给另一个函数。
function func1(thefunc){ if(typeof(thefunc)=='function'){// thefunc(); }else{ alert(typeof(thefunc)); } } function func2(){ return '123'; } function func3(a,b){ var result =a+b; alert(result); } function func4(a,b,c){ var result =a+b+c; alert(a+b+c); } func1(func2());//执行结果传递过去 func1(func2);//func2作为一个对象传递给func1的形参thefunc，再由func1内部进行thefunc的调用。 //事实上，将函数作为参数传递，或者是将函数赋值给其他变量是所有事件机制的基础。 //将func3传递给func1; //var t=new func3(1,2); //func1(func3); var t1 = new func3(1,2); alert(typeof(t1));
4.传递给参数的隐含参数 arguments
当进行函数调用时，除了指定的参数外，还创建了一个隐含的对象--arguments，arguments是一个类似数组但不是数组的对象，说它类似是因为它具有数组一样的访问性质，可以用arguments[index]这样的语法取值，拥有数组长度属性length。arguments对象存储的是实际传递给函数的参数，而不局限于函数声明所定义的参数列表，例如：
function Myfunc(a,b){ alert(a); alert(b); for (var i=0;i<arguments.length;i++) { alert(arguments[i]); } } Myfunc(1,2)//显示：1,2,1,2 Myfunc(1,2,3)//显示：1,2,1,2,3
**因此，在定义函数的时候，即使不指定参数列表，仍然可以通过arguments引用到所获得的参数，这给编程带来了很大的灵活性。
**arguments对象的另一个属性callee，它表示对函数对象本身的引用，这有利于实现无名函数的递归或者保证函数的封装性。
var sum =function(n){ if(1==n){ return 1; }else{ return n+sum(n-1);//递归的调用 } } alert(sum(100)); //arguments.callee 表示对函数对象本身的引用，有利于实现无名参数的递归或者保证函数的封装性 var sum2 =function(n){ if(1==n){ return 1; }else{ return n+arguments.callee(n-1);//arguments.callee，递归的调用 } } alert(sum2(100));
**callee属性并不是arguments不同于数组对象的唯一特征，以下代码：
Array.prototype.p1 = 1;//给所以数组对象添加属性p1，初始化值为1. alert(new Array().p1);//1 function func(){ alert(arguments.p1); } func();//undefined 说明p1不是arguments的属性
**arguments的length的模拟实现方法的重载
//arguments可以实现方法的重载! function myFunc(){ var result=0; if(arguments.length==2){ result =arguments[0]+arguments[1]; }else if(arguments.length==3){ result=arguments[0]+arguments[1]+arguments[2]; } /* for(var i=0;i<arguments.length;i++){ result+=arguments[i]; } */ return result; } alert(myFunc(1,2,3));//6 alert(myFunc(1,2));//3
5.函数的apply,call方法和length属性
JS对函数对象定义了两个方法:apply和call,它们的作用都是将函数绑定到另外一个对象上去运行,两者仅在定义参数的方式有所区别:
Function.prototype.apply(thisArg,argArray);
Function.prototype.call(thisArg,"arg1","arg2"...)
从函数原型可以看到,第一个参数都被取名为thisArg,即所有函数内部的this指针都会被赋值为thisArg,这就实现了将函数作为另外一个对象的方法运行的目的.
//apply call function func1(){ this.p="func1-"; this.A=function(arg){ alert(this.p+arg+'<func1>'); }; }; function func2(){ this.p="func2-"; this.B=function(arg){ alert(this.p+arg+"<func2>"); } } var obj1=new func1(); var obj2=new func2(); //obj1.A("byA");//正常调用 //obj2.B("byB");//正常调用 obj1.A.apply(obj2,["byA"]); obj2.B.apply(obj1,["byB"]); obj1.A.call(obj2,"byA"); obj2.B.call(obj1,"byB"); //可以看出,obj1的方法A被绑定到obj2运行后,整个函数A的运行环境就转移到了obj2,即this指针指向了obj2. //同样,obj2的函数B也可以绑定obj1运行,整个函数B的运行环境就转移到了obj1,即this指针指向了obj1.
函数对象的属性length,它表示函数定义时所指定参数的个数,而非调用时实际传递的参数个数
//函数对象的属性length,它表示函数定义时所指定参数的个数,而非调用时实际传递的参数个数 function sum(a,b,c) { return a + b+c; } alert(sum.length);//3 var t1=sum; alert(t1);
6.深入认识JS中的this指正
this指针是面向对象程序设计中的一项重要概念,塔表示当前运行的对象.在实现对象的方法时,可以使用this指针来获得该对象的自身的引用.
和其他语言不同,JS中的this指针是一个动态的变量,一个方法内的this指针并不是始终指向定义该方法的对象的,它可以是动态的!
var obj1=new Object(); var obj2=new Object(); obj1.p=1; obj2.p=2; obj1.getP=function(){ alert(this.p); } obj1.getP();//1 obj2.getP=obj1.getP;//函数对象赋值给函数对象 obj2.getP();//2 //由此可见,getP函数仅定义了一次,在不同的场合运行,显示了不同的运行结果.这是由this指针的变化所决定的. //在obj1的getP方法中,this就指向了obj1对象,而在obj2的getP方法中,this就指向了obj2对象,并通过this指针引用到了两个对象都具有的属性p
**JS中的this指针是一个动态变化的变量,它表面了当前运行该函数的对象.由this指针的性质,也可以更好的理解JS中对象的本质:一个对象就是由一个或多个属性(方法)组成的集合.每个集合元素不是仅能属于一个集合,而是可以动态的属于多个集合.这样,一个方法(集合元素)由谁调用,this指针就指向谁!
**实际上,apply方法和call方法都是通过强制改变this指针的值来实现的,使this指针指向参数所指定的对象,从而达到将一个对象的方法作为另一个对象的方法运行.
命名空间的概念(重要)
/* * 每个对象集合的元素(即属性或方法)也是一个独立的部分,全局函数和作为一个对象方法定义的函数之间没有任何区别. * 因为可以把全局函数和变量看作为window对象的方法和属性.也可以使用new操作符来操作一个对象的方法来返回一个对象, * 这样一个对象的方法也就可以定义为类的形式,其中的this指针则会指向新创建的对象.这时对象名可以起到一个命名空间的 * 作用,这是使用js进行面向对象程序设计的一个技巧. * */ var namespace1 = new Object();//这里就可以把namespace1看成一个命名空间 namespace1.class1 = function() {//namespace1命名空间下面的类class1 //初始化对象代码 } var obj1=new namespace1.class1();//