查阅书籍：JavaScript权威指南
函数声明与函数表达式
sum(10,10)//20
function sum(n1,n1){
return n1+n2;
}
sum(10,10)//报错
var sum=function(){
return n1+n2;
}
用函数声明定义的函数,函数可以在函数声明之前调用,而用函数表达式定义的函数只能在声明之后调用。
根本原因是
解析器会率先读取函数声明，将其加入执行环境中，
函数表达式，必须等到解析器执行到它所在的代码行，才会被真正的执行
在权威指南是这么写到的
ECMAScript规范中表示，函数声明语句可以出现在全局代码中，或者内嵌在其他函数中，但是不能出现在循环、条件判、或者try/finally以及with语句中。函数定义表达式可以出现在javascript代码的任何地方。
匿名函数
JavaScript函数可以是匿名的。这意味着你可以从函数声明中省略函数名。但是，函数必须存储在变量中。
var addNumbers = function (x, y) { return x + y; }
上述语法被也被称为函数表达式。
立即执行函数表达式
(function() {
// Your code here
}());
这其中定义的任何变量或函数不能被这个范围以外的任何代码改变。
这是一个在代码中创建局部范围的很好方法。它们可以帮助你保护变量和函数，以避免被应用程序的其他部分更改或覆盖。
嵌套函数
function hyotense(a,b){
function square(x){return x*x};
return Math.sqrt(square(a)+square(b));
}
他的特别之处在于他的变量作用域规则，他们可以访问嵌套他们的函数的参数和变量，这里要说一下作用域链
作用域链
作用域链中的下一个变量对象来自包含（外部）环境，而在下一个变量对象则来自下一个包含环境，一直延续到全局执行环境，全局执行环境的变量对象始终是作用域的最后一个对象
函数调用
（1）作为函数
（2）作为方法
（3）作为构造函数
（4）通过它们的call和apply间接调用
作为函数
就是我们通常看到的最简单的调用
function square(x){return x*x};
square(10);
作为方法
var calcuator={
a:1,
b:2,
add:function(){
this.result=this.a+this.b;
}
}
calcuator.add();
calcuator.result; =>3
方法链
当方法返回的是一个对象的时候，这个对象还可以调用它的方法，jQuery 就是这样。
需要注意的是
作为构造函数
函数可以充当构造器的角色，并且可以使用构造函数来创建新的对象。这是JavaScript面向对象的特点之一。使用构造函数的好处是，你将能够通过预定义的属性和方法，创造尽可能多的对象。
function Programmer(name, company, expertise) {
this.name = name;
this.company = company;
this.expertise = expertise;
this.writeCode = function() {
console.log("Writing some public static thing..");
}
this.makeSkypeCall = function() {
console.log("Making skype call..");
}
this.doSalsa = function() {
console.log("I'm a programmer, I can only do Gangnam style..");
}
this.canWriteJavaScript = function() {
return expertise === "JavaScript";
}
}
始终使用new关键字来从构造器创建新的对象。
var jsProgrammer = Programmer("Douglas Crockford", "Yahoo", "JavaScript")
最终将添加所有属性和方法到全局的window对象，原因是，除非明确指定，否则“this”指向全局的window对象。使用new 设置“this”上下文到被创建的当前对象。
间接调用
javascript函数也是对象，函数对象也可以包括方法，其中call()和apply也可以间接调用函数
call和apply都可以改变this的指向
call第二个参数是散列分布
apply以数组的形式传第二个参数
ClassA.call(this,name,age);改变this值
ClassA.apply(this,[name,age]);
ClassA.apply(this,arguments);arguments是一个数组，里面放的是所有传过来的实参
call可以用做继承
function Parent(age){
this.name=['mike','jack','smith'];
this.age=age;
}
function Child(age){
Parent.call(this,age);//把this指向Parent,同时还可以传递参数
}
var test=new Child(21);
console.log(test.age);//21
console.log(test.name);
test.name.push('bill');
console.log(test.name);//mike,jack,smith,bill
ES5还定义了一个方法：bind()，它会创建一个函数的实例，其this值会被绑定到传给bind()函数的值。如
window.color='red';
var o={color:'blue'};
function sayColor(){
console.log(this.color);
}
var objectSaycolor=sayColor.bind(o);
//var objectSaycolor=sayColor.bind();
objectSaycolor();//blue
在这里sayColor()调用bind()并传入对象o,创建了objectSayColor()函数。objectSayColor()函数的this值等于o,因此即使是在全局作用域中调用这个函数，也会看到blue。
实参和形参
当调用函数时，传入的实参比函数声明时指定的形参要少的话，剩下的形参都会设为undefine
那么当调用函数时，传入的实参超过函数声明时指定的形参的话，没有办法直接获得其他形参，参数对象解决了这个问题，那么什么是参数对象呢？
参数对象arguments
标识符arguments是指向实参对象的引用，实参对象是一个类数组对象，这样通过数组下标就可以访问传入函数的实参值
我们可以通过arguments[0]取到传入实参的第一位，和真正的数组一样arguments也有length属性，用来表示传入实参的个数。
arguments有一个重要的用处，让函数可以操作任意数量的实参。下面的这个例子就利用arguments实现任意数量的数字去比较大小。
要注意的是，实参对象并不是真正的数组，他不能够使用数组的方法
实参对象的callee和caller属性
callee是标准的，指向当前正在执行的函数， 一般用于递归函数 可以实现低耦合 防止将函数赋值为其他函数，
caller是非标准的，调用当前正在执行的函数的函数
function factorial(num){
if(num <= 1){
return 1;
}else{
return num*arguments.callee(num-1);
}
}
闭包
用一句可以概括一下闭包：外部函数内会定义一个内部函数 2.内部函数调用外部函数的变量 3.外部函数的变量不会回收
函数对象可以可以通过作用域链相互关联起来，函数内部的变量可以保存在函数内作用域。
从技术角度讲，javascript的函数都是闭包，定义大多数函数时的作用域链在调用函数时依然有效。
var scope="global scope";
function checkscope(){
var scope="local scope"
function f(){return scope};
retunr f();
}
checkscope();
这个例子很明显，会输出local scope，将f函数执行后的结果返回。
做一点改变
var scope="global scope";
function checkscope(){
var scope="local scope"
function f(){return scope};
retunr f;
}
checkscope()();
答案是“local scope”
书上的答案是这样的
注意：函数定义时的作用域在函数执行时依然有效
很多人会认为外部函数中定义的局部变量在函数返回后就不存在了，
其实原理是这样的，
当执行流进入一个函数时，函数的环境（变量，函数）会被推进一个环境栈（我习惯叫运行栈），在栈里面存的是对函数的一个引用，真正的函数是放在堆上面的，当函数执行之后，正常的情况会将环境中的变量弹出来，断开函数的引用，但是由于在外面checkscope变量指向了function(){return scope}这个函数,而在函数里面还需要scope这个变量，因此在这种情况下，编译器会将scope捕捉（我理解就是复制了一份引用），这样我们就可以取到scope，这就是在内部函数里面调用外部函数的变量，外部函数的变量不会被释放的原因。
闭包有什么用处呢？
看下面这个例子
for(var i=0;i<10;i++){
ali[i].onclick=function(){
alert(i);
}
}
想想这个例子，当我们点击不同的li时，会如我们所愿的输出当前li的下标么？答案当然是不，点击不同的li时都会输出10，因为for循环瞬间执行完毕的时候，每次i出了函数，都将i从栈里面弹出去，在重新给i赋值，i最后变成了10，这个时候无论点击什么，都会alert 10，闭包就可以解决这个问题，将变量保存下来
for(var i=0;i<10;i++){
(function(idx){
ali[i].onclick=function(){
alert(i);
}
})(i);
}
看一下这个闭包，通过这种方式就可以保存下来每一个下标，每个点击事件都将当前的i保留下来了，原理和上面那个例子是一样的。
