深入浅析JavaScript中的Function类型

function sum(a , b ){
return a+b;
}

var sum = function(){
return a+b; 
}; //注意分号
　//两种方式的区别：
　//解释器会率先读取函数声明，并使其在执行之前可以访问，而使用表达式则必须等到解析器执行到它所在的代码行，才会真正被解释执行（变量声明提前，而值留在原地）
alert (sum (10 ,10));
function sum(a ,b){
　　return a+b;
}
//↑上面的代码会正常执行，因为在代码执行前，解析器通过函数声明提升，读取并将函数声明添加到执行环境中，放到代码树的顶部
alert (typeof sum);
alert(sum(10 , 10));
var sum = function (a ,b){
　　return a+b;
}
//↑报错，原因在于函数位于一个初始化语句中，不是一个函数声明，不会被提前，而只会把var sum提前，用typeof操作符显示sum是undefined，所以报错

function sum(a , b ){
return a+b;
}
console.log(sum(2 ,3)); //5
var anotherSum = sum; //变量anotherSum也指向了同一个函数对象
console.log(anotherSum(4 , 5)); //9
sum = null; //sum变量不再保存函数对象的指针了
console.log(anotherSum(1 , 3)); //anotherSum这个变量仍能调用

function add(a){
return a+3 ;
}
function add(a){
return a+5;
}
var result = add(3); //8
//两个函数同名了，结果只能是后一个函数覆盖前一个，所以不能重载

function foo (){
var a =arguments.callee; 
return a.toString();
}
foo();
/*
返回结果：
　　"function sum(){
　　var a =arguments.callee; 
　　return a.toString();
　　}"
也就是说，一个函数内部，arguments.callee指的就是这个函数本身。这个函数在递归调用时有点用，有许多缺陷，在ES5严格模式被移除
*/

function inner(){
console.log(inner.caller);
} 
function outer(){
inner();
}
outer(); 
//function outer(){
inner();
}

function add(a ,b ,c){
return a+b+c;
}
add.length; //3

function sum(a , b){
return a+b;
}
function callSum(a , b){
return sum.apply(this , arguments);
}//第二个参数是一个类数组对象arguments
function callSum1(a , b){
return sum.apply(this, [a , b]);
} //第二个参数是一个数组
console.log(callSum(2 , 3)); //5 
console.log(callSum1(3 ,5)); //8

var color = 'red';
var obj = {
color :'blue' 
}
function foo(){
console.log(this.color); 
}
foo(); //'red'
foo.call(this);//'red'
foo.call(obj); //'blue'
//最后一次调用foo()函数的执行环境变了，其中的this指向了obj对象，所以是'blue'

var x = 9; 
var module = {
x: 81,
getX: function() { return this.x; }
};
module.getX(); // 81
var retrieveX = module.getX;
retrieveX(); // 9, 因为在这种情况下, "this" 指向全局变量
var boundGetX = retrieveX.bind(module);//把retrieveX()函数中的this永远与module绑定，再调用这个函数永远都是在module对象中运行
boundGetX(); // 81