与闭包有关的概念：变量的作用域和变量的生存周期。下面本篇文章就来给大家介绍一下JS中变量的作用域及闭包，有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。



一、变量的作用域

1、变量的作用域指变量有效的范围，与变量定义的位置密切相关，作用域是从空间的角度来描述变量的，也可以理解为变量的可见性。在某个范围内变量是可见的，也就是说，变量是可用的。

2、按照作用域的不同，变量可分为全局变量和局部变量。

●　全局变量：在全局环境中声明的变量

●　局部变量：在函数中声明的变量

●　当函数在执行时，会创建一个封闭的执行期上下文环境，函数内部声明的变量仅可在函数内部使用，外部无法访问，而全局变量则在任何地方都可以使用

3、在函数中使用var关键字显示声明的变量是局部变量；而没有用var关键字，用直接赋值的方式声明的变量是全局变量

var m=8;
function f1(){
    var a1=10;
    console.log(m);  //8
}
function f2(){
    var a2=20;
    console.log(m);  //8
}
f1();
f2();

4、依赖变量作用域实现封装特性

（1）使用ES6提供的let

（2）通过函数来创建作用域：

var myObject=(function(){
    var _name="yian";  //私有变量
    return {
        getName:function(){  //公有方法
            return _name;
        }
    }
})();
console.log(myObject._name);  //undefined
console.log(myObject.getName());  //yian

二、变量的生存周期

1、对于全局变量来说，其生命周期是永久的，除非主动销毁此全局变量；

2、对于在函数内用var关键字声明的局部变量来说，当退出函数时，这些局部变量即失去它们的价值，它们会随着函数调用的结束而被销毁

3、模仿块级作用域

（1）用作块级作用域的匿名函数：将函数声明包含在一对圆括号中，表示它实际上是一个函数表达式，而紧随其后的另一对圆括号会立即调用这个函数。

(function(){
    //这里是块级作用域
})();

在匿名函数中定义的任何变量，都会在执行结束时被销毁

（2）先定义一个函数，然后调用它。定义函数的方式是创建一个匿名函数，并把这个匿名函数赋值给变量；而调用函数的方式是在函数的名称后添加一对圆括号。

var someFunction=function(){
    //这里是块级作用域
};
someFunction();

经典问题：

var nodes=document.getElementsByTagName("div");
for(var i= 0,len=nodes.length;i<len;i++){
    nodes[i].onclick=function(){
        console.log(i);  //无论点击哪个div，最后弹出的结果都是5
    }
}

解释： div节点的onclick事件是被异步触发的，当事件被触发时，for循环早已结束，此时i 已经是5

解决办法：

法一：使用ES6中的let

法二：在闭包的帮助下，把每次循环的i值都封存起来

var nodes=document.getElementsByTagName("div");
for(var i= 0,len=nodes.length;i<len;i++){
    (function(x){
        nodes[i].onclick=function(){
            console.log(x);
        }
    })(i);
}

4、作用：读取函数内部的变量，并将这些变量的值始终保存在内存中

（1）封装变量：闭包可以把一些不需要暴露在全局的变量封装为“私有变量”，私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。

例：mult函数接收number类型的参数，并返回这些参数的乘积、

初始代码：

var cache={ };
var mult=function(){
    var args=Array.prototype.join.call(arguments,",");
    if(cache[args]){
        return cache[args];
    }
    var a=1;
    for(var i=0,len=arguments.length;i<len;i++){
        a=a*arguments[i];
    }
    return cache[args]=a;
};
console.log(mult(1,2,3));  //6
console.log(mult(3,4,5));  //60

使用闭包后：

var mult=(function(){
    var cache={ };  //加入缓存机制，避免相同参数的计算
    var calculate=function(){
        var a=1;
        for(var i= 0,len=arguments.length;i<len;i++){
            a=a*arguments[i];
        }
        return a;
    };
    return function(){
        var args=Array.prototype.join.call(arguments,",");
        if(args in cache){
            return cache[args];
        }
        return cache[args]=calculate.apply(null,arguments);
    }
})();

补充：in判断属性属于对象

var mycar = {make: "Honda", model: "Accord", year: 1998};
if ( "make" in mycar ){  //属性名必须是字符串形式，因为make不是一个变量
    document.write('true');  // 显示true
}
else{
    document.write('false');
}

（2）延续局部变量的寿命

例：使用report数据上报时会丢失30%左右的数据，原因是img时report中的局部变量，当report函数调用结束后，img局部变量随即被销毁

初始代码：

var report=function(src){
    var image=new Image();
    image.src=src;
};

使用闭包后（把img变量用闭包封装起来）：

var report=(function(){
    var imgs=[ ];
    return function(){
        var image=new Image();
        imgs.push(image);
        image.src=src;
    }
})();

5、闭包和面向对象设计

闭包写法：

var extent=function(){
    var value=0;
    return {
        call:function(){
            value++;
            console.log(value);
        }
    }
}
var extent=extent();
extent.call();  //1
extent.call();  //2

面向对象写法一：

var extend={
    value:0,
    call:function(){
        this.value++;
        console.log(this.value);
    }
};
extend.call();  //1
extend.call();  //2

面向对象写法二：

var Extend=function(){
    this.value=0;
};
Extend.prototype.call=function(){
    this.value++;
    console.log(this.value);
};
var extend=new Extend();
extend.call();  //1
extend.call();  //2

6、闭包与内存管理

●　局部变量变量应该在函数退出时被解除引用，但如果局部变量被封闭在闭包形成的环境中，那么局部变量就会一直生存下去，即它会常驻内存。

●　使用闭包的同时比较容易形成循环引用，如果闭包的作用域链中保存着一些DOM节点，这就有可能造成内存泄漏。

●　解决循环引用带来的内存泄漏问题：把循环引用中的变量设为null。（将变量设置为null以为着切断变量与它之前引用的值之间的连接，当垃圾收集器下次运行时，就会删除这些值并回收它们占用的内存）

7、特点：

●　函数嵌套函数；

●　在函数内部可引用外部的参数和变量；

●　参数和变量不会以垃圾回收机制回收。

8、优点：避免全局变量的污染

9、缺点：会常驻内存，增加内存的使用量，使用不当会造成内存泄漏；闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存

10、创建闭包

写法一：

function a() {  
	var b=123;  
	function c(){
    	console.log(b+=1);
    }  
    return c;
}
var d=a();
d();

方式二：

function f1(){
    var num=10;  //函数执行完毕，变量仍然存在
    var f2=function(){
        num++;
        console.log(num);  //11
    };
    return f2;
}
var res=f1();
res();

●　解释：执行f1()后,f1()闭包内部的变量会存在，而闭包内部函数的内部变量不会存在，使得JavaScript的垃圾回收机制不会收回f1()占用的资源，因为f1()中内部函数的执行需要依赖f1()中的变量。

方式三：

function foo(x) {
    var tmp = 3;
    return function f2(y) {
        alert(x + y + (++tmp));  //17
    };
}
var bar = foo(3);  //bar现在是一个闭包
bar(10);

练习题：

function f1(){
   var a=1;
   t=function(){
       a++;
   }
   return function(){
       console.log(a);
   }
}
var b=f1();  //返回值为一个匿名函数
b();  //1
t();
b();  //2

声明变量，若变量名称相同，就近原则：

var name="g";
function out(){
    var name="loc";
    function foo(){
        console.log(name);
    }
    foo();
}
out();  //name=loc

补充知识点：

1、JS中有哪些垃圾回收机制？

（1）引用计数：跟踪记录每个值被使用的次数。

●　当声明一个变量并将一个引用类型赋值给该变量时，该值的引用次数加1；

●　若该变量的值变为另一个，则该值引用次数减1；

●　若该值引用次数为0时，说明变量没有在使用，此值无法访问；

●　因此，可以将它占用的空间回收，垃圾回收机制会在运行时清理引用次数为0 的值所占用的空间。

●　在低版的IE中会发生内存泄漏，很多时候就是因为它采用引用计数得到方式进行垃圾回收（如果两个对象之间形成了循环引用，那么这两个对象都无法被回收）。

（2）标记清除：最常见的垃圾回收方式

●　当变量进入执行环境时，垃圾回收器将其标为“进入环境”，离开时标记为“离开环境”；

●　垃圾回收机制在运行时给存储在内存中的所有变量加上标记；

●　去掉环境中的变量及被环境中变量所引用的变量（闭包）的标记；

●　完成这些后仍存在的标记就是要删除的变量。

2、哪些操作会造成内存泄漏？

●　内存泄漏：指不再拥有或需要任何对象（数据）之后，它们仍然存在于内存中。

●　垃圾回收器定期扫描对象，并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为0（没有其他对象引用过该对象），或对该对象的唯一引用是循环的，那么该对象占用的内存立即被回收。

●　如果setTimeout的第一个参数使用字符串而非函数，会造成内存泄漏。

●　闭包、控制台日志、循环（在两个对象彼此引用且彼此保留时，就会产生一个循环）等会造成内存泄漏。

想要了解更多相关知识，可访问 前端学习网站！！ 

1，从作用域的角度出发：变量可分为全局变量和局部变量，全局变量顾名思义是在任何地方都可以访问的，而局部变量则不然，列如在一个函数中定义一个变量
 ：

function af(){

var b = 10；

}

这个变量b在函数外是访问不了的。

全局变量如何定义呢，可以直接在函数外 var c = 10; 或者是不加"var" 直接就是  c = 10，这种称为隐式申明;或者是加上window : window.c = 10;这里就有个地方要注意了:

如果你在一个函数内使用隐式申明或是加上window，这样的方式去定义一个全局变量，如

function bf(){

d = 11;

}

这时你直接在函数外访问 alert(d)，是访问不了的，会报没有定义的错误，但是如果你先执行函数bf(),在访问变量alert(d)，就可以了。其实这也很容易理解，函数未执行，这个变量就没有被申明，还没有为他分配内存，所以不存在。




2，全局变量和局部变量使用那个比较好：

这个问题其实也是很明显的，函数内的局部变量在函数执行的时候回为其分配内存，当函数执行完之后就会摧毁回收，而全局变量是要在程序执行完才能回收，尽可能的避免使用全局变量，因为它还可能带来其他问题，列如变量覆盖。而局部变量是鼓励使用的(当然不是乱使用)，特别是涉及到要操作dom，或是需要多次去计算的情况下，比如在一个数组循环中，要把数组的值输出:

var ary  = [1,2,3,4,5];  

var leng = ary.length;//先把长度计算出，不要每次都去取数组的长度

for(var i=0; i<leng; i++){

.............

}




3，一些坑

 
 先看看这两段代码的区别，第一段会正常输出11，而第二段就会输出undefined，这是为什么呢

其实这就跟变量的解析有关了，变量的解析开始是会在当前作用域内查找变量，如果没有找到，就会到上一层作用域去找，

但是在第二段代码中，是可以找到这个变量a的，所以它直接输出，但是很遗憾的是，这个变量还没有赋值，也就是等于申明了一个变量，但是没有赋值  就像：var a;  alert(a)  这种情况。

数据的存储类型

一、变量的作用域

变量的作用域是指变量有效性的范围，与变量定义的位置密切相关，作用域是从空间这个角度来描述变量的，按照作用域的不同，变量可分为局部变量和全局变量。

1、局部变量

在函数（或代码块）内部定义的变量，也称为内部变量，局部变量只能在定义它的函数（或代码块）内使用，其他函数均不能使用，局部变量的作用域，限于说明它的代码块内：从说明的地方开始至所在的代码块结束。注意，在同一个作用域内，不允许有同名的变量。

例如：在同一个main()函数中，定义了三个数据类型和变量名均相同的局部变量i。在访问这些变量i中，他们不会混淆，它们是三个不同的局部变量。它们各有自己的作用域。

代码如下：

#include <stdio.h>

void main()

{
int i=10;
printf("The first i is %d\n",i);
printf("Enter a positive or negative number:  ");
scanf("%d",&i);

    
printf("In main() i=%d\n",i);
if(i>0)
{
int i=-10;
printf("In if i is %d\n",i);
}
else
{
int i=20;
printf("In else i is %d\n",i);
}
printf("The i in main() still is %d\n",i);
return;

}

运行结果：

 

2、全部变量

作用域是从定义点开始直到程序文件结束的变量，称为全局变量。全局变量在程序的整个运行过程中，都占用存储单元。在一个函数中改变了全局变量的值，其他函数可以共享。全局变量相当于起到在函数间传递数据的作用。

例如：求一元二次方程的根：ax2 + bx + c =0

代码如下：

#include <stdio.h>

#include <math.h>

float X1,X2,p,q,d;      //定义全局变量



void greater_than_zero(float,float);  //函数声明

void equal_to_zero(float,float);

void smaller_than_zero(float,float);



void main()

{
float a,b,c;          //定义局部变量
printf("Enter a,b,c:  ");
scanf("%f%f%f",&a,&b,&c);


d=b*b-4*a*c;
if(d>0)
{
greater_than_zero(a,b);
printf("X1 = %5.2f\tX2 = %5.2f\n",X1,X2);
}
else if(d==0)
{
equal_to_zero(a,b);
printf("X1 = X2 = %5.2f\n",X1);
}
else
{
smaller_than_zero(a,b);
printf("X1 = %5.2f+%5.2fi\n",p,q);
printf("X2 = %5.2f-%5.2fi\n",p,q);
}
return;



}



void greater_than_zero(float x,float y)

{
X1=(-y+sqrt(d))/(2*x);
X1=(-y-sqrt(d))/(2*x);
return;

}



void equal_to_zero(float x,float y)

{
X1=(-y)/(2*x);
return;

}



void smaller_than_zero(float x,float y)

{
p=-y/(2*x);
q=sqrt(-d)/(2*x);
return;

}

二、变量的存储类型

运行程序时，系统在内存中为数据的存储开辟了两块区域：静态数据区和动态数据区，分配在静态数据区的变量称为静态变量，分配在动态数据区的变量称为动态变量。在静态和动态两大类的存储方法中，C语言将变量的存储类型分为四种，其存储类型说明符和名称如下：

类型说明符          名称

auto                自动变量

static               静态局部变量

extern              外部变量

register             寄存器变量

在变量定义语句中，存储类型符放在它所修饰的数据类型前面，一般形式为：

存储类型符    数据类型符    变量名表；

1、自动变量auto（动态存储类型）

在函数内定义的或在函数的语句块内定义的变量，若存储类型省略或写为auto，都是自动变量。此前的程序中使用的都属于自动变量。下面的两条变量的定义语句是等价的：

int  a,b;   等价于：

auto int a,b;

注意：自动变量在初始化前，或没有赋值前，它的值是不确定的。

2、静态局部变量static（静态存储类型）

静态局部变量在静态存储区为其分配存储空间，在整个程序运行期间都不释放，变量的生存期是程序运行期。虽然静态局部变量的存储空间在整个程序运行中都保持着，但是，在它的作用域以外，仍然是不能被引用的。

例如：函数numbers()是一个数发生器，每调用函数numbers()一次，产生一个整数。每个数的产生都是在上次产生的数的基础上计算出来的。

代码如下：

#include <stdio.h>

int numbers(void);

main()

{
int i;
for(i=0;i<10;i++)
printf("%d  ",numbers());
return 0;

}



int numbers(void)

{
static int num1=0,num2=0;  //定义静态变量num1,num2
num1 = num1 + 4;
num2 = num2 + 7;
return num2 % num1;

}

运行结果：

 



3、寄存器变量register（）

如果变量在程序运行中使用非常频繁，则为存取该变量要消耗很多时间。利用寄存器操作速度快的特点，将变量存放在CPU的寄存器中，可以提高程序的运行效率。寄存器变量占用CPU的高速寄存器，不占用内存单元。变量的值就保存在CPU的寄存器中。

寄存器变量仅能用于定义局部变量或是函数的形参，不能用于全局变量。在ANSI中，寄存器变量可以用于任何数据类型，但Turbo C++将寄存器变量只限用于char型和int型变量。

例如：

register  int  num;

register型变量常用于作为循环控制变量，这是使用它的高速特点的最佳场合。比较下面两个程序的运算速度。

main ( )

{

register int temp, i;

for ( i=0; i<=30000; i++ )

for ( temp=0; temp<=100; temp++ ) ;

printf ("ok\n");

}





#include <stdio.h>

main( )

{

int temp, i;

for ( i=0; i<=30000; i++ )

for ( temp=0; temp<=100; temp++ ) ;

printf ("ok\n");

}



三、全局变量的存储定义

1、外部全局变量

全局变量是在函数外部定义的变量。变量在编译时分配在静态数据区，生存期是程序的运行期间。作用域是从定义点往后的所有定义的函数均有效。但当函数内的局部变量同名时，局部变量是有效的，全局变量无效。

如果在一个源文件中将某些变量定义为全局变量，而这些全局变量允许其他源文件中的函数引用的话，就需要有一种方法，把程序的全局变量告诉相关的模块文件。解决的办法是，在一个模块文件中将变量定义为全局变量，而在引用这个变量的模块文件中，用存储类型符extern将其说明为外部变量。即extern定义符的作用只是将一个文件定义全局变量的作用域延伸到本源程序文件。

例如：文件file1定义主函数和一个全局变量m。文件file2定义计算阶乘的函数fact(),并说明变量m为外部的。

//file1.c

#include <stdio.h>

int fact(void);

int m;

void main()

{
printf("Enter a number:  ");
scanf("%d",&m);


printf("%d!=%d\n",m,fact());
return;

}



//file2.c

extern int m;

int fact(void)

{
int result=1,i;
for(i=1;i<=m;i++)
result=result+i;
return(result);

}

2、静态全局变量

静态全局变量是在被定义的源程序文件以外是不可见的。也就是说，静态全局变量只限于它所在的源程序文件中的函数引用，而不能被其他的源程序文件中的函数引用。其定义形式和局部静态变量是一样的，其一般形式为：

static 数据类型  变量；

注意：

（1）静态全局变量和静态局部变量分配在静态数据区，生存期是程序运行期。但静态全局变量与静态局部变量的作用域方面是不相同的；

（2）静态全局变量和全部变量在同一文件内的作用域是一样的，但全局变量的作用域可延伸到其他程序文件；

（3）静态局部变量与（动态）局部变量在作用域上相同的，但前者分配在静态数据区，后者分配在动态数据区，因而，他们的生存期是不同的。

//第一个文件file1.c

static int num1,num2;

int numbers(void)

{
num1 = num1 + 4;
num2 = num2 + 7;
return num2%num1;

}

void num_init(int x1,int x2)

{
num1 = x1;
num2 = x2;

}





//file2.c

#include <stdio.h>

#include "file1.c"

int numbers(void);

void num_init(int,int);



main(void)

{
int i;
num_init(5,6);
for(i=0;i<10;i++)
printf("%d  ",numbers());
return 0;

}



总结：

（1）一个数据包含有两方面的属性：数据类型和存储类型；

（2）从作用域的角度，有局部变量和全局变量，按存储类型分，局部变量又分为自动的、静态的、寄存器三种；全局变量又分为静态的和外部的两种；

（3）从生存期的角度，有动态存储和静态存储两类，动态存储类的数据分配在动态数据区，是在进入相应的定义块时分配存储单元，如自动变量、寄存器变量和形参；静态存储类的数据分配在静态数据区，是编译时分配的，在整个程序运行期间都存在，如静态局部变量、静态外部变量和全局变量。



四、内部函数和外部函数

对于一个多源程序文件的C程序来说，根据一个函数能否调用其他源程序文件的函数，将函数分为内部函数和外部函数。

1、内部函数

函数只能被源程序文件的函数所调用，这样的函数称为内部函数，内部函数也叫做静态函数，内部函数在定义时，要在函数类型前加上说明符static，例如：

static char myfunction(char ch)

{

}

如果在定义函数时省略extern，则隐含为外部函数。例如：

void num_init(){}

int numbers(){}

在定义时虽然没有用extern说明，但实际上就是外部函数，它们可以被另一个文件的函数调用。在需要调用外部函数的文件中，用extern说明所用的函数是外部函数。例如：

extern int sum();



#include <stdio.h>

#include "file4.c"

int sum();

int i,j;

main()

{
int x;
printf("Enter two numbers: ");
scanf("%d%d",&i,&j);
x=sum();
printf("  sum=%d\n",x);
return 0;

}

在一个函数内部定义的变量就是内部变量，也就是局部变量。

在一个函数外部定义的变量就是外部变量，也就是全局变量。
从变量的作用域角度看，变量的类别可分为：

（1）局部变量

（2）全局变量
从变量的生存期角度看，变量的类别可分为：

（1）动态存储的变量（局部变量）

（2）静态存储的变量（全局变量和static修饰的变量）
数据的存储类别分为两大类：

（1）动态存储类

（2）静态存储类

具体包含4种：

（1）自动的 auto （只能声明局部变量）

（2）静态的 static （既可以声明局部变量，也可以声明全局变量）

（3）寄存器的 register （只能声明局部变量）

（4）外部的 extern （只能声明全局变量）
如果一个函数只能被本源文件中的其他函数所调用，而不能被其他源文件调用，那么这个函数就称为内部函数。

在定义内部函数时，在函数首部的最左边加关键字 static

写法如下：

static int fun（int a，int b）

{

null；

}
在定义函数时，如果在函数首部的最左边加关键字 extern ，则表示此函数是外部函数，可以被其他源文件调用。

例如：

extern int fun（int a，int b）

{

null；

}

C规定，如果在定义函数时省略 extern ，则隐含为外部函数。同时为了方便编程，C允许在调用其他源文件的外部函数时，省写关键字 extern