函数申明：
function functionName(arg0,arg1,arg2){
//函数体
}
函数表达式：
var functionName=function(arg0,arg1,arg2){
// 函数体
}; //注意 ;
functionName(arg0,arg1,arg2);
递归
function factorial(num){
if(num<=1){
return 1;
}else{
return num*factorial(num-1);
}
}
function factorial(num){
if(num<=1){
return 1;
}else{
return arguments.callee(num-1)*num;
}
}//这种方式在严格模式下会报错
//最佳方法
var factorial = (function f(num){
if(num<=1){
return 1;
}else{
return num*f(num-1);
}
});
闭包
闭包是有权访问另一个函数作用域中的变量函数。
function createComparisonFunction(propertyName){
return function(object1,object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
if(value1<value2){
return -1;
}else{
return 0;
}
};
}
即使函数中的匿名函数被返回了，而且在其他地方被调用了，但它仍然可以访问变量propertyName。这是因为内部函数的作用域链中包含了createComparisonFunction()的作用域.
作用域链
- 当某个函数第一次被调用时，会创建一个 执行环境 及相应的 作用域链，并把作用域链赋值给一个特殊的内部属性(执行环境中的[[Scopr]])。然后，使用this、arguments和其他命名参数的值来初始化函数的 活动对象。外部函数的活动对象始终处于第二位，外部函数的外部函数的活动对象处于第三位.....
function compare(value1, value2){
if(value1 < value2){
return -1;
} else{
return 1;
}
}
执行环境及相应的作用域链
后台的每个 执行环境 都有一个表示变量的对象—— 变量对象。全局环境的变量对象始终存在，而想compare()函数这样的局部环境的变量对象，只有在函数执行的过程中存在(活动对象)。
在创建compare()函数时，会创建一个预先包含全局变量对象的作用域链，这个作用域链保存在内部的[[Scope]]属性中。当调用compare()时，会为函数创建一个执行环境，然后通过复制函数的[[Scope]]属性中的对象构建执行环境的作用域链。此后，又有一个活动对象(变量对象)被创建并被推入执行环境作用域链的前端。
作用域链的前端，始终都是当前执行的代码所在环境的变量对象。如果这个环境是函数，则将其活动对象作为变量对象。 (活动对象就是作用域链上正在被执行和引用的变量对象)
function createComparisonFunction(propertyName){
return function(object1,object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
if(value1<value2){
return -1;
}else{
return 0;
}
};
}
在匿名函数从createComparisonFunction()中被返回后，它的作用域链被初始化为包含createComparisonFunction()函数的 活动对象 和 全局变量对象。这样，匿名函数就可以访问在createComparisonFunction()中定义的所有变量。当createComparisonFunction()函数返回后，其执行环境的作用域链被销毁，但它的活动对象仍然会留在内存中，直到匿名函数被销毁后，createComparisonFunction()的活动对象才会被销毁。
闭包与变量
闭包只能取得包含函数中任何变量的最后一个值。
function createFunction(){
var result = new Array();
for(var i=0; i<10; i++){
result[i] = function(){
return i;
}
}
return result;
}
这个函数会返回一个函数数组，每个函数都返回10。因为每个函数的作用域链中都保存着createFuntion函数的活动对象，并返回了createFunction中变量i的值，由于经过for循环i的值变为了10，所以result中每个函数都只会返回10。
通过创建另一个匿名函数强制让闭包的行为符合预期：
function createFunctions()
{
var result = new Array();
for(var i=0;i<10;i++)
{
result[i] = function(num)
{
return function()
{
return num;
}
}(i);
}
return result;
}
由于函数参数传递是按值传递的，所以就会将变量i的当前值复制给参数num，而在这个匿名函数内部，又创建并返回了一个访问num的闭包。这样一来，result数组中的每函数都有自己num变量的一个副本，因此就可以返回各自不同的数值了。
this对象
var name = "The Window";
var object = {
name : "My Object",
getNameFunc: function(){
return function(){
return this.name;
};
}
};
alert(object.getNameFunc()()); // The Window
//object.getNameFunc()返回的是一个匿名函数，想要调用该匿名函数还需要加一个()
出现这样的现象的原因分析(自己理解):
在创建匿名函数时，会创建一个预先包含全局变量对象的作用域链(包括this，此时this为GLobal对象)，这个作用域链被保存在内部的[[Scope]]属性中。当调用匿名函数时，会为函数创建一个执行环境，然后通过复制函数的[[Scope]]属性中的对象构建起执行环境的作用域链。因此该例中，匿名函数中的this仍然为Global对象。
在javascript中，函数的调用一共有4种方式：
- Function Invocation Pattern
诸如foo()的调用形式被称为Function Invocation Pattern，是函数最直接的使用形式，注意这里的foo是作为单独的变量出现，而不是属性。
在这种模式下，foo函数体中的this永远为Global对象，在浏览器中就是window对象。 - Method Invocation Pattern
诸如foo.bar()的调用形式被称为Method Invocation Pattern，注意其特点是被调用的函数作为一个对象的属性出现，必然会有“.”或者“[]”这样的关键符号。
在这种模式下，bar函数体中的this永远为“.”或“[”前的那个对象，如上例中就一定是foo对象。 - Constructor Pattern
new foo()这种形式的调用被称为Constructor Pattern，其关键字new就很能说明问题，非常容易识别。
在这种模式下，foo函数内部的this永远是new foo()返回的对象。 - Apply Pattern
foo.call(this，Object)和foo.apply(this，Object)的形式被称为Apply Pattern，使用了内置的call和apply函数。
在这种模式下，call和apply的第一个参数就是foo函数体内的this，如果thisObject是null或undefined，那么会变成Global对象。
// 把外部作用域中的this对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象了
var name = "The Window";
var object = {
name : "My Object",
getNameFunc: function(){
var that = this;
return function(){
return that.name;
};
}
};
alert(object.getNameFunc()()); // The Object
模仿块级作用域
(function(){
//这里是块级作用域
}) ();
以上代码定义并立即调用了一个匿名函数。将函数申明包含在一对圆括号中，表示它实际上是一个 函数表达式 。而紧随其后的另一对圆括号会立即调用这个函数。
私有变量
- JavaScript中没有私有成员的概念；所有的对象属性都是公有的。但是有私有变量的概念。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。
- 如果在函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量，利用这点，可以创建用于访问私有变量的公有方法。
/* demo01 */
function MyObject(){
var privateVariable = 10;
function privateFunction(){
return false;
}
this.publicMethod = function(){
privateVariable++;
return privateFunction();
};
}
var object = new MyObject();
object.publicMethod(); //false
如果需要构建多个实例，则需为每个实例创建同样的方法
静态私有变量
(function(){
var privateVariable = 10;
function privateFUncion(){
return false;
}
MyObject = function(){
};
MyObject.prototype.publicMethod = function(){
privateVariable++;
return privateFunction();
}
})
// 使用
var object = new MyObject();
注意 :定义构造函数时，没有使用函数生命，而是使用了函数表达式。函数声明只能创建局部函数。出于同样的原因，在声明MyObject时也没有使用var关键字。** 记住 ** : ** 初始话未经声明的变量，总是会创建一个全局变量 ** 。因此MyObject就成为一个全局变量，能够在私有作用域之外被访问。 ** 静态私有变量 ** privateVariable时被所有实例共享的，它可以任何实例修改(通过publicMethod方法)
模块模式
模块模式通过为单例添加私有变量和特权方法能够使其得到增强
var singleton = function(){
var privateVariable = 10;
function privateFunction(){
return false;
}
// 返回一个对象
return {
publicProperty: true;
publicMethod: function(){
privateVariable++;
return privateFunction();
}
};
}();
singleton.publicProperty;
singleton.publicMethod();
这个模块模式使用了一个返回对象的匿名函数。
增强的模块模式
返回特定类型的对象
var singleton = function(){
var privateVariable = 10;
function privateFunction(){
return false;
}
// 可以返回特定类型的对象
var object = new CustomType();
object.publicProperty = true;
object.publicMethod = function(){
privateVariable++;
return privateFunction();
}
}();
singleton.publicProperty;
singleton.publicMethod();
