在这篇文章中，将会介绍一些function的知识，比如function的使用，变量作用域，匿名函数，回调，自执行函数，内部函数，闭包等相关的知识。其中，闭包的知识会在下一次的文章中介绍。
function的使用
javascript是非常灵活的语言。
比如，定义一个函数
?
function sum(a, b) {
var c = a + b;
return c;
}
?
执行sum(1,2)得到3，
执行sum(1)，由于javascript允许少传参数，所以后面一个参数将被设成undefined，所以得到NaN，
执行sum(1,2,3,4,5,6)，javascript也允许多传参数，后面多余的参数将会被忽略，所以得到3。
可见javascript是非常灵活的。
另外，当创建一个function的时候，javascript会自动创建一个叫做arguments的数组，里面包含了所以参数。
?
function args() {
return arguments;
}
?
args(); // [] args( 1, 2, 3, 4, true, 'ninja'); // [1, 2, 3, 4, true, "ninja"]?
?
作用域
在javascript中，变量不是被定义在一个代码块里面的，而是在一个function里面。也就是说，如果在function内部定义一个临时变量，那么在function外面是没法访问到的，然而将变量定义在一个if或者for代码块里面，在代码块外面是可以访问得到的。如果在任何function外部定义变量，那么这个变量就是全局变量，全局变量在任何function里面都是可以访问得到的。下面我们来看一下例子：
?
var global = 1;
function f() {
var local = 2;
global++;
return global;
}
f(); // 2
local; // ReferenceError: local is not defined
?
我们看到，在函数f里面成功访问到了global变量。但是在函数外部，访问不到local变量。再看下面的代码：
?
function f() {
if(true){
var local = 0;
}
local++;
return local;
}
f(); // 1
?
可以发现，local变量并不是出了if块就不能被访问了。在代码块外面同样可以访问。由此看来javascript的变量的作用域是函数级的，不是块级的。
另外，值得一提的是，如果在函数中定义变量时，没用用var来声明，那么这个变量会被定义为全局变量。看下面代码：
function f() {
local=2;
}
local; // ReferenceError: local is not defined
f(); // undefined
local; // 2
?
可以发现，在f()函数被调用前，local变量是不存在的，调用后，local可以在函数外部被访问，成为全局变量。
因此，在我们平时开发中，应该尽量用var来定义变量。避免定义全局变量，可以想象多个人在一个脚本中对一个全局变量操作，是相当难控制的。
在一个函数中，定义了一个和外部全局变量同名的变量是，在函数内，局部变量的优先级高于全局变量。为了直观一点，看下面的代码：
?
var a = 123;
function f() {
alert(a);
var a = 1;
alert(a);
}
f();
?
这段代码并不像你所想的一样，第一个alert弹出123，第二个alert弹出1，而是分别弹出undefined和1。这正是因为在函数内部，局部变量的优先级高于全局变量，所以，局部变量会覆盖所有同名的全局变量。
函数也是数据
在javascript中，函数也是数据，定义函数可以有以下两种方式：
?
function f(){
return 1;
}
var f = function(){
return 1;
}
?
用typeof来验证f，返回"function"，因此，函数是一种特殊的数据。同时，函数还可以像普通变量一样赋值给其他变量，甚至删除掉。
?
var sum = function(a, b) {
return a + b;
}
var add = sum;
delete sum; // true
typeof sum; // "undefined"
typeof add; // "function"
add(1,2); // 3
匿名函数
在javascript中，function可以在不给予函数名的情况下使用。比如：
?
function(a){
return a;
}
但是这样的函数并没有什么用处，要让他能被调用，可以有下面两种方法：
- 把一个匿名函数当做函数B的参数，然后在函数B中做一些有用的操作。
- 可以定义一个匿名函数并且立即执行他。
下面我们针对这两种方法来进行更细一些的了解。
?
回调函数
由于函数可以像其他数据一样被赋给变量，能被定义、删除、复制，所以，同样的也可以被当做参数传递到另一个函数。
下面的例子是向函数中传入两个函数，执行以后返回两个函数返回值的和。
?
function invoke_and_add(a, b){
return a() + b();
}
?
然后定义两个简单的函数
?
function one() {
return 1;
}
function two() {
return 2;
}
?
现在我们把这两个函数传入到invoke_and_add方法中。
?
invoke_and_add(one, two); // 3
?
执行以后，返回3。
另外，同样可以传入两个匿名函数来试试。
?
invoke_and_add(function(){return 1;}, function(){return 2;}); // 3
?
像这样类似的，传入一个函数A到另一个函数B中，在B中执行A，A就叫做回调函数。如果A是匿名函数的话，可以叫做匿名回调函数。
再看一个例子：
?
/**
*把a，b，c 3个数乘以2以后，返回积的数组
*/
function multiplyByTwo(a, b, c) {
var i, ar = [];
for(i = 0; i < 3; i++) {
ar[i] = arguments[i] * 2;
}
return ar;
}
function addOne(a) {
return a + 1;
}
?测试：
?
multiplyByTwo(1, 2, 3); // [2, 4, 6] addOne(100); // 101
?
现在，我们需要传入3个数字，然后先对着3个数字乘以2，再在积上加1。我们通常会想到，先调用multiplyByTwo方法，在循环结果，把各个结果传入addOne方法，最后得到我们想要的。这样做，必然会需要循环数组两次来算出结果。
有了回调函数，我们就可以这样做，稍微把multiplyByTwo方法修改一下。
?
function multiplyByTwo(a, b, c, callback) {
var i, ar = [];
for(i = 0; i < 3; i++) {
ar[i] = callback(arguments[i] * 2);
}
return ar;
}
?
多加入一个callback参数，在方法中一次性就得到最终需要的结果。
?
multiplyByTwo(1, 2, 3, addOne); // [3, 5, 7]
?
由此，可见使用callback函数，不仅可以减少我们的代码量，还可以优化性能。
自执行函数
下面我们来看匿名函数的另一种用法―自执行函数。它可以在函数被定义以后马上被执行。
?
(
function(){
alert('boo');
}
)()
?
?将匿名函数放在一对小括号里面，后面在跟一对小括号就可以。后面的小括号内可以传入函数所需要的实参。比如：
?
(
function(name){
alert('Hello ' + name + '!');
}
)('dude')
?
使用自执行函数的好处在于，你可以不必为函数创建全局变量。但是缺点是，自执行函数只能执行一次，除非你把它放在循环里或者其他方法里。因此，自执行函数适合用在一次性执行的地方或者初始化的地方。
?
内部函数(私有函数)
在函数中，还可以定义另一个函数。比如：
?
function a(param) {
function b(theinput) {
return theinput * 2;
};
return 'The result is ' + b(param);
};
?
这样的函数b就叫做内部函数。执行一下。
?
a(8); // "The result is 16" b(2); // b is not defined
?
可以发现，函数b提示没有定义。因此也叫私有函数。
定义内部函数有什么好处呢？
首先，可以保持外部命名空间比较干净，减小了命名冲突的几率。
第二，由于它的私有性，你可以把不想提供给外部的函数私有化。
?
函数中返回函数
在之前，我们知道，函数总是返回一个值，如果函数没有显式的返回一个值，那么他将返回undefined。同样，函数也可以返回一个函数。
?
function a() {
alert('A!');
return function(){
alert('B!');
};
}
?
在上面这个例子中，函数a完成了自己的工作(弹出“A!”)，之后又返回一个做别的工作(弹出“B!”)的函数。你可以把返回的这个函数重新赋值给一个变量。然后把这个变量像其他普通函数一样调用。
?
var newFunc = a(); // 弹出"A!" newFunc(); //弹出"B!"
?
如果你不想重新定义一个变量就立即执行return的函数的话，你可以在外部函数后面加一对小括号来立即执行他。
?
a()(); // 先弹出"A!"，再弹出"B!"
重写本函数
由于函数可以返回函数，因此你可以用新的函数来替换掉旧的函数。
?
a = a(); // 弹出"A!" a = a(); // 弹出"B!"
?
你可以发现，第一次重写弹出A!，第二次重写弹出B!。
当一个函数有一些一次性的初始化工作要做时，这就很有用了。在函数被调用时，为了避开重复做一些不必要的事，可以在第一次调用完函数后重写他自己。
在上面的例子中，我们从外部把函数重写了。但是我们也可以在内部重写他。
?
function a() {
alert('A!');
a = function(){
alert('B!');
};
}
?
在第一次执行a()的时候，会弹出A!，我们可以把它看做是一次性初始化工作。
在这之后，每次执行a()，都会弹出B!
?
至此，函数方面的知识暂时介绍到这了。下一次的文章中会介绍函数的另一个重要特性----闭包的有关知识。