一、定义函数
在js中，函数也是对象，能赋值给变量，能当作参数，可以设置属性，和调用他拥有的方法。函数的toString（）方法，会返回他完整的函数内容。他有两个定义方法，函数表达式和函数声明。当一个函数作为构造函数时，首字母大写！函数声明在js运行前和变量声明一样被js提到所处作用域的最前面。函数可以定义在另一个函数的内部，也可以当作另一个的函数的return返回值。由于变量声明的hoisting特性，所以在函数中最好都在函数顶部声明有可能用到的所有变量。
函数声明: （[ ]括起来表示可有可无。）
function 函数名称 ( [ 参数 ] ){ 函数体 }
函数表达式：
function [函数名称] ([参数]) { 函数体 }
关于函数表达式，(function ([参数]) { 函数体 }([参数]))表示立即执行。eg：
(function (){
alert("1");
}());
因为在js中函数也是对象，所以可以用构造函数来定义函数。
var f = new Function("x","y","z","return x + y - z;");
f(2,3,9);
Function可以输入任意数量的实参，最后一个字符串表示函数体。
二、函数的调用
第一种就是函数名加括号
FunctionName（），当他作为一个对象方法调用，并且返回自身，然后还可以再接着调用，这是函数的链式调用；
1 var x = {
2 count:1,
3 add:function(){
4 this.count ++;
5 return this;
6 }
7 };
8
9 x.add().add().add();//x.count = 4;
第二种是用new关键字，作为构造函数条用，new FunctionName（）；
第三种是利用call（），apply（）间接调用。他们的第一个参数都是当前函数执行上下文，也就是this,,如果第一个参数是null或者undefined，那么默认this为window。call后面的参数作为函数的实参，而apply后面的实参都放入一个数组中。
function test(x,y,z){
return x + y + z;
}
test.call(null,1,2,3);
test.apply(null,[1,2,3]);
他的调用方式影响他的上下文this。如果就是普通函数调用，this就是window；如果是方法调用，this就是调用这个方法的对象；如果是当作构造函数调用，他会创建一个新对象，那么this就是他创建的这个新对象，如果用call或者apply间接调用，this就是他们的第一个参数。
三、函数传参
JavaScript的函数在传参这点做得很高级，但是不够严谨，太过随意。当传入个数少于函数的形参个数时，剩下的形参都是undefined，为了避免出错，最好用 || 给默认值。
而当传入个数多余形参个数时，也没有关系。虽然没法直接获得未命名值的引用，但是参数对象解决了这个问题。在函数体内，arguments指向实参对象的引用，他是一个类数组对象，从0开始，依次是传入参数的顺序，多余的为undefined。在arguments中有个callee属性，他是指当前正在执行的函数，可以调用的，当然乱用会产生死循环，不断的自己执行自己。
function test(){
console.log(arguments[4]);
console.log(arguments.callee);
return arguments[0] + arguments[1] + arguments[2];
}
test(1,2,3);
var t = test;//函数作为值来使用
t(1,2,3,4);
四、将函数作为命名空间
如果要写一段可复用的js代码，方便以后在其他项目中的使用，那么就应该把他放在一个函数中，因为并不能保证自己定义的变量是否和当前项目的全局变量重名。此时，这个函数名的作用就类似于命名空间，他把全局变量变成了函数的局部变量，并且可以向全局环境中隐藏一些变量。
五、函数作用域及作用域链（Scope Chain）
函数的作用域决定了参数和变量的生命周期，可见性，并且减少了命名冲突，提供了自动内存管理（GC,垃圾回收）。在一个js文件中，包括很多函数，每个函数都有自己的作用域，他们在一起就有了作用域链。内部的一个[[Scope]]属性包含了函数被创建时所处作用域中的对象集合，这个对象就是函数的作用域链。作用域链用来查找变量，需要注意的是，函数里声明变量一定要用var 否则他会变成全局变量的。例如：
1 var window_x = "window";
2 function test(){
3 var parentsArg = arguments;
4 var test_x = "test";
5 function inner(){
6 console.log(test_x);
7 console.log(window_x);
8 return parentsArg[0] + parentsArg[1] + parentsArg[2];
9 }
10 return inner();
11 }
变量的查找
函数inner的作用域链可以看作 window--->test--->inner。例如查找window_x，首先查找inner的作用域是否有该变量，没有就接着作用域链上一级（test）查找，直到该标示符被找到，如果查找到window的全局作用域都没有该标示符，那么就要抛出异常了：xxx is not defined.(goolge chrome)。可以猜到，标示符所处的位置越深，他的查找会越慢，window的全局变量总是最后一个查找的。
作用域链（Scope Chain）的创建：inner为例
1.inner被创建，他的作用域链[[ scope ]]被填充test作用域中的对象集合；test被创建时，[[scope]]被填充了全局作用域的对象集合(window，document…….)。这些[[scope]]中的对象代表此函数的中可访问的数据。
2.inner被执行时，他要建立一个内部对象，称为“运行期上下文”，这个对象定义了函数执行时的环境。函数每次执行都会创建一个新的“运行期上下文”，当函数执行完毕时这个对象会自动销毁。一个运行期上下文有自己的作用域链[[scope]]，scope中包括运行函数的scopeChain中包含的对象（复制过去的）。
3.上一步完成后，一个被称做“激活对象”的新对象就为运行期上下文创建好了。他包含所有可访问的局部变量，命名参数，参数集合等等。然后这个激活对象被推到作用域链的最前端，生命周期和作用域链一样。
此时，inner的作用域链包含了3个对象，inner的激活对象，outer的激活对象，window对象。
六、闭包 closure
闭包在《JavaScript权威指南》中的解释：函数对象可以通过作用域链相互关联起来，函数体内部的变量都可以保存在函数作用域内，这种特性在计算机科学文献中称为“闭包”。通俗点说，一个函数就是一个闭包。
1.闭包的作用
在js中，函数内可以随意访问全局变量，函数外想访问函数内的变量就不可以了（可以用这个特性来模仿类的私有变量）。但是闭包的特性解决了这个问题，他可以在外面访问函数内的局部变量。
1 function outer(){
2 var outer_x = 0;
3
4 function inner(i){
5 i = typeof i == "number" ? i : 0;
6 outer_x += i;
7 console.log("我要把outer_x + " + i + " = " + outer_x);
8 }
9
10
11 return inner;
12
13 }
14
15 var test = outer();
16 test(1);//我要把outer_x + 1 = 1
17 test(2);//我要把outer_x + 2 = 3
18 test(3);//我要把outer_x + 3 = 6
19 test(4);//我要把outer_x + 4 = 10
20
21 function outer1(i){
22 var outer_x = 0;
23 i = typeof i == "number" ? i : 0;
24 outer_x += i;
25 console.log("我要把outer_x + " + i + " = " + outer_x);
26 }
27 var test1 = outer1;
28 test1(1);//我要把outer_x + 1 = 1
29 test1(2);//我要把outer_x + 2 = 2
30 test1(3);//我要把outer_x + 3 = 3
31 test1(4);//我要把outer_x + 4 = 4
在这里例子中，outer返回一个匿名的函数，这个匿名函数可以访问outer的局部变量，并且加一个指定的数字。这样可以通过外部的i来影响outer的局部变量。outer1也实现对局部变量outer_x加一个指定数字。对比一下他们的运行结果，可以发现，在有闭包的函数中，他的变量并没有被垃圾回收机制（GC）回收。那么闭包还可以用来让一些局部变量一直保存在内存中。需要小心内存泄漏。
为什么不会被GC回收？
outer函数返回了inner函数的引用给了test。inner的作用域链包括了inner，outer的激活对象，还有window对象，test在外部引用了inner，这个引用不放手，inner的作用域链就不会被GC回收，又因为inner作用域链包含了outer激活对象，那么处于outer作用域链的局部变量自然也不会被GC回收。
2.同一个作用域中的多个闭包
若同一个作用域链中有多个闭包，他们会共享同一个局部变量。并且关联到闭包的作用域链都是活动的。例如我想在一个函数中创建10个闭包。
function test(){
var arr = [];
for(var i = 0; i < 10; i++){
arr[i] = function(){
return i;
}
}
return arr;
}
var arr = test();
var i = 0;
while(i<10){
console.log( i + ":" + arr[i++]());
}
可以发现返回的arr数组中，每个都是10。为什么？因为当我执行var arr = test（）时，i = 10，所有闭包都会共享这个i。嵌套的函数他不会将作用域内的局部变量复制一份的。arr[i] 的i没有受到影响，是因为这个i属于test的局部变量，并且没有在嵌套函数中。怎么样才能使用闭包达到需要的效果呢？
有2种方法，第一是把变量i变成全局变量，由于这个方法会污染全局变量，并不好。
var i = 0
function test(){
var arr = [];
for(; i < 10; i++){
arr[i] = function(){
return i;
}
}
return arr;
}
第二种方法是让闭包函数立即执行，并且返回当前的值给外部函数的局部变量。
function test(){
var arr = [];
for(var i = 0; i < 10; i++){
arr[i] = (function(){
return i;
})();
}
return arr;
}
var arr = test();
var i = 0;
while(i<10){
console.log( i + ":" + arr[i++]);
}
3.闭包的上下文this
下面的这个例子很清楚，一个函数内嵌套的函数无论在普通函数中，还是在方法中，他的上下文都是window。
var name = "The Window";
var myObject = {
name : "My Object",
getThis : function(){
console.log("方法：" + this.name);//方法：My Object
return function(){
console.log("方法中的闭包：" + this.name); //方法中的闭包：The Window
};
}
};
myObject.getThis()();
function outer(){
var name = "outerName";
function inner(){
//return this.name //The Window
return name; //outerName
}
return inner;
}
console.log("普通函数的闭包：" + outer()());