一、函数的声明方式
1、普通的函数声明
function box(num1,num2){ return num1+num2; }
alert(box(1,2));
2、使用变量初始化函数
var box=function(num1,num2){ return num1+num2; } alert(box(1,2));
3、使用Function构造函数
var box=new Function("num1","num2","return num1+num2"); alert(box(1,2));
第三种不推荐，因为这种语法导致解析两次代码(第一次解析常规ECMAScript代码，第二次解析传入构造函数中的字符串)
，从而影响性能，但我们可以通过这种语法来理解，函数是对象，函数名是指针的概念
二、作为值的函数，函数可以传递函数
1、函数的返回值可以来传递
function box(sum,num){ return sum+num; } function sum(num){ return num+10; } var result=box(sum(10),10); //这里传递的是函数的返回值，和普通变量没区别 alert(result);
2、把函数本身作为参数来传递，而不是作为结果
function box(sum,num){ return sum(num); } function sum(num){ return num+10; } var result=box(sum,10) //这里sum是函数，当做参数传递到另外一个函数里，而不是返回值 alert(result)
三、函数内部属性
1、arguments类数组对象，包含了传入函数中所有参数，这个对象还有一个callee的属性，该属性是一个指针，指向拥有这个arguments对象的函数
function box(num){ if(num<=1){ return 1; }else{ return num*box(num-1); //3*2*1 } } alert(box(3));
以上是一个阶乘或者是递归，box调用了自己，如果很多自我调用修改也许会麻烦，所以用到arguments.callee来调用自己
function box(num){ if(num<=1){ return 1; }else{ return num*arguments.callee(num-1); //arguments.callee 调用自身，实现递归 } } alert(box(3));
2、this
四、函数的属性和方法
1、length 函数希望接收参数个数
function box(a,b){ return a+b; } alert(box.length) //2
2、prototype 原型，下面有两个方法 apply()和call()，每个函数都包含这两个非继承而来的方法，这两个方法的用途都在特定的作用域中调用函数，实际上等于设置函数体内this对象的值
function box(a,b){ return a+b; } function sum(a,b){ return box.apply(this,[a,b]); //this表示window作用域,[]表示传递的参数 } function sum1(a,b){ return box.apply(this,arguments); //这个可以当数组传递 } alert(box(10,10));alert(sum(10,10)); alert(sum1(10,10));
call()和apply()方法相同，他们的区别在于接收参数方式不同。对于call()方法，第一个参数也是作用域，没有变化，变化只是其余的参数都是直接传递给函数的
function box(a,b){ return a+b; } function sum(a,b){ return box.call(this,a,b); //this表示window作用域,[]表示传递的参数 } alert(box(10,10)); alert(sum(10,10));
以上是对象冒充，其实call()和apply()最大的作用是修改作用域
var color="hongse"; var box={ color:"lanse" } function sayColor(){ alert(this.color); } sayColor.call(window); sayColor.call(this); //this就是window sayColor.call(box);
----------------------------------------------进阶----------------------------------------------
1、当函数作为对象的方法时，this指向该对象
2、作为普通函数调用时（当函数不作为对象属性调用时，也就是普通函数方式，此时的this总是指向全局对象，在JavaScript中，这个全局对象是Window对象
例子1：
var myObject={ name:"sven", getName:function(){ return this.name; } } console.log(myObject.getName()) //sven var myObject1=myObject.getName; window.name="lee"; console.log(myObject1()) //lee
例子2：
var div=document.getElementById('div1'); div1.onclick=function(){ console.log(this); //这里的this是dom节点 function callback(){ console.log(this); //这里的this是window，因为是作为普通函数调用的 } callback(); }
-------修改方法，callback.call(this)
3、使用new调用构造器时，如果构造器显示返回一个object类型的对象，那么这次结果最终会返回这个对象，而不是之前期待的this
例1
var myObject=function(){ this.name="sven"; return { name : "anne" //返回object类型 } } var obj=new myObject(); console.log(obj.name) //输出 anne
4、Function.prototype.call 或 Function.prototype.apply 调用
跟普通函数相比，用Function.prototype.call 或 Function.prototype.apply可以动态的改变传入函数的this
例1
var obj1={ name:"sven", getName:function(){ return this.name; } } var obj2={ name:"annr" } console.log(obj1.getName()); //输出 sven console.log(obj1.getName.call(obj2)); //输出 anne -------------call是function方法-----------
5、call和apply
apply接收两个参数，第一个参数指定了函数体内this对象的指向，第二个是个集合（可以是数组，也可以是类数组）
var func=function(a,b,c){ console.log([a,b,c]); } func.apply(null,[1,2,3]) //[1,2,3]
其实和之前学的是一样的，调用函数的时候，都省略了call或apply，比如调用 a()，其实是a.apply()的缩写，只不过，第一个参数是null，函数体内的this会指向默认的宿主对象，在浏览器中则是window
var func=function(a,b,c){ console.log(this===window); } func.apply(null,[1,2,3])
***借用其他对象的方法
有时候我们使用call或者apply的目的不在于指定this指向，而是另有用途,比如借用其他对象的方法，传入null代替某个具体的对象
Math.max.apply(null,[1,2,5]) //5
借用Array.prototype对象上的方法，往arguments中添加一个新的元素，通常会借用Array.prototye.push方法
(function(){ Array.prototype.push.call(arguments,3) console.log(arguments) })(1,2) //[1,2,3] 把任意对象传入Array.prototype.push var a={}; Array.prototype.push.call(a,"frist"); a[0]; //frish a.length; //1
想把arguments转成真正的数组的时候，可以借用Array.prototype.slice方法，想截去arguments列表的头一个元素的时候，可以借用Array.prototype.shift方法
(function(){ Array.prototype.slice.call(arguments) console.log(arguments) })(1,2) //[1,2] (function(){ Array.prototype.shift.call(arguments) console.log(arguments) })(1,2) //[2]