闭包:由许多被引用变量和包含这些变量的环境组成。
产生闭包的条件:
1.函数嵌套
2.内部函数引用外部函数的变量或者函数
3.在外部执行外部函数
在执行外部函数的时候,嵌套的内部函数也引用了嵌套的外部函数的变量或者函数,就会产生闭包。
闭包特点
1.一般函数执行完后,函数内部声明的局部变量都会被销毁。而存在于闭包中的局部变量不会被立马销毁,存在一段生命周期。
2.外部函数可以对函数内部局部变量进行操作
3.闭包容易造成内存泄露,比如产生了某个闭包,在函数执行完毕后,局部变量没有释放,会一直占用内存?,容易造成内存泄露。所以,不能滥用闭包。当我们使用完闭包后,应该将引用变量置为null。
闭包的常用方式
1.将函数作为另一个函数的返回值
function test(){
let a = 10
return function(){
a++
console.log(a)
}
}
let t = test()
t()
t()
//释放内存
t = null
上述代码中,test()执行后返回的是函数t,函数t第一次执行的时候,变量a自增,所以a等于11,这毫无疑问。那函数t第二次执行的时候,不应该还是先找到外部的变量a,再进行自增,所以a还是等于11吗?
这里就需要知道,第二次执行函数t的时候,找到的还是test()内部定义的变量a,只不过这个a的值在经过上一次函数t的调用后发生了变化,所以第二次执行函数t的时候,变量a的值是基于上一次的结果进行变化的。有人也许有其它疑惑,函数执行完毕后。函数内部的局部变量不是会被销毁吗?但是,变量被销毁的前提是这个变量不再被引用了,而上面的例子中,变量a在第二次执行函数t的时候还被引用,所以不会被销毁。
2.将函数作为另一个函数的实参
let test3 = (fn) =>{
return fn()
}
let test1 = () =>{
let a = 10
let test2 = () =>{
return a
}
return test3(test2)
}
console.log(test1())
3.利用闭包定义一个包含很多私有变量、私有函数的公有函数,这个公有函数可以被当做单独的一个js模块使用,模块的内部封装了许多的私有属性和方法,模块只向外暴露一个私有属性、方法的对象,在其它地方引入此模块,就可以根据暴露的对象使用模块中的私有属性和方法。
var counter = (function(){
var privateCounter = 0; //私有变量
function change(val){
privateCounter += val;
return privateCounter
}
return { //变量属性和方法
increment:function(num){
return change(num);
},
decrement:function(num){
return change(num);
},
value:function(){
return privateCounter;
}
};
})();
console.log(counter.value());//0
console.log(counter.increment(5));//5
console.log(counter.increment(3));//8
4.给setTimeout()传参
function fn(a){
console.log(a*2)
}
setTimeout(fn(2),1000)
5.假设有这样一个功能:点击某个按钮,显示这是第几个按钮。
<button class='btn'>按钮1</button>
<button class='btn'>按钮2</button>
<button class='btn'>按钮3</button>
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
btns[i].onclick = function(){
console.log(`这是第${i+1}个按钮`)
}
}
//这种写法导致不管点击的是哪个按钮,得到的结果都是第3个按钮
//因为每次执行点击事件,都会去查找i,而这里的i属于全局变量,并且在for循环结束后,i的值就已经确定是3了。所以每次去找这个i,都是已经为3的i。
//早期修改方法
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
btn[i].index = i //给每个按钮添加一个属性记录i值,这个i属于每个按钮本身
btns[i].onclick = function(){
console.log(`这是第${this.index+1}个按钮`)
}
}
//也可以利用闭包
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
(function(j){
btns[j].onclick = function(){
console.log(`这是第${j+1}个按钮`)
}
})(i)
}
//也可以利用let关键字
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(let i = 0; i < length;i++){
btns[i].onclick = function(){
console.log(`这是第${i+1}个按钮`)
}
}
闭包面试题
function fnnn(){
var arr = [];
for(var i = 0;i < 5;i ++){
arr[i] = function(){
return i;
}
}
return arr;
}
var list = fnnn();
for(var i = 0,len = list.length;i < len ; i ++){
console.log(list[i]());//5 5 5 5 5
}
<body>
<button id="add">加1</button>
<span id="span">10</span>
</body>
<script>
//第一种写法
var a = 10;
add.onclick = function (){
a++;
span.innerHTML = a;
}
//第二种写法
add.onclick = function (){
var a = 10;
a++;
span.innerHTML = a;
}
</script>
上面第一种写法,每次点击按钮都会加1,而第二种写法每次得到的结果都是一样的。这里我们就需要了解一个知识点:局部变量在没有被其它对象引用的时候就会被销毁掉。第一种写法下,定义的a是全局变量,全局变量只有在页面关闭或者浏览器关闭的时候才会被销毁,所以,每次点击,都是在原来的基础上加1,不断递增。而对于第二种写法,每次点击,执行完回调函数后,局部变量就被销毁,再次点击的时候,重新定义了变量a,所以每次点击的结果都一样。
把上面的例子引用到闭包来,在闭包中,嵌套的内部函数使用外部函数的局部变量,就类似于上面举的例子。外部函数执行完,但是局部变量不会销毁,如果创建的闭包很多,那么就有许多变量不会被销毁,一直保存在内存中,很有可能造成内存泄露
。
学习闭包的过程中,发现这样一种情况:还不知道什么原因。
function fun(num){
console.log(num)
}
let obj = {
fix:function(num){
return fun(num)
}
}
obj.fix(5)
//但是下面这种写法就不行
let obj1 = {
fix:function(num){
return function(num){//为什么返回匿名函数就没有输出结果呢?
console.log(num)
}
}
}
obj1.fix(5)//无结果