js函数表达式

创建函数

// 函数声明
function sayName(name){
  alert(name);
}
// 函数表达式
var sayName = function(name){
  alert(name);
}

递归(不建议递归～)

function factorial(num){
  if(num <= 1){
    return 1;
  }
  return num * factorial(num-1);
}
// 下面这个将无法正常运行
var another = factorial;
factorial = null;
alert(another(4));//错误
// 原因是：another函数内，调用factorial，但是factorial已经==null了

// 优化方案一：arguments.callee;//函数的属性
function factorial(num){
  if(num <= 1){
    return 1;
  }
  return num * arguments.callee(num-1);
}

//优化方案二:函数表达式
var factorial = (function f(num){
 if(num <= 1){
    return 1;
  }
  return num * f(num-1);
} );

闭包（和匿名函数很像）

闭包的含义：闭包说白了就是函数的嵌套，内层的函数可以使用外层函数的所有变量，即使外层函数已经执行完毕

function createFunction(){
  var result = function (num1,num2){
      return num1>num2;
  }
return result;
}

// 应用
function createFunctions(){
  var result = new Array();
  for (var i = 0;i <10;i++){
    result[i] = function(){
      return i;
    }
  }
return result;
}
// 函数本意返回函数数组，每个函数都应返回自己的索引值，但实际都是返回10
// 原因是首先在匿名函数（ function(){ alert(i); }）内部查找是否定义了 i，结果是没有定义；因此它会向上查找，查找结果是已经定义了，并且i的值是10（循环后的i值）；所以，最终每次返回的都是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;
}

匿名函数

匿名函数最大的用途是创建闭包（这是JavaScript语言的特性之一），并且还可以构建命名空间，以减少全局变量的使用。

// 匿名函数的最大的用途
var oEvent = {};
(function(){ 
    var addEvent = function(){ /*代码的实现省略了*/ };
    function removeEvent(){}

    oEvent.addEvent = addEvent;
    oEvent.removeEvent = removeEvent;
})();
// 在这段代码中函数addEvent和removeEvent都是局部变量，但我们可以通过全局变量oEvent使用它，这就大大减少了全局变量的使用

// 匿名函数的小技巧
var outer = null;

(function(){
    var one = 1;
    function inner (){
        one += 1;
        alert(one);
    }
    outer = inner;
})();

outer();    //2
outer();    //3
outer();    //4
// 这段代码中的变量one是一个局部变量（因为它被定义在一个函数之内），因此外部是不可以访问的。但是这里我们创建了inner函数，inner函数是可以访问变量one的；又将全局变量outer引用了inner，所以三次调用outer会弹出递增的结果。

// this
var name = "the window";
var object = {
  name:"my object",
  getNameFunction:function (){
     return function(){
        return this.name;
     };
  }
}
alert(object. getNameFunction()());//the window
// that 的使用
var name = "the window";
var object = {
  name:"my object",
  getNameFunction:function (){
    var that = this;
     return function(){
        return that.name;
     };
  }
}
alert(object. getNameFunction()());//my object

// this 可能意外改变，下面这个例子
var name = "the window";
var object = {
  name : "the object",
  getName:function (){
    return this.name;
  }
};
object.getName();//the object
(object.getName)();//the object
(object.getName = object.getName)();//the window
// 第三个赋值表达式的值是函数本身，因此this的值不能得到维持～

内存泄漏

// 若闭包作用链中存在html元素，导致该元素无法销毁，内存泄漏
function assignHandler(){
  var element = document.getElementById("some");
  element.onClick = function(){
    alert(element.id);
  }
// 循环引用，assignHandler函数包含onClick 函数的引用，匿名函数又保存着assignHandler的活动对象引用，导致循环引用
}
// 解决方案
function assignHandler(){
  var element = document.getElementById("some");
  var id =  element.id;
  element.onClick = function(){
    alert(id);
  }
element = null;
// dom对象使用后记得消除引用，防止内存泄漏

模仿块级作用域（js中没有块级作用域）

var someFunction = function(){
 // 块级作用域
};
someFunction();
// 语法
(function(){
 // 块级作用域
})()

私有变量

function Container(param) {
     this.member = param;
    var secret = 3;
    var self = this;
}
// 这个构造器有三个私有实例变量：param, secret, 和 self。它们被附加到了对象上，但它们无法从外部访问，同时它们也无法被这个对象的公共方法所访问。他们只对私有成员可见。私有方法则是构造器内部的函数。

// 特权方法
function Person(name){
  this.getName = function(){
    return name;
  }
  this.setName = function(value){
    this.name = value;
  }
}
// 这俩方法都能访问内部私有变量，也可以在构造函数外使用

静态私有变量

// 通过在私有域中定义私有变量和私有函数
(function(){
  // 私有变量和私有函数
  var privateVariable = 10;
  function privateFunction(){
    return false;
  }
  // 构造函数
  Myobject = function(){
  };
  //  公有/特权方法
  Myobject.prototype.publicMethod = function (){
      return  privateFunction();
  };
})();
// 注意 Myobject没用var修饰，代表全局变量，严格模式下将无法正常运行

模块模式(包含 单利模式)

// js 以字面量创建单利对象的
var singleton = {
  name:value,
  method:function(){
    // 方法代码
  }
}
// 模块模式通过为单利添加私有变量和特权方法能够使其得到增强

增强的模块模式