您的当前位置:首页正文

javascript函数作用域学习示例(js作用域)_基础知识

时间:2023-12-04 来源:欧塔娱乐网

在一些类似c语言的编程语言中,花括号内的每一段代码都具有各自的作用域,而且变量在声明他们的代码段之外是不可见的,我们称为块级作用域(block scope),而javascript中没有块级作用域。取而代之的javascript使用的是函数作用域(function scope):变量在声明它的函数体以及这个函数体嵌套的任意函数体内都是有定义的。 在如下代码中,在不同位置定义的i,j和k,他们再同一个作用域内都是有定义的

代码如下:function text(o) { var i=0; alert(typeof o); if(typeof o == "string") { var j=0; for(var k=0;k<10;k++) { alert(k);//输出0-9 } alert(k);//输出10 } alert(j);//输出0 }

javascript的函数作用域指在函数内部声明的所有的变量在函数体内始终是可见的。有意思的是,这意味着变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前(hoisting),即javascript的函数体内声明的所有的变量(不涉及赋值)都被“提前”至函数体的顶部。看以下代码

代码如下:var global="globas"; function globals() { alert(global);//undefined var global="hello QDao"; alert(global);//hello QDao }

由于函数作用域的特性,局部变量在整个函数体始终是有定义的,也就是说在函数体内部变量遮盖了同名的全局变量。尽管如此在程序执行到var语句的时候,局部变量才会被真正的赋值,因此,上述过程等价于:将函数内的变量声明“提前”至函数体顶部,同事变量初始化留在原来的位置:

代码如下:var global="globas"; function globals() { var global; alert(global);//undefined global="hello QDao"; alert(global);//hello QDao }

小编还为您整理了以下内容,可能对您也有帮助:

Js基础27:作用域

函数和变量的有效范围就是作用域

1、作用域的概念

这是因为js中存在作用域的概念。

作用域:

作用域就是指定一个变量或者一个函数的作用范围。

能在页面的任何位置都可以访问,称为 全局作用域

只能在局部(函数内)访问,称为为 局部作用域

上述代码中,a是全局变量,b是局部变量

ES5中只有函数才有作用域,所谓是局部作用域也可以叫函数作用域。

作用域的作用就是为了把数据进行保护,不让外部的数据对我们的数据进行污染

以下①②③④打印什么?

但是结果却大出所料,这里得到的结果是undefined。

③处的结果也和我们最初的认识是不一样的,结果为f对应的函数对象。

造成这个结果是因为变量和函数的作用域提升的原因,什么意思呢?

JS是解释性语言,JS引擎对代码的处理分为两步:

4、作用域链和访问规则

在JavaScript里面,函数内部是可以包含另一个函数的

此时函数b就被函数a包含越来了,这样就形成了两层作用域。

如果有以下代码:三个同名变量放在三个作用域内

会依次输出:10,20,30

虽然多个变量x同名,但是不同作用域内优先使用自己内部作用域的变量x。

如果代码做一下修改:删除函数b的局部变量x

依次输出:10,20,20

函数b内部没有变量b,会向自己的外面的作用域查找x变量,函数a内的x变量离函数b最近,会优先得到函数a的变量x

代码再做修改:再删除a的局部变量x

会依次输出:10,10,10

函数b内部没有x变量,会向函数a的作用域查找,但是函数a内部也没有x变量,会向函数a的上一层作用域再查找,直到查找到了全局作用域。

代码再次变化:全局的变量x也删除

函数b内部没有变量x,会顺着上层作用域一层一层地查找,直到全局作用域也没有,就会报错。

总结:

javascript的作用域

script lanuage="javascript"

var global="javascript";

test();

funciton test()

{

var local="vbscript"

document.write("the global is"+gloabl+"br");

document.write("the local is"+local+"br");

}

document.write("local");

/script

----------------------------------
错误local已经释放掉了,它的作用域是函数范围内

script language="javascript"

for(var i = 0; i

9; i++)

{

document.write(i+"br");

}

document.write(i);

--------------------
i没有被释放,它的作用域是定义后的范围

js中作用域,闭包问题

这篇文章主要介绍了JavaScript中的作用域和闭包问题,是JS入门学习中的基础知识,需要的朋友可以参考下
JavaScript的作用域以函数为界,不同的函数拥有相对独立的作用域。函数内部可以声明和访问全局变量,也可以声明局部变量(使用var关键字,函数的参数也是局部变量),但函数外部无法访问内部的局部变量:
function test() {
var a = 0; // 局部变量
b = 1; // 全局变量
}
a = ?, b = ? // a为undefined,b为1
同名的局部变量会覆盖全局变量,但本质上它们是两个独立的变量,一方发生变化不会影响另一方:
a = 5; // 函数外a的值为5
function test() {
var a = 4; // 函数内a的值为4
}();
a = ? // 函数外a的值仍为5,不受函数影响
一般而言,函数结束后,对函数内部变量的引用全部结束,函数内的局部变量将被回收,函数的执行环境将被清空,但是,如果以内部函数作为函数的返回结果,情况就会发生变化:
function test(i) {
var b = i * i;
return function() {
return b--;
};
}
var a = test(8);
a(); // 返回值为64, 内部变量b为63
a(); // 返回值为63, 内部变量b为62
当以内部函数作为返回值时,因为函数结束后内部变量的引用并未结束,所以函数的局部变量无法回收,函数的执行环境被保留下来,因而形成了闭包效果,可以通过该引用访问本该被回收的内部变量。
闭包还使得函数的局部变量成为“私有”变量,只能通过返回的内部函数访问,而无法通过其他任何手段去改变。
因此,闭包可用于维持局部变量和保护变量。
不使用闭包的情况:
var a = []; // 假设a中包含5个元素
for (var i = 0, m = a.length; i < m; i++) {
a[i].onclick = function(e) {
return 'No. ' + i;
};
}
// 点击任何一个元素,返回值都是“No. 5”,因为i最后的值

js中作用域,闭包问题

这篇文章主要介绍了JavaScript中的作用域和闭包问题,是JS入门学习中的基础知识,需要的朋友可以参考下
JavaScript的作用域以函数为界,不同的函数拥有相对独立的作用域。函数内部可以声明和访问全局变量,也可以声明局部变量(使用var关键字,函数的参数也是局部变量),但函数外部无法访问内部的局部变量:
function test() {
var a = 0; // 局部变量
b = 1; // 全局变量
}
a = ?, b = ? // a为undefined,b为1
同名的局部变量会覆盖全局变量,但本质上它们是两个独立的变量,一方发生变化不会影响另一方:
a = 5; // 函数外a的值为5
function test() {
var a = 4; // 函数内a的值为4
}();
a = ? // 函数外a的值仍为5,不受函数影响
一般而言,函数结束后,对函数内部变量的引用全部结束,函数内的局部变量将被回收,函数的执行环境将被清空,但是,如果以内部函数作为函数的返回结果,情况就会发生变化:
function test(i) {
var b = i * i;
return function() {
return b--;
};
}
var a = test(8);
a(); // 返回值为64, 内部变量b为63
a(); // 返回值为63, 内部变量b为62
当以内部函数作为返回值时,因为函数结束后内部变量的引用并未结束,所以函数的局部变量无法回收,函数的执行环境被保留下来,因而形成了闭包效果,可以通过该引用访问本该被回收的内部变量。
闭包还使得函数的局部变量成为“私有”变量,只能通过返回的内部函数访问,而无法通过其他任何手段去改变。
因此,闭包可用于维持局部变量和保护变量。
不使用闭包的情况:
var a = []; // 假设a中包含5个元素
for (var i = 0, m = a.length; i < m; i++) {
a[i].onclick = function(e) {
return 'No. ' + i;
};
}
// 点击任何一个元素,返回值都是“No. 5”,因为i最后的值

如何更好的理解javascript变量类型以及变量作用域


变量的类型
Javascript和Java、C这些语言不同,它是一种无类型、弱检测的语言。它对变量的定义并不需要声明变量类型,我们只要通过赋值的形式,可以将各种类型的数据赋值给同一个变量。例如:
i=100;//Number类型
i="variable";//String类型
i={x:4};//Object类型
i=[1,2,3];//Array类型JS的这种特性虽然让我们的编码更加灵活,但也带来了一个弊端,不利于Debug,编译器的弱检测让我们维护冗长的代码时相当痛苦。

全局变量和局部变量
当JS解析器执行时,首先就会在执行环境里构建一个全局对象,我们定义的全局属性就是做为该对象的属性读取,在顶层代码中我们使用this关键字和window对象都可以访问到它。而函数体中的局部变量只在函数执行时生成的调用对象中存在,函数执行完毕时局部变量即刻销毁。因此在程序设计中我们需要考虑如何合理声明变量,这样既减小了不必要的内存开销,同时能很大程度地避免变量重复定义而覆盖先前定义的变量所造成的Debug麻烦。
变量作用域
任何程序语言中变量的作用域都是一个很关键的细节。JS中变量的作用域相对与JAVA、C这类语言显得更自由,一个很大的特征就是JS变量没有块级作用域,函数中的变量在整个函数都中有效,运行下面代码:
<SCRIPT LANGUAGE="JavaScript" type="text/javascript">
//定义一个输出函数
function outPut(s){
document.writeln(s)
}
//全局变量
var i=0;
//定义外部函数
function outer(){
//访问全局变量
outPut(i); // 0
//定义一个类部函数
function inner(){
//定义局部变量
var i = 1;
// i=1; 如果用隐式申明那么就覆盖了全局变量i
outPut(i); //1
}
inner();
outPut(i); //0
}
outer();
</SCRIPT>输出结果为0 1 0,从上面就可以证明JS如果用var在函数体中声明变量,那么此变量在且只在该函数体内有效,函数运行结束时,本地变量即可销毁了。
由于上面的这个JS特性,还有一个关键的问题需要注意。此前一直使用ActionScript,虽然它和JS都是基于ECMA标准的,但在这里还是略有不同的。例如下面代码:
<SCRIPT LANGUAGE="JavaScript" type="text/javascript">
//定义一个输出函数
function outPut(s){
document.writeln(s)
}
//全局变量
var i=0;
//定义外部函数
function outer(){
//访问全局变量
outPut(i); // 0
//定义一个类部函数
function inner(){
outPut(i); //undefiend
var i=1;
outPut(i); //1
}
inner();
outPut(i); //0
}
outer();
</SCRIPT>JS变量作用域
<script language ="javascript" type ="text/javascript" >
var a = "change";
function fun() {
alert(a);//输出undefined
var a = "改变了";
alert(a);//输出改变了
}
alert(a);//输出change
fun();
</script>var定义的是一个作用域上的变量,在第一次输出a之前,JS在预编译分析中已经将a赋值为change,所以第一次输出change,当调用到fun()函数的时候,JS创建一个新的作用域,在输出a之前,初始化所有var变量的值为undefined,所以fun()中第一次输出的是undefined,第二次输出已经给a赋值了,所以输出新的值;两个a在函数里面和外面是不同的两个变量,如:
<script language ="javascript" type ="text/javascript" >
var b;
function fun() {
b = "change";
}
alert(b);//输出undefined
</script>变量b在函数外面已经定义了,在函数中有给b赋值,但输出的却是undefined。

如何更好的理解javascript变量类型以及变量作用域


变量的类型
Javascript和Java、C这些语言不同,它是一种无类型、弱检测的语言。它对变量的定义并不需要声明变量类型,我们只要通过赋值的形式,可以将各种类型的数据赋值给同一个变量。例如:
i=100;//Number类型
i="variable";//String类型
i={x:4};//Object类型
i=[1,2,3];//Array类型JS的这种特性虽然让我们的编码更加灵活,但也带来了一个弊端,不利于Debug,编译器的弱检测让我们维护冗长的代码时相当痛苦。

全局变量和局部变量
当JS解析器执行时,首先就会在执行环境里构建一个全局对象,我们定义的全局属性就是做为该对象的属性读取,在顶层代码中我们使用this关键字和window对象都可以访问到它。而函数体中的局部变量只在函数执行时生成的调用对象中存在,函数执行完毕时局部变量即刻销毁。因此在程序设计中我们需要考虑如何合理声明变量,这样既减小了不必要的内存开销,同时能很大程度地避免变量重复定义而覆盖先前定义的变量所造成的Debug麻烦。
变量作用域
任何程序语言中变量的作用域都是一个很关键的细节。JS中变量的作用域相对与JAVA、C这类语言显得更自由,一个很大的特征就是JS变量没有块级作用域,函数中的变量在整个函数都中有效,运行下面代码:
<SCRIPT LANGUAGE="JavaScript" type="text/javascript">
//定义一个输出函数
function outPut(s){
document.writeln(s)
}
//全局变量
var i=0;
//定义外部函数
function outer(){
//访问全局变量
outPut(i); // 0
//定义一个类部函数
function inner(){
//定义局部变量
var i = 1;
// i=1; 如果用隐式申明那么就覆盖了全局变量i
outPut(i); //1
}
inner();
outPut(i); //0
}
outer();
</SCRIPT>输出结果为0 1 0,从上面就可以证明JS如果用var在函数体中声明变量,那么此变量在且只在该函数体内有效,函数运行结束时,本地变量即可销毁了。
由于上面的这个JS特性,还有一个关键的问题需要注意。此前一直使用ActionScript,虽然它和JS都是基于ECMA标准的,但在这里还是略有不同的。例如下面代码:
<SCRIPT LANGUAGE="JavaScript" type="text/javascript">
//定义一个输出函数
function outPut(s){
document.writeln(s)
}
//全局变量
var i=0;
//定义外部函数
function outer(){
//访问全局变量
outPut(i); // 0
//定义一个类部函数
function inner(){
outPut(i); //undefiend
var i=1;
outPut(i); //1
}
inner();
outPut(i); //0
}
outer();
</SCRIPT>JS变量作用域
<script language ="javascript" type ="text/javascript" >
var a = "change";
function fun() {
alert(a);//输出undefined
var a = "改变了";
alert(a);//输出改变了
}
alert(a);//输出change
fun();
</script>var定义的是一个作用域上的变量,在第一次输出a之前,JS在预编译分析中已经将a赋值为change,所以第一次输出change,当调用到fun()函数的时候,JS创建一个新的作用域,在输出a之前,初始化所有var变量的值为undefined,所以fun()中第一次输出的是undefined,第二次输出已经给a赋值了,所以输出新的值;两个a在函数里面和外面是不同的两个变量,如:
<script language ="javascript" type ="text/javascript" >
var b;
function fun() {
b = "change";
}
alert(b);//输出undefined
</script>变量b在函数外面已经定义了,在函数中有给b赋值,但输出的却是undefined。

前端:如何理解 JS 的作用域和作用域链?说说闭包的两个应用场景

ES6 之前 JS 没有块级作用域。例如

从上面的例子可以体会到作用域的概念,作用域就是一个独立的 地盘 ,让变量不会外泄、暴露出去。上面的name就被暴露出去了,因此,JS 没有块级作用域,只有全局作用域和函数作用域

全局作用域就是最外层的作用域,如果我们写了很多行 JS 代码,变量定义都没有用函数包括,那么它们就全部都在全局作用域中。这样的坏处就是很容易撞车、冲突。

这就是为何 jQuery、Zepto 等库的源码,所有的代码都会放在(function(){....})()中。因为放在里面的所有变量,都不会被外泄和暴露,不会污染到外面,不会对其他的库或者 JS 脚本造成影响。这是函数作用域的一个体现。

附:ES6 中开始加入了块级作用域,使用let定义变量即可,如下:

首先认识一下什么叫做 自由变量。如下代码中,console.log(a)要得到a变量,但是在当前的作用域中没有定义a(可对比一下b)。当前作用域没有定义的变量,就称为 自由变量。自由变量如何得到 —— 向父级作用域寻找。

如果父级也没呢?再一层一层向上寻找,直到找到全局作用域还是没找到,就宣布放弃。这种一层一层的关系,就是 作用域链

通过例子来理解闭包。

自由变量将从作用域链中去寻找,但是 依据的是函数定义时的作用域链,而不是函数执行时,以上这个例子就是闭包。闭包主要有两个应用场景:

1.函数作为返回值,上面的例子就是

2.函数作为参数传递,看以下例子

前端:如何理解 JS 的作用域和作用域链?说说闭包的两个应用场景

ES6 之前 JS 没有块级作用域。例如

从上面的例子可以体会到作用域的概念,作用域就是一个独立的 地盘 ,让变量不会外泄、暴露出去。上面的name就被暴露出去了,因此,JS 没有块级作用域,只有全局作用域和函数作用域

全局作用域就是最外层的作用域,如果我们写了很多行 JS 代码,变量定义都没有用函数包括,那么它们就全部都在全局作用域中。这样的坏处就是很容易撞车、冲突。

这就是为何 jQuery、Zepto 等库的源码,所有的代码都会放在(function(){....})()中。因为放在里面的所有变量,都不会被外泄和暴露,不会污染到外面,不会对其他的库或者 JS 脚本造成影响。这是函数作用域的一个体现。

附:ES6 中开始加入了块级作用域,使用let定义变量即可,如下:

首先认识一下什么叫做 自由变量。如下代码中,console.log(a)要得到a变量,但是在当前的作用域中没有定义a(可对比一下b)。当前作用域没有定义的变量,就称为 自由变量。自由变量如何得到 —— 向父级作用域寻找。

如果父级也没呢?再一层一层向上寻找,直到找到全局作用域还是没找到,就宣布放弃。这种一层一层的关系,就是 作用域链

通过例子来理解闭包。

自由变量将从作用域链中去寻找,但是 依据的是函数定义时的作用域链,而不是函数执行时,以上这个例子就是闭包。闭包主要有两个应用场景:

1.函数作为返回值,上面的例子就是

2.函数作为参数传递,看以下例子

js 函数的作用域链如何设置?

在JavaScript中,函数的作用域链是由当前执行上下文中的变量组成的。当我们在一个函数中声明一个变量时,它会向上沿着作用域链查找,直到找到该变量或者到达全局作用域。如果在全局作用域中找不到该变量,则返回undefined。

您可以通过以下方式设置函数的作用域链:

- 使用var关键字声明变量

- 使用let和const关键字声明变量

JavaScript作用域链使用介绍

之前写过一篇JavaScript 闭包究竟是什么的文章理解闭包 觉得写得很清晰 可以简单理解闭包产生原因 但看评论都在说了解了作用域链和活动对象才能真正理解闭包 起初不以为然 后来在跟公司同事交流的时候发现作用域和执行环境确实很重要 又很基础 对理解JavaScript闭包很有帮助 所以在写一篇对作用域和执行环境的理解

作用域

作用域就是变量和函数的可访问范围 控制着变量和函数的可见性与生命周期 在JavaScript中变量的作用域有全局作用域和局部作用域

单纯的JavaScript作用域还是很好理解的 在一些类C编程语言中花括号内的每一段代码都有各自的作用域 而且变量在声明它们的代码段外是不可见的 称之为块级的作用域 JavaScript容易让初学者误会的地方也在于此 JavaScript并没有块及的作用域 只有函数级作用域 变量在声明它们的函数体及其子函数内是可见的

变量没有在函数内声明或者声明的时候没有带var就是全局变量 拥有全局作用域 window对象的所有属性拥有全局作用域 在代码任何地方都可以访问 函数内部声明并且以var修饰的变量就是局部变量 只能在函数体内使用 函数的参数虽然没有使用var但仍然是局部变量

复制代码 代码如下:

var a= ; //全局变量            function fn(b){ //局部变量                c= ; //全局变量                var d= ; //局部变量                function subFn(){                    var e=d; //父函数的局部变量对子函数可见                    for(var i= ;i< ;i++){                        console write(i);                    }                    alert(i);// 在for循环内声明 循环外function内仍然可见 没有块作用域                }            }            alert(c); //在function内声明但不带var修饰 仍然是全局变量

只要是理解了JavaScript没有块作用域 简单的JavaScript作用域很好理解 还有一点儿容易让初学者迷惑的地方是JavaScript变量可函数的与解析或者声明提前 好多种叫法但说的是一件事情 JavaScript虽然是解释执行 但也不是按部就班逐句解释执行的 在真正解释执行之前 JavaScript解释器会预解析代码 将变量 函数声明部分提前解释 这就意味着我们可以在function声明语句之前调用function 这多数人习以为常 但是对于变量的与解析乍一看会很奇怪

复制代码 代码如下:

console log(a); //undefined            var a= ;            console log(a); //             console log(b); //Uncaught ReferenceError: b is not defined

     上面代码在执行前var a= ; 的声明部分就已经得到预解析(但是不会执行赋值语句) 所以第一次的时候会是undefined而不会报错 执行过赋值语句后会得到 上段代码去掉最后一句和下面代码是一样的效果

复制代码 代码如下:

var a;            console log(a); //undefined            a= ;            console log(a); //

然而如果只是这样那么JavaScript作用域问题就很简单了 然而由于函数子函数导致的问题使作用域不止这样简单 大人物登场——执行环境或者说运行期上下文(好土鳖) 执行环境(execution context)定义了变量或函数有权访问的其它数据 决定了它们的各自行为 每个执行环境都有一个与之关联的变量对象(variable object VO) 执行环境中定义的所有变量和函数都会保存在这个对象中 解析器在处理数据的时候就会访问这个内部对象

全局执行环境是最外层的一个执行环境 在web浏览器中全局执行环境是window对象 因此所有全局变量和函数都是作为window对象的属性和放大创建的 每个函数都有自己的执行环境 当执行流进入一个函数的时候 函数的环境会被推入一个函数栈中 而在函数执行完毕后执行环境出栈并被销毁 保存在其中的所有变量和函数定义随之销毁 控制权返回到之前的执行环境中 全局的执行环境在应用程序退出(浏览器关闭)才会被销毁

作用域链

当代码在一个环境中执行时 会创建变量对象的一个作用域链(scope chain 不简称sc)来保证对执行环境有权访问的变量和函数的有序访问 作用域第一个对象始终是当前执行代码所在环境的变量对象(VO)

复制代码 代码如下:

function a(x y){            var b=x+y;            return b;        }

 在函数a创建的时候它的作用域链填入全局对象 全局对象中有所有全局变量

如果执行环境是函数 那么将其活动对象(activation object AO)作为作用域链第一个对象 第二个对象是包含环境 下一个是包含环境的包含环境

复制代码 代码如下:

function a(x y){            var b=x+y;            return b;        }        var tatal=a( );

 这时候 var total=a( );语句的作用域链如下

在函数运行过程中标识符的解析是沿著作用域链一级一级搜索的过程 从第一个对象开始 逐级向后回溯 直到找到同名标识符为止 找到后不再继续遍历 找不到就报错

再来看看闭包

之前博客曾经总结道 只要存在调用内部函数的可能 JavaScript就需要保留被引用的函数 而且JavaScript运行时需要跟踪引用这个内部函数的所有变量 直到最后一个变量废弃 JavaScript的垃圾收集器才能释放相应的内存空间 回头再看看好理解了很多 父函数定义的变量在子函数的作用域链中 子函数没有被销毁 其作用域链中所有变量和函数就会被维护 不会被销毁

复制代码 代码如下:

for(var i= ;i<elements length;i++){                elements[i] onclick=function(){                    alert(i);                }            }

  这是上篇博客提到过的经典错误 每次element点击alert都是length 这段代码中为element绑定的click事件处理程序的作用域链是这样的

由于内部函数(click事件处理程序时刻有调用可能) 所以其作用域链不能被销毁(更别说本例中i在全局作用域中 只能页面卸载是销毁) i的值一直保持for循环执行完后的length值 所以每次触发onclick的时候才会alert length

复制代码 代码如下:

for(var i= ;i<elements length;i++){                (function(n){                    elements[n] onclick=function(){                        alert(n);                    }                })(i);            }

为什么这样就行了呢 这时候onclick引用的变量变成了n 而由于立即执行函数的原因 每个onclick函数在作用域链中分别保持着对应的n( ~length ) 这时候就可以了

最后

lishixin/Article/program/Java/JSP/201405/30945

    JavaScript作用域链使用介绍

    之前写过一篇JavaScript 闭包究竟是什么的文章理解闭包 觉得写得很清晰 可以简单理解闭包产生原因 但看评论都在说了解了作用域链和活动对象才能真正理解闭包 起初不以为然 后来在跟公司同事交流的时候发现作用域和执行环境确实很重要 又很基础 对理解JavaScript闭包很有帮助 所以在写一篇对作用域和执行环境的理解

    作用域

    作用域就是变量和函数的可访问范围 控制着变量和函数的可见性与生命周期 在JavaScript中变量的作用域有全局作用域和局部作用域

    单纯的JavaScript作用域还是很好理解的 在一些类C编程语言中花括号内的每一段代码都有各自的作用域 而且变量在声明它们的代码段外是不可见的 称之为块级的作用域 JavaScript容易让初学者误会的地方也在于此 JavaScript并没有块及的作用域 只有函数级作用域 变量在声明它们的函数体及其子函数内是可见的

    变量没有在函数内声明或者声明的时候没有带var就是全局变量 拥有全局作用域 window对象的所有属性拥有全局作用域 在代码任何地方都可以访问 函数内部声明并且以var修饰的变量就是局部变量 只能在函数体内使用 函数的参数虽然没有使用var但仍然是局部变量

    复制代码 代码如下:

    var a= ; //全局变量            function fn(b){ //局部变量                c= ; //全局变量                var d= ; //局部变量                function subFn(){                    var e=d; //父函数的局部变量对子函数可见                    for(var i= ;i< ;i++){                        console write(i);                    }                    alert(i);// 在for循环内声明 循环外function内仍然可见 没有块作用域                }            }            alert(c); //在function内声明但不带var修饰 仍然是全局变量

    只要是理解了JavaScript没有块作用域 简单的JavaScript作用域很好理解 还有一点儿容易让初学者迷惑的地方是JavaScript变量可函数的与解析或者声明提前 好多种叫法但说的是一件事情 JavaScript虽然是解释执行 但也不是按部就班逐句解释执行的 在真正解释执行之前 JavaScript解释器会预解析代码 将变量 函数声明部分提前解释 这就意味着我们可以在function声明语句之前调用function 这多数人习以为常 但是对于变量的与解析乍一看会很奇怪

    复制代码 代码如下:

    console log(a); //undefined            var a= ;            console log(a); //             console log(b); //Uncaught ReferenceError: b is not defined

         上面代码在执行前var a= ; 的声明部分就已经得到预解析(但是不会执行赋值语句) 所以第一次的时候会是undefined而不会报错 执行过赋值语句后会得到 上段代码去掉最后一句和下面代码是一样的效果

    复制代码 代码如下:

    var a;            console log(a); //undefined            a= ;            console log(a); //

    然而如果只是这样那么JavaScript作用域问题就很简单了 然而由于函数子函数导致的问题使作用域不止这样简单 大人物登场——执行环境或者说运行期上下文(好土鳖) 执行环境(execution context)定义了变量或函数有权访问的其它数据 决定了它们的各自行为 每个执行环境都有一个与之关联的变量对象(variable object VO) 执行环境中定义的所有变量和函数都会保存在这个对象中 解析器在处理数据的时候就会访问这个内部对象

    全局执行环境是最外层的一个执行环境 在web浏览器中全局执行环境是window对象 因此所有全局变量和函数都是作为window对象的属性和放大创建的 每个函数都有自己的执行环境 当执行流进入一个函数的时候 函数的环境会被推入一个函数栈中 而在函数执行完毕后执行环境出栈并被销毁 保存在其中的所有变量和函数定义随之销毁 控制权返回到之前的执行环境中 全局的执行环境在应用程序退出(浏览器关闭)才会被销毁

    作用域链

    当代码在一个环境中执行时 会创建变量对象的一个作用域链(scope chain 不简称sc)来保证对执行环境有权访问的变量和函数的有序访问 作用域第一个对象始终是当前执行代码所在环境的变量对象(VO)

    复制代码 代码如下:

    function a(x y){            var b=x+y;            return b;        }

     在函数a创建的时候它的作用域链填入全局对象 全局对象中有所有全局变量

    如果执行环境是函数 那么将其活动对象(activation object AO)作为作用域链第一个对象 第二个对象是包含环境 下一个是包含环境的包含环境

    复制代码 代码如下:

    function a(x y){            var b=x+y;            return b;        }        var tatal=a( );

     这时候 var total=a( );语句的作用域链如下

    在函数运行过程中标识符的解析是沿著作用域链一级一级搜索的过程 从第一个对象开始 逐级向后回溯 直到找到同名标识符为止 找到后不再继续遍历 找不到就报错

    再来看看闭包

    之前博客曾经总结道 只要存在调用内部函数的可能 JavaScript就需要保留被引用的函数 而且JavaScript运行时需要跟踪引用这个内部函数的所有变量 直到最后一个变量废弃 JavaScript的垃圾收集器才能释放相应的内存空间 回头再看看好理解了很多 父函数定义的变量在子函数的作用域链中 子函数没有被销毁 其作用域链中所有变量和函数就会被维护 不会被销毁

    复制代码 代码如下:

    for(var i= ;i<elements length;i++){                elements[i] onclick=function(){                    alert(i);                }            }

      这是上篇博客提到过的经典错误 每次element点击alert都是length 这段代码中为element绑定的click事件处理程序的作用域链是这样的

    由于内部函数(click事件处理程序时刻有调用可能) 所以其作用域链不能被销毁(更别说本例中i在全局作用域中 只能页面卸载是销毁) i的值一直保持for循环执行完后的length值 所以每次触发onclick的时候才会alert length

    复制代码 代码如下:

    for(var i= ;i<elements length;i++){                (function(n){                    elements[n] onclick=function(){                        alert(n);                    }                })(i);            }

    为什么这样就行了呢 这时候onclick引用的变量变成了n 而由于立即执行函数的原因 每个onclick函数在作用域链中分别保持着对应的n( ~length ) 这时候就可以了

    最后

    lishixin/Article/program/Java/JSP/201405/30945

      05.作用域

      一个变量如果定义在了一个function里面,那么这个变量就是一个局部变量,只在这个function里面有定义,出了这个function,就如同没有定义过一样

      a被var在了function里面,所以现在这个a变量只在函数内定义

      JavaScript变量作用域非常的简单,没有块级作用域,管理住作用域的只有一个东西,函数

      如果一个变量,没有定义在任何的function中,那么它将在全部程序范围内都有定义:就是你在JS的任何位置都能够使用它。

      总结:

      当遇见一个变量时,JS引擎会从其所在的作用域依此向外层 查找,查找会在找到第一个匹配的标识符的时候停止

      多层嵌套,如果有同名的变量,那么就会发生”遮蔽效应“

      作用域链:一个变量在使用的时候,就会在当前层寻找它是否被定义,如果找不到,就去找上一层function,知道找到全局变量,如果全局页面没有,就报错。

      这是JS的一个机理,如果遇见了一个标识符,从来没有var过,并且还赋值了:

      那么就会自动帮你在全局范围内定义 var num;

      a, b, c, d就是一个fn的局部变量,出了fn就没有定义

      两个函数同时操作同一个变量,一个增加,一个减少,函数和函数通信

      如果num定义在baoshu里面,每次执行就会把num重置为0,

      机理:

      推导过程:
      inner()这个函数不能在outer外面调用,因为outer外面没有inne的定义

      但是我们现在就想在全局作用域下,运行outer内部的inner,此时我们必须想一些奇奇怪怪的方法。

      有一个简单可行的办法,就是让outer自己return掉inner:

      这就说明了,inner函数能够持久保存自己定义是的所处环境,并且及时自己在其他的环境被调用的时候,依然可以访问自己定义时所处环境的值

      一个函数可以把它自己内部的语句,和自己声明时所处的作用域一起封装乘了一个密闭的环境,我们称之为“闭包”(Closures)

      每一个函数都是闭包,每个函数天生就能记忆自己定义时所处的作用域环境。但是,我们必须将这个函数挪到别的作用域,才能更好的观察闭包。这样才能实验它有没有把作用域给“记住”

      每次重新引用函数的时候,闭包时全新的。

      无论它在何处被调用,它总是能访问它定义时所处作用域中的全部变量

      05.作用域

      一个变量如果定义在了一个function里面,那么这个变量就是一个局部变量,只在这个function里面有定义,出了这个function,就如同没有定义过一样

      a被var在了function里面,所以现在这个a变量只在函数内定义

      JavaScript变量作用域非常的简单,没有块级作用域,管理住作用域的只有一个东西,函数

      如果一个变量,没有定义在任何的function中,那么它将在全部程序范围内都有定义:就是你在JS的任何位置都能够使用它。

      总结:

      当遇见一个变量时,JS引擎会从其所在的作用域依此向外层 查找,查找会在找到第一个匹配的标识符的时候停止

      多层嵌套,如果有同名的变量,那么就会发生”遮蔽效应“

      作用域链:一个变量在使用的时候,就会在当前层寻找它是否被定义,如果找不到,就去找上一层function,知道找到全局变量,如果全局页面没有,就报错。

      这是JS的一个机理,如果遇见了一个标识符,从来没有var过,并且还赋值了:

      那么就会自动帮你在全局范围内定义 var num;

      a, b, c, d就是一个fn的局部变量,出了fn就没有定义

      两个函数同时操作同一个变量,一个增加,一个减少,函数和函数通信

      如果num定义在baoshu里面,每次执行就会把num重置为0,

      机理:

      推导过程:
      inner()这个函数不能在outer外面调用,因为outer外面没有inne的定义

      但是我们现在就想在全局作用域下,运行outer内部的inner,此时我们必须想一些奇奇怪怪的方法。

      有一个简单可行的办法,就是让outer自己return掉inner:

      这就说明了,inner函数能够持久保存自己定义是的所处环境,并且及时自己在其他的环境被调用的时候,依然可以访问自己定义时所处环境的值

      一个函数可以把它自己内部的语句,和自己声明时所处的作用域一起封装乘了一个密闭的环境,我们称之为“闭包”(Closures)

      每一个函数都是闭包,每个函数天生就能记忆自己定义时所处的作用域环境。但是,我们必须将这个函数挪到别的作用域,才能更好的观察闭包。这样才能实验它有没有把作用域给“记住”

      每次重新引用函数的时候,闭包时全新的。

      无论它在何处被调用,它总是能访问它定义时所处作用域中的全部变量

      有效提高JavaScript执行效率的几点知识_javascript技巧


      为了提供新鲜、别致的用户体验,很多网站都会使用 JavaScript 来改善设计、验证表单、检查浏览器,以及Ajax请求,cookie操作等等,实现无刷新动态效果 。但是,要将大量内容在浏览器呈现,如果处理不好,网站性能将会急剧下降。所以我们有必要了解下,如何提高JavaScript的执行效率。

      JavaScript 函数

      在JavaScript 中,函数在使用前会预编译。尽管有些时候下可以使用字符串代替函数,但是每次执行这段JavaScript 代码时都会重新解析,影响性能。

      1、eval例子
      代码如下:
      eval('output=(input * input)');
      // 建议改成:
      eval(new function() { output=(input * input)});


      2、setTimeout例子

      代码如下:
      setTimeout("alert(1)", 1000);
      // 建议改成:
      setTimeout(function(){alert(1)}, 1000);


      使用函数代替字符串作参数确保新方法中的代码能被 JavaScript 编译器优化。

      JavaScript作用域

      JavaScript作用域链中的每个作用域都包含几个变量。理解作用域链很重要,这样才能利用它。

      代码如下:
      var localVar = "global"; //全局变量

      function test() {

      var localVar = "local"; //局部变量

      //局部变量
      alert(localVar);

      //全局变量
      alert(this.localVar);

      //查找document在局部变量找不到,就查找全局变量
      var pageName = document.getElementById("pageName");
      }

      使用局部变量比使用全局变量快得多,因为在作用域链中越远,解析越慢。下图显示了作用域链结构:



      如果代码中有 with 或 try-catch 语句,作用域链会更复杂,如下图:



      JavaScript字符串

      JavaScript中一个非常影响性能的函数是字符串连接,一般情况都是使用 + 号来实现拼接字符串。但是早期浏览器没有对这样的连接方式做优化,导致在连续创建和销毁字符串严重降低JavaScript执行效率。

      代码如下:
      var txt = "hello" + " " + "world";


      建议改成:

      代码如下:
      var o = [];
      o.push("hello");
      o.push(" ");
      o.push("world");
      var txt = o.join();


      我们再简单封装一下:

      代码如下:
      function StringBuffer(str) {
      var arr = [];
      arr.push(str || "");
      this.append = function(str) {
      arr.push(str);
      return this;
      };
      this.toString = function() {
      return arr.join("");
      };
      };


      然后这样子调用:

      代码如下:
      var txt = new StringBuffer();
      txt.append("Hello");
      txt.append(" ");
      txt.append("World");
      alert(txt.toString());


      JavaScript DOM操作

      HTML Document Object Model (DOM) 定义了访问和操作 HTML 文档的标准方法。它将 HTML 文档表示成节点树,其中包含元素、属性和文本内容。通过使用 HTML DOM,JavaScript 能访问 HTML 文档中所有节点并操作它们。

      DOM重绘

      每次修改到页面的DOM对象,都涉及到DOM重绘,浏览器都会重新渲染页面。所以降低DOM对象的修改次数,可以有效地提高JavaScript 的性能。

      代码如下:
      for (var i = 0; i < 1000; i++ ) {
      var elmt = document.createElement('p');
      elmt.innerHTML = i;
      document.body.appendChild(elmt);
      }


      建议改成:

      代码如下:
      var html = [];
      for (var i = 0; i < 1000; i++) {
      html.push('' + i + '
      ');
      }
      document.body.innerHTML = html.join('');


      DOM访问

      通过DOM可以访问到HTML文档中的每个节点。每次调用getElementById()、getElementsByTagName()等方法,都会重新查找并访问节点。所以将查找到的DOM节点缓存一下,也可以提高JavaScript 的性能。
      代码如下:
      document.getElementById("p2").style.color = "blue";
      document.getElementById("p2").style.fontFamily = "Arial";
      document.getElementById("p2").style.fontSize = "larger";


      建议改成:

      代码如下:
      var elmt = document.getElementById("p2");
      elmt.style.color = "blue";
      elmt.style.fontFamily = "Arial";
      elmt.style.fontSize = "larger";


      DOM遍历

      DOM遍历子元素通常都是按索引循环读取下一个子元素,在早期浏览器下这种读取方式执行效率很低,利用nextSibling方式可以提高js遍历DOM的效率。

      代码如下:
      var html = [];
      var x = document.getElementsByTagName("p");//所有节点
      for (var i = 0; i < x.length; i++) {
      //todo
      }


      建议改成:

      代码如下:
      var html = [];
      var x = document.getElementById("div");//上级节点
      var node = x.firstChild;
      while(node != null){
      //todo
      node = node.nextSibling;
      }


      JavaScript 内存释放

      在web应用中,随着DOM对象数量的增加,内存消耗会越来越大。所以应当及时释放对象的引用,让浏览器能够回收这些内存。

      释放DOM占用的内存

      代码如下:
      document.getElementById("test").innerHTML = "";


      将DOM元素的innerHTML设置为空字符串,可以释放其子元素占用的内存。

      释放javascript对象

      代码如下:
      //对象:
      obj = null
      //对象属性:
      delete obj.property
      //数组元素:
      arr.splice(0,3);//删除前3个元素

      有效提高JavaScript执行效率的几点知识_javascript技巧


      为了提供新鲜、别致的用户体验,很多网站都会使用 JavaScript 来改善设计、验证表单、检查浏览器,以及Ajax请求,cookie操作等等,实现无刷新动态效果 。但是,要将大量内容在浏览器呈现,如果处理不好,网站性能将会急剧下降。所以我们有必要了解下,如何提高JavaScript的执行效率。

      JavaScript 函数

      在JavaScript 中,函数在使用前会预编译。尽管有些时候下可以使用字符串代替函数,但是每次执行这段JavaScript 代码时都会重新解析,影响性能。

      1、eval例子
      代码如下:
      eval('output=(input * input)');
      // 建议改成:
      eval(new function() { output=(input * input)});


      2、setTimeout例子

      代码如下:
      setTimeout("alert(1)", 1000);
      // 建议改成:
      setTimeout(function(){alert(1)}, 1000);


      使用函数代替字符串作参数确保新方法中的代码能被 JavaScript 编译器优化。

      JavaScript作用域

      JavaScript作用域链中的每个作用域都包含几个变量。理解作用域链很重要,这样才能利用它。

      代码如下:
      var localVar = "global"; //全局变量

      function test() {

      var localVar = "local"; //局部变量

      //局部变量
      alert(localVar);

      //全局变量
      alert(this.localVar);

      //查找document在局部变量找不到,就查找全局变量
      var pageName = document.getElementById("pageName");
      }

      使用局部变量比使用全局变量快得多,因为在作用域链中越远,解析越慢。下图显示了作用域链结构:



      如果代码中有 with 或 try-catch 语句,作用域链会更复杂,如下图:



      JavaScript字符串

      JavaScript中一个非常影响性能的函数是字符串连接,一般情况都是使用 + 号来实现拼接字符串。但是早期浏览器没有对这样的连接方式做优化,导致在连续创建和销毁字符串严重降低JavaScript执行效率。

      代码如下:
      var txt = "hello" + " " + "world";


      建议改成:

      代码如下:
      var o = [];
      o.push("hello");
      o.push(" ");
      o.push("world");
      var txt = o.join();


      我们再简单封装一下:

      代码如下:
      function StringBuffer(str) {
      var arr = [];
      arr.push(str || "");
      this.append = function(str) {
      arr.push(str);
      return this;
      };
      this.toString = function() {
      return arr.join("");
      };
      };


      然后这样子调用:

      代码如下:
      var txt = new StringBuffer();
      txt.append("Hello");
      txt.append(" ");
      txt.append("World");
      alert(txt.toString());


      JavaScript DOM操作

      HTML Document Object Model (DOM) 定义了访问和操作 HTML 文档的标准方法。它将 HTML 文档表示成节点树,其中包含元素、属性和文本内容。通过使用 HTML DOM,JavaScript 能访问 HTML 文档中所有节点并操作它们。

      DOM重绘

      每次修改到页面的DOM对象,都涉及到DOM重绘,浏览器都会重新渲染页面。所以降低DOM对象的修改次数,可以有效地提高JavaScript 的性能。

      代码如下:
      for (var i = 0; i < 1000; i++ ) {
      var elmt = document.createElement('p');
      elmt.innerHTML = i;
      document.body.appendChild(elmt);
      }


      建议改成:

      代码如下:
      var html = [];
      for (var i = 0; i < 1000; i++) {
      html.push('' + i + '
      ');
      }
      document.body.innerHTML = html.join('');


      DOM访问

      通过DOM可以访问到HTML文档中的每个节点。每次调用getElementById()、getElementsByTagName()等方法,都会重新查找并访问节点。所以将查找到的DOM节点缓存一下,也可以提高JavaScript 的性能。
      代码如下:
      document.getElementById("p2").style.color = "blue";
      document.getElementById("p2").style.fontFamily = "Arial";
      document.getElementById("p2").style.fontSize = "larger";


      建议改成:

      代码如下:
      var elmt = document.getElementById("p2");
      elmt.style.color = "blue";
      elmt.style.fontFamily = "Arial";
      elmt.style.fontSize = "larger";


      DOM遍历

      DOM遍历子元素通常都是按索引循环读取下一个子元素,在早期浏览器下这种读取方式执行效率很低,利用nextSibling方式可以提高js遍历DOM的效率。

      代码如下:
      var html = [];
      var x = document.getElementsByTagName("p");//所有节点
      for (var i = 0; i < x.length; i++) {
      //todo
      }


      建议改成:

      代码如下:
      var html = [];
      var x = document.getElementById("div");//上级节点
      var node = x.firstChild;
      while(node != null){
      //todo
      node = node.nextSibling;
      }


      JavaScript 内存释放

      在web应用中,随着DOM对象数量的增加,内存消耗会越来越大。所以应当及时释放对象的引用,让浏览器能够回收这些内存。

      释放DOM占用的内存

      代码如下:
      document.getElementById("test").innerHTML = "";


      将DOM元素的innerHTML设置为空字符串,可以释放其子元素占用的内存。

      释放javascript对象

      代码如下:
      //对象:
      obj = null
      //对象属性:
      delete obj.property
      //数组元素:
      arr.splice(0,3);//删除前3个元素

      javascript中作用域问题~

      几乎很多语言都有一个不为人知的特性,这是我在学习as3时看到的
      也就是代码的排序
      1.排在最前的是用function定义的函数
      例如下面这个例子
      showMessage();
      function showMessage(){
      msg();
      return true;
      function msg(){
      alert('hello');
      }
      }
      上面的例子会提示"hello"
      即使函数在return后定义,依然可以调用它
      2.第二位应该是由var定义的变量
      不过注意,虽然这些变量的定义提前到第二位了,但是他们的赋值语句其实没有被提前
      也就是说是一个undefined的值
      例子:
      var foo="foo";
      function showMessage(){
      if (false){
      var foo="bar";
      }
      alert(foo);
      }
      showMessage();
      上面的例子会提示"undefined"
      3.排在最后的当然就是剩下的语句了,当然包括语句块,它们是最后执行的
      可能你还对刚才一个例子有点疑惑,只要按照这个顺序重新排一下就清楚了
      function showMessage(){
      var foo;
      if (false){
      foo="bar";
      }
      alert(foo);
      }
      var foo;
      foo="foo";
      showMessage();
      记住了代码的排序是在每一个作用域里(也就是脚本中或function中,但是let算不算我就不清楚了)都会进行的。
      而你的代码里执行的顺序应该是下面这样的
      function myFun()
      {
      alert("2!");
      }
      window.myFun=function(){alert("1!")}

      myFun首先用function关键字定义了,然后由被一个赋值语句覆盖了,也就不存在了,所以总是执行赋值语句所定义的函数

      希望对你有些启发

      javascript中作用域问题~

      几乎很多语言都有一个不为人知的特性,这是我在学习as3时看到的
      也就是代码的排序
      1.排在最前的是用function定义的函数
      例如下面这个例子
      showMessage();
      function showMessage(){
      msg();
      return true;
      function msg(){
      alert('hello');
      }
      }
      上面的例子会提示"hello"
      即使函数在return后定义,依然可以调用它
      2.第二位应该是由var定义的变量
      不过注意,虽然这些变量的定义提前到第二位了,但是他们的赋值语句其实没有被提前
      也就是说是一个undefined的值
      例子:
      var foo="foo";
      function showMessage(){
      if (false){
      var foo="bar";
      }
      alert(foo);
      }
      showMessage();
      上面的例子会提示"undefined"
      3.排在最后的当然就是剩下的语句了,当然包括语句块,它们是最后执行的
      可能你还对刚才一个例子有点疑惑,只要按照这个顺序重新排一下就清楚了
      function showMessage(){
      var foo;
      if (false){
      foo="bar";
      }
      alert(foo);
      }
      var foo;
      foo="foo";
      showMessage();
      记住了代码的排序是在每一个作用域里(也就是脚本中或function中,但是let算不算我就不清楚了)都会进行的。
      而你的代码里执行的顺序应该是下面这样的
      function myFun()
      {
      alert("2!");
      }
      window.myFun=function(){alert("1!")}

      myFun首先用function关键字定义了,然后由被一个赋值语句覆盖了,也就不存在了,所以总是执行赋值语句所定义的函数

      希望对你有些启发

      欧塔娱乐网还为您提供以下相关内容希望对您有帮助:

      Js基础27:作用域

      1、作用域的概念 这是因为js中存在作用域的概念。作用域:作用域就是指定一个变量或者一个函数的作用范围。能在页面的任何位置都可以访问,称为 全局作用域 只能在局部(函数内)访问,称为为 局部作用域 上述代码中,...

      JS块级作用域和私有变量实例分析

      上例中,定义了一个块级作用域,变量i在块级作用域中可见的,但是在块级作用域外部则无法访问。这种技术经常在全局作用域中被用在函数外部,从而限制向全局作用域中添加过多的变量和函数。私有变量 任何在函数中定义的变量...

      前端:如何理解 JS 的作用域和作用域链?说说闭包的两个应用场景_百度知 ...

      从上面的例子可以体会到作用域的概念,作用域就是一个独立的 地盘 ,让变量不会外泄、暴露出去。上面的name就被暴露出去了,因此, JS 没有块级作用域,只有全局作用域和函数作用域 。全局作用域就是最外层的作用域 ,如...

      javascript的作用域

      /script---错误local已经释放掉了,它的作用域是函数范围内script language="javascript"for(var i = 0; i9; i++){document.write(i+"br");}document.write(i);---i没有被释放,它的作用域是定义后的范围 ...

      理解什么是JS作用域,闭包和基本的JS作用域面试题

      作用域:它是指对某一变量和方法具有访问权限的代码空间, 在JS中, 作用域是在函数中维护的。表示变量或函数起作用的区域,指代了它们在什么样的上下文中执行,亦即上下文执行环境。Javascript的作用域只有两种:全局作用域和本...

      js 关于作用域链的问题

      一:函数作用域 先看一小段代码:[javascript] view plain copy var scope="global";function t(){ console.log(scope);var scope="local"console.log(scope);} t();(PS: console.log()是firebug提供的调试工具,...

      如何更好的理解javascript变量类型以及变量作用域

      JS中变量的作用域相对与JAVA、C这类语言显得更自由,一个很大的特征就是JS变量没有块级作用域,函数中的变量在整个函数都中有效,运行下面代码: &lt;SCRIPT LANGUAGE="JavaScript" type="text/javascript"&gt; //定义一个输出...

      有效提高JavaScript执行效率的几点知识_javascript技巧

      ;使用函数代替字符串作参数确保新方法中的代码能被 JavaScript 编译器优化。JavaScript作用域JavaScript作用域链中的每个作用域都包含几个变量。理解作用域链很重要,这样才能利用它。 代码如下:var localVar = "global";...

      js关于作用域的问题

      首先说一下js全局变量的作用域:在js中如果直接定义一个变量,都是在window这个作用域下定义的 比如 var num = 60 也可以写成这样 window.num = 60 这两个写法是完全一样的,不管哪种写法,使用 console.log(num, ...

      javascript中: (function(){})();如何理解?

      javascript中: (function(){})()是匿名函数,主要利用函数内的变量作用域,避免产生全局变量,影响整体页面环境,增加代码的兼容性。(function(){})是一个标准的函数定义,但是没有复制给任何变量。所以是没有名字的函数,...

      Top