js闭包【前端开发必备】

先从闭包特点解释,应该更好理解.闭包的两个特点：

1、作为一个函数变量的一个引用 - 当函数返回时，其处于激活状态。

2、一个闭包就是当一个函数返回时，一个没有释放资源的栈区。

其实上面两点可以合成一点,就是闭包函数返回时,该函数内部变量处于激活状态,函数所在栈区依然保留.

我们所熟知的主流语言,像C,java等,在函数内部只要执行了return,函数就会返回结果,然后内存中删除该函数所在的区域.生命周期也就停止了.一般的js函数也是这样.

但是有闭包特性的js函数有点特殊.

就例子来说:function a(){

var i=0;

function b(){ alert(++i); }

 return b;

}

var c = a();

c();

这是个标准的闭包.在函数a中定义了函数b,a又return了b的值.这些可以先不管.

var c = a();

c();

这两句执行很重要.

在var c = a();这行里,执行了a函数,那么肯定a经过了return.按照主流语言的函数特性,现在c的值就是a的返回值.第二行c()的执行实际执行的就是b函数.最后不管执行的是谁,会弹出一个值为0的窗口,到此为止,所有的生命周期按理论来说就算全部结束了.

可是,如果我们再多执行一行.var c = a();c();c();第一次弹出0，第二次执行却弹出了1.也就是说,第一次c()后,a中的i依然保留.自然a在内存的栈区依然保留.a是return过了,但是,a及内部值却依然存在,这就是闭包.

好了,总结下,

1，闭包外层是个函数.

2，闭包内部都有函数

.3，闭包会return内部函数.

4，闭包返回的函数内部不能有return.(因为这样就真的结束了)

5，执行闭包后,闭包内部变量会存在,而闭包内部函数的内部变量不会存在.

闭包的应用场景(呵呵,复制的参考资料)

1、保护函数内的变量安全。以最开始的例子为例，函数a中i只有函数b才能访问，而无法通过其他途径访问到，因此保护了i的安全性。

2、在内存中维持一个变量。依然如前例，由于闭包，函数a中i的一直存在于内存中，因此每次执行c()，都会给i自加1。

根据参考资料的应用场景,我们会自然的想到java或是c++的类.虽然JS没有类的概念,但是有了类的相似执行结果.另外,还有一种格式颇受争议:(function(a,b))(a,b);如果你使用过jquery,并且观察过他的代码,你就会很奇怪他的写法,网上有人也把这种格式叫做闭包.

-------------------------------------------------------------------------------------------------------------------------

例1。 <script type="text/javascript">
function sayHello2(name) {
var text = 'Hello ' + name; // local variable
var sayAlert = function() { alert(text); }
return sayAlert;
}
var sy = sayHello2('never-online');
sy();
</script>
作为一个Javascript程序员，应该明白上面的代码就是一个函数的引用。如果你还不明白或者不清楚的话，请先了解一些基本的知识，我这里不再叙述。

上面的代码为什么是一个闭包？
因为sayHello2函数里有一个内嵌匿名函数
sayAlert = function(){ alert(text); }
在Javascript里。如果你创建了一个内嵌函数（如上例），也就是创建了一个闭包。

在C 或者其它的主流语言中，当一个函数返回后，所有的局部变量将不可访问，因为它们所在的栈已经被消毁。但在Javascript里，如果你声明了一个内嵌函 数，局部变量将在函数返回后依然可访问。比如上例中的变量sy，就是引用内嵌函数中的匿名函数function(){ alert(text); }，可以把上例改成这样：<script type="text/javascript">
function sayHello2(name) {
var text = 'Hello ' + name; // local variable
var sayAlert = function() { alert(text); }
return sayAlert;
}
var sy = sayHello2('never-online');
alert(sy.toString());
</script>这里也就与闭包的第二个特点相吻合。

例2。<script type="text/javascript">
function say667() {
// Local variable that ends up within closure
var num = 666;
var sayAlert = function() { alert(num); }
num++;
return sayAlert;
}

var sy = say667();
sy();
alert(sy.toString());
</script>
上面的代码中，匿名变量function() { alert(num); }中的num，并不是被拷贝，而是继续引用外函数定义的局部变量??num中的值，直到外函数say667()返回。

例3。<script type="text/javascript">
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; }
}

</script>
<button οnclick="setupSomeGlobals()">生成 - setupSomeGlobals()</button>
<button οnclick="gAlertNumber()">输出值 - gAlertNumber()</button>
<button οnclick="gIncreaseNumber()">增加 - gIncreaseNumber()</button>
<button οnclick="gSetNumber(5)">赋值5 - gSetNumber(5)</button>
上例中，gAlertNumber, gIncreaseNumber, gSetNumber都是同一个闭包的引用，setupSomeGlobals()，因为他们声明都是通过同一个全局调用??setupSomeGlobals()。
你可以通过“生成”，“增加”，“赋值”，“输出值”这三个按扭来查看输出结果。如果你点击“生成”按钮，将创建一个新闭包。也就会重写gAlertNumber(), gIncreaseNumber(), gSetNumber(5)这三个函数。

如果理解以上代码后，看下面的例子：

例4。<script type="text/javascript">
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();
</script>
运行结果:
item 3 is undefined
item 3 is undefined
item 3 is undefined

代码result.push( function() {alert(item + ' ' + list[i])} )，
使result数组添加了三个匿名函数的引用。这句代码也可以写成
var p = function() {alert(item + ' ' + list[i])};
result.push(p);

关于为什么会输出三次都是 "item 3 is undefined"

在上面的例子say667()例子中已经解释过了。
匿 名函数function() {alert(item + ' ' + list[i])}中的list[i]并不是经过拷贝，而是对参数list的一个引用。直到函数buildList()返回为止，也就是说，返回最后一个 引用。即遍历完list（注：list的最大下标应该是2）后，经过i++也就变成了3，这也就是为什么是item 3，而list[3]本身是没有初始化的，自然也就是undefined了。

例5。<script type="text/javascript">
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);
}
}
var closure1 = newClosure(40, {someVar:' never-online'})
var closure2 = newClosure(99, {someVar:' BlueDestiny'})
closure1(4)
closure2(3)
</script>

在这最后一个例子中，展示如何声明两个不同的闭包。