javascript函数 匿名函数 立即调用

1.函数的返回值：
function add(a, b ) {
return a + b;
}
函数有返回值，当没有显示的定义函数的返回值时，默认返回undefined


2.定义函数时你可以为函数指定的参数。当传递参数值时，如果忘记了给这个参数传递值，javascript会给参数自动赋值undefined。
exp:
function add(a, b) {
return a + b;
}
var result = add(3);//result 的值时NaN
当你传递的参数值的个数超过要接收的参数的个数时，多余的参数值将被忽略掉。
exp:
function add(a, b) {
return a + b;
}
var result = add(3,3,4,5,5,5);//result 的值时6,从4开始到最后一个5的所有参数值均被忽略

3.arguments 参数
当函数被创建时，javasript会自动为函数创建一个arguments这个数组。arguments数组接收函数被调用时接收的参数值。
注释：实际上arguments并不是一个数组，而是一个类似数组的对象.
exp:
function args() {
return args();
}


args();//[]
args(21,24,4325,true,"ninja");//[21,24,4325,true,"ninjia"]

arguments.length返回当函数被调用时接收的参数值的个数
4.变量的作用域
javascript的变量具有函数作用域---这个意味着，如果一个参数在函数内定义，那么他在函数外部是不可见的。
然而，在if和for代码块中定义的参数在这个代码块外部却是可见的。
全局变量--是一个你在任何函数外部定义的变量
局部变量--是一个你在某个函数内部定义的变量
一个函数内部的代码可以访问其局部变量和全局变量

exp:
var global = 1;
function f() {
var local = 2;
global += 1;
return global;
}
>>f();
>>2;
>>f();
>>3;
>>local
local is undefined


需要注意的是,如果你定义一个变量时没有使用var关键字，这个变量会自动变成全局变量。


exp:
>>>function f() {
local = 2;
  }
>>>f();
>>>local;
2


exp2:
>>>var a = 123;
>>>function f() {
alert(a);  //在函数内部，局部变量比全局变量更为重要，局部变量覆盖了全局变量。undefiend,a还未被定义
var a = 1; //a被定义了
alert(a);  //1
}
>>>f();


5.函数也是数据
exp1:
function f() {//-----函数声明
return 1;
}
exp2:
var f = function () {//--函数表达式
return 1;
};
exp2中，函数被赋值给了一个叫做f的变量。




6.匿名函数
你可以这样使用匿名函数：
1.把它传递给别的函数，来做点儿事情
2.立即使用它
exp1:
>>>function invoke_and_add(a, b) {
return a() + b();
  }


>>>function one() {
    return 1;
  }

>>>function two() {
    return 2;
  }
>>>invoke_and_add(one, two);
exp2:
>>>invoke_and_add(function () {return 1;}, function () {return 2});


7. 回调函数：当你把函数A传递给函数B，B执行了函数A的时候，通常我们把函数A叫做回调函数。如果函数A没有名字，那么A就叫做匿名回调函数。
回调函数的优点：
1.你可以调用他们，又不用给他们命名（这个意味着代码中的全局变量更少了）
2.
3.提高了代码的性能


回调函数的例子：
exp1:
>>>function multipleByTwo(a, b, c) {
    var i, ar = [];
for ( i = 0; i < 3; i +=1) {
ar[i] = arguments[i] * 2;
}
return ar;
}
    >>>function addOne(a) {
  return a + 1;
  }




>>>var myarr = [];
>>>myarr = multipleByTwo(10, 20, 30);
>>>for( var i = 0; i < 3; i ++ ) {
myarr[i] = addOne(myarr[i]);
  }
  
>>>myarr;
[21,41,61];
上述代码仍然有有待提升的地方：1.代码中有两次循环。修改multipleByTwo()，使之能够接收一个回调函数，然后在每次循环中调用回调函数。
exp:
>>>function multiplyByTwo(a, b, c, callback) {
  var i, ar = [];
  for(i = 0; i < 3; i += 1) {
  ar[i] = callback(arguments[i] *2);
      }
  return ar;
  }


>>> myarr = multiplyByTwo(1, 2, 3, addOne);
[3,5,7];
再次改进：为了节约全局变量，我们可以用匿名函数来定义addOne这个函数。
exp:
>>>myarr = multiplyByTwo(1, 2, 3, function(a) {return a + 1;});
[3,5,7];


8.自调用函数
前面，我们讨论了把匿名函数作为回调函数的例子。下面是匿名函数的另一个例子：创建一个匿名函数，然后立马调用他。
exp:
>>>(
function () {
alert("hello,cat");
}
  ) ()
代码解读：咋一看，可能觉得上面这段代码的语法看起来很奇怪。这样理解：你仅仅是把一个匿名函数放到了一个()里面，然后在这对括号后面又跟了一对()。第二个括号的作用是，立马执行他！！！第二个括号也用来传递参数，看下面的例子exp2.
exp2:
>>>(
      function (name) {
alert("hello," + name + "!");
  }
  ) ("due")
使用匿名自调用函数的优点是：可以做些事情，但是又不用再去定义一个全局变量.缺点是：你不能再次执行这个匿名函数。
这个就使得匿名自调用函数很适合用于只用一次的函数或者用于初始化的任务。

9.私有函数
记住，函数和其他数值以以一样的，没有啥能够阻止你在一个函数内部再定义一个函数。
exp1:
>>>function a(param) {
  function b(the_input) {
  return the_input * 2;
  }
  return 'The result is : " + b( param);
           }


exp2:
使用函数表达式，也可以这样:
>>>var a = function (param) {
  var b = function (the_input) {
return the_input * 2 ;
}
  return 'The result is : " + b( param);
  };


当你调用函数a的时候，它将自动的调用函数b。既然函数b是局部的，所以在函数a外面是无法访问函数a的。因此，我们说函数a是一个私有函数
>>> a(2);
"The result is : 4"
>>> a(4);
"The result is : 8"
>>>b(2);
b is undefined.
使用私有函数的好处是：
1.保持了全局命名空间的clean（更少的命名冲突）
2.私有性：你只把你的函数暴露给你想要暴露的"外部世界".


10.返回函数的函数
exp:
function a() {
alert("A");
return function () {
alert("B");
};
}


var f = a();//alert("A");
f();//alert("B");
如果你想要立即执行返回的函数：
exp:
a()();
13.重写自己的函数
既然一个函数可以返回一个函数，那么我们可以用一个返回值来重写这个函数
exp:
>>> a = a();
上述代码是在函数a外面来对函数a进行重写，我们可以在函数a内部对函数a进行重写。
function  a() {
alert("A");
a = function () {
alert("B");
};
}


下面这个例子综合了上面的几个技术点：
exp:
var a = function () {
function someSetup () {
var setup = "done";
}


function actualWork () {
alert("worky-worky");
} 
someSetup(); 
return actualWork;
} ();
解释：
1.你定义了一个自调用函数a，注意到a后面的（） 了么
2.在函数a内部有两个私有函数--someSetup，actualWork
3.函数a自调用后，actualWork的引用返回给了函数a，注意到return  actualWork后面没有() 了么？？