例子2：多个函数绑定同一个闭包，因为他们定义在同一个函数内。

　　function setupSomeGlobals() {

　　// Local variable that ends up within closure

　　var num = 666;

　　// Store some references to functions as global variables

　　gAlertNumber = function() { alert(num); }

　　gIncreaseNumber = function() { num++; }

　　gSetNumber = function(x) { num = x; }

　　}

　　setupSomeGolbals(); // 为三个全局变量赋值

　　gAlertNumber(); //666

　　gIncreaseNumber();

　　gAlertNumber(); // 667

　　gSetNumber(12);//

　　gAlertNumber();//12

　　例子3：当在一个循环中赋值函数时，这些函数将绑定同样的闭包

　　function buildList(list) {

　　var result = [];

　　for (var i = 0; i < list.length; i++) {

　　var item = 'item' + list[i];

　　result.push( function() {alert(item + ' ' + list[i])} );

　　}

　　return result;

　　}

　　function testList() {

　　var fnlist = buildList([1,2,3]);

　　// using j only to help prevent confusion - could use i

　　for (var j = 0; j < fnlist.length; j++) {

　　fnlist[j]();

　　}

　　}

　　testList的执行结果是弹出item3 undefined窗口三次，因为这三个函数绑定了同一个闭包，而且item的值为最后计算的结果，但是当i跳出循环时i值为4，所以list[4]的结果为undefined.

　　例子4：外部函数所有局部变量都在闭包内，即使这个变量声明在内部函数定义之后。

　　function sayAlice() {

　　var sayAlert = function() { alert(alice); }

　　// Local variable that ends up within closure

　　var alice = 'Hello Alice';

　　return sayAlert;

　　}

　　var helloAlice=sayAlice();

　　helloAlice();

　　执行结果是弹出”Hello Alice”的窗口。即使局部变量声明在函数sayAlert之后，局部变量仍然可以被访问到。

　　例子5：每次函数调用的时候创建一个新的闭包

　　function newClosure(someNum, someRef) {

　　// Local variables that end up within closure

　　var num = someNum;

　　var anArray = [1,2,3];

　　var ref = someRef;

　　return function(x) {

　　num += x;

　　anArray.push(num);

　　alert('num: ' + num +

　　'\nanArray ' + anArray.toString() +

　　'\nref.someVar ' + ref.someVar);

　　}

　　}

　　closure1=newClosure(40,{someVar:'closure 1'});

　　closure2=newClosure(1000,{someVar:'closure 2'});

　　closure1(5); // num:45 anArray[1,2,3,45] ref:'someVar closure1'