es6有闭包。在es6中，在一个函数内部创建另一个函数，把内嵌的函数称为闭包，它可以访问外部函数的局部变量；简单来说，闭包指有权访问另一个函数作用域中变量的函数。闭包的主要作用：延伸了变量的作用范围。由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。
本教程操作环境：windows7系统、ECMAScript 6版、Dell G3电脑。
一、变量作用域
变量根据作用域的不同分为两种：全局变量和局部变量。
函数内部可以使用全局变量。
函数外部不可以使用局部变量。
当函数执行完毕，本作用域内的局部变量会销毁。
二、什么是闭包？
在es6中，闭包（closure）指有权访问另一个函数作用域中变量的函数。简单理解：一个作用域可以访问另外一个函数内部的局部变量。
闭包：在一个函数内部创建另一个函数，把内嵌的函数称为闭包，它可以访问外部函数的局部变量
// fun 这个函数作用域 访问了另外一个函数 fn 里面的局部变量 num
function fn(){
let num = 10
function fun(){
console.log(num)
}
fun()
}
fn() //10闭包的主要作用：延伸了变量的作用范围。
// fn 外面的作用域可以访问fn 内部的局部变量
function fn(){
let num = 10
// 方法一: 先定义再返回函数
function fun(){
console.log(num)
}
return fun //返回 fun函数
}
let f = fn()
f() //10 // fn 外面的作用域可以访问fn 内部的局部变量
function fn(){
let num = 10
// 方法二: 直接返回函数
return function(){
console.log(num)
}
}
let f = fn()
f() //10三、闭包的使用场景
（1）用来返回值
//以闭包的形式将 name 返回
function fun(){
let name = 'woniu'
//定义闭包
return function f1(){
return name
}
}
let ft = fun() //因为fun函数的返回值是f1函数，ft实质是一个函数
let na = ft() //调用ft函数，实际调用的就是f1函数
console.log(na); //woniu（2）函数赋值：在函数内部定义函数表达式
var f2
function fn(){
let name = '曹操'
f2 = function(){ //闭包，将外部函数的name变量作为闭包的返回值
return name
}
}
fn() //必须先调用fn函数，否则f2不是一个函数
console.log(f2()); //曹操（3）把闭包作为函数的参数
function fn(){
let name = '蜗牛学苑'
//定义闭包
return function callback(){
return name
}
}
let f1 = fn() //将fn函数的返回值callback赋给f1
function f2(temp){
console.log(temp()) //输出temp函数的返回值,实际调用了闭包callback
}
//调用f2函数：将f1作为实参传递给temp
f2(f1)（4）立即执行函数中使用闭包
//立即执行函数
(function(){
let name = '蜗牛学苑'
let f1 = function(){
return name
}
fn2(f1) //调用fn2函数，将闭包f1作为实参传递给fn2函数
})()
function fn2(temp){ //temp是一个形参，接收f1
console.log(temp()); //对temp的调用，实际调用的是闭包f1
}（5）循环赋值
(function(){
for (let i = 1; i <= 10; i++) {
(
function(j){
setTimeout(function(){
console.log(j);
},j*1000)
}
)(i)
}
})()（6）将闭包封装到对象中
用于 inference.sh 的 JavaScript/TypeScript SDK，可运行 AI 应用、构建代理、集成 150+ 模型。包名：@inferencesh/sdk（npm install），完整 TypeScript 支持。
function fun(){
let name = '蜗牛学苑'
setName = function(na){ //setName是闭包，用来设置外部函数的变量值
name = na
}
getName = function(){ //getName是闭包，用来返回外部函数的变量值
return name
}
//外部fun函数的返回值，将闭包封装到对象中返回
return {
setUserName:setName,
getUserName:getName
}
}
let obj =fun() //将fun函数返回值（对象）赋给obj
console.log('用户名：',obj.getUserName()) //蜗牛学苑
obj.setUserName('石油学苑')
console.log('用户名：',obj.getUserName()) //石油学苑（7）通过闭包实现迭代
let arr = ['aa','bb','cc']
function fn(temp){ //外部函数的返回值是闭包
let i = 0
//定义闭包：迭代获取数组元素并返回
return function(){
return temp[i++] || '数组已经遍历结束'
}
}
let f1 = fn(arr)
console.log(f1()) //aa
console.log(f1()) //bb
console.log(f1()) //cc
console.log(f1()) //数组已经遍历结束(8)、首次区分（相同的参数，函数不会重复执行）
var fn = (function(){
var arr = [] //用来缓存的数组
return function(val){
if(arr.indexOf(val) == -1){ //缓存中没有则表示需要执行
arr.push(val) //将参数push到缓存数组中
console.log('函数被执行了',arr); //这里写想要执行的函数
} else {
console.log('此次函数不需要执行');
}
console.log('函数调用完打印一下，方便查看缓存的数组：',arr);
}
})()
fn(10)
fn(10)
fn(1000)
fn(20)
fn(1000)注意
（1）搞清除谁是闭包函数
（2）分清楚闭包的返回值、外部函数的返回值
四、闭包总结
闭包是什么：闭包是一个函数（一个作用域可以访问另外一个函数的局部变量）。
闭包的作用是什么：延伸变量的作用范围。
没有产生闭包，因为并没有局部变量，所以访问到的是全局变量
The Window
let name = 'The Window'
let object = {
name: 'My Object',
getNameFunc(){
return function(){
return this.name
}
}
}
let f = object.getNameFunc()
console.log(f()) //The Window产生了闭包：因为 this 在函数内部被赋值给了 that，指向的是 object 这个对象。
let name = 'The Window'
let object = {
name: 'My Object',
getNameFunc(){
let that = this
return function(){
return that.name
}
}
}
let f = object.getNameFunc()
console.log(f()) //My Object使用闭包的注意点
1）由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
2）闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
【推荐学习：javascript视频教程】
