js全局变量和局部变量的区别,认清js中var a=b=1和var a=1，b=1的区别
js全局变量和局部变量的区别,认清js中var a=b=1和var a=1，b=1的区别详细介绍
本文目录一览： 浅谈js中什么是封闭函数、闭包、内置对象
本篇文章给大家带来的内容是介绍js中什么是封闭函数、闭包、内置对象。有一定的参考价值，有需要的朋友可以参考一下，希望对你们有所助。一、变量作用域变量作用域指的是变量的作用范围，javascript中的变量分为全局变量和局部变量1、全局变量：在函数之外定义的变量，为整个页面公用，函数的内部外部都可以访问。2、局部变量：在函数内部定义的变量，只能在定义该变量的函数内部访问，外部无法访问。函数内部访问变量时，先在内部查找是否有此变量，如果有，就使用内部，如果没有，就去外部查找 二、封闭函数封闭函数是javascript中匿名函数的另外一种写法，创建一个一开始就执行而不用命名的函数。1、一般函数的定义和执行函数2、封闭函数的定义和执行：(function(){...})();还可以在函数定义前加上"~"或者"!"符号来定义匿名函数。三、闭包闭包就是函数嵌套函数，内部函数可以引用外部函数的参数和变量，参数和变量不会被垃圾回收机制收回 1、闭包用途1：将一个变量长期驻扎在内存当中，可用于循环中存索引值 2、闭包用途2：私有变量计数器，外部无法访问，避免全局变量的污染四、内置对象1、document比如说在商品详情页观看时，想去购买，这是会跳转到登录页面，登录成功后使用该方法跳转到商品详情页document.referrer//获取上一个跳转页面的地址（需要服务器环境） 2、locationa、window.location.href // 获取或者重定url地址b、window.location.search //获取地址参数部分c、window.location.hash //获取页面锚点或者哈希值3、Matha、Math.random 获取0-1的随机值b、Math.floor 向下取整c、Math.ceil 向上取整 总结：
JS里定义变量的位置
下边的方法中cur的值永远是你在调用starMove方法时的初始值，在setInterval的方法执行过程中，这个值是不会改变的。所以永远走不进cur==iTarget这个判断中。
而第一种方法，每次setInterval的方法执行时会重新获取cur的值，所以是正确的。
一、js全局变量和局部变量
1、全局变量和它的作用域 全局变量是指在程序开头的说明部分定义和说明的量。它的作用域分为两种情况： 1）在全局变量和局部变量不同名时，其作用域是整个程序。 2）在全局变量和局部变量同名时，全局变量的作用域不包含同名局部变量的作用域。2、局部变量和它的作用域 凡是在子程序内部使用的变量，必须在子程序中加入说明。这种在子程序内部说明的变量称为局部变量。局部变量的作用域是其所在的子程序。形式参数也只能在子程序中有效。因此也属于局部变量。局部变量的作用域分为两种情况： 1）当外层过程序的局部变量名和嵌套过程中的局部变量不同名时，外层过程的局部变量作用域包含嵌套过琛。 2）当外层过程的局部变量名和嵌套过程内的局部变量名同名时，外层局部变量名的作用域不包含此过程。
二、js定义变量需要注意以下内容：
1、Javascript的变量的scope是根据方法块来划分的（也就是说以function的一对大括号｛ ｝来划分）；切记，是function块，而for、while、if块并不是作用域的划分标准
2、Javascript在执行前会对整个脚本文件的声明部分做完整分析(包括局部变量)，从而确定实变量的作用域
3、当全局变量跟局部变量重名时，局部变量的scope会覆盖掉全局变量的scope，当离开局部变量的scope后，又重回到全局变量的scope
三、js定义变量时，var和this的区别
1、var的规则是: 使用var声明变量就是内部变量, 否则就是先调用全局变量, 不管多少层函数2、this的规则是: method函数里的this永远指向自身, 普通函数的this永远指向DOMWindow
附件为var和this区别的示例代码！
JS全局变量是全局对象的属性，函数局部变量为什么就不是函数的属性呢？
我觉得有java的基础会更好理解这个问题
首先，全局变量是作为全局对象的类属性存在的
函数对象的属性分为私有属性和类属性和实例属性
函数的局部变量属于函数对象的私有属性，类似于java中private ，只能在函数内部使用
函数的类属性则类似于java中的public属性，可以通过 类名.属性名 进行访问
在JavaScript中虽然没有类的概念，但其实构造函数就是类似于java中类，所以构造函数是JavaScript中的类，类名就是函数的名称。
局部变量和全局变量同名时,会隐藏这个全局变量；
4.变量
关键字: 4.变量
4.1 变量的类型
JS是松散类型的语言
4.2 变量的声明
var 声明是变量的标准声明
var 声明的变量是永久性的,不能用delete运算符删除
全局对象,调用对象初始化时,JS解析器会在相应的代码段里寻找var声明的变量,
然后在全局对象,调用对象中创建相应的属性,此时它是未赋值的(undefined),
当程序执行到相应的var声明代码段时才会给相应对象的属性赋值
重复的声明:根据以上var声明作用的理解,重复的var声明不会造成任何错误,
var声明只是方便创建全局对象,调用对象的属性,代码只是赋值用的
遗漏的声明:给未声明的变量赋值,JS会隐式声明全局变量(在全局对象中增加相应的属性),然后给其赋值
4.3 变量的作用域
全局变量,局部变量
局部变量和全局变量同名时,会隐藏这个全局变量
4.3.1 没有块级作用域
函数中声明的变量,无论在哪里声明的,在整个函数中它们都是有定义的
4.3.2 未声明的变量和未赋值的变量
alert(u);会产生一个错误--使用未声明的变量会产生一个错误
var u;alert(u);会跳出undefined---使用未赋值的变量,使用的它的默认值undefined
4.4 基本类型和引用类型
第三章已经讲过
4.5 垃圾收集
同java
4.6 作为属性的变量
4.6.1 全局对象
JS解释器开始运行时,在执行任何JS代码前,会创建一个全局对象,这个对象的属性就是JS全局变量,
并初始化为undefined
var声明一个JS全局变量时,实际上就是定义了一个全局对象的属性,
JS解释器还会用预定义的值和函数来初始化全局对象的许多属性,如:Infinity parseInt Math
非函数内部可以用this来引用这个全局对象
客户端的JS中,Window对象代表浏览器窗口,它包含该窗口中的所有JS代码的全局对象,具有自我引用的window属性
4.6.2 局部变量:调用对象
函数的局部变量存放在调用对象的属性
调用对象是一个完全独立的对象,所以可以防止覆盖同名的全局变量
4.6.3 JS的执行环境
JS解释器执行一个函数时,会创建一个执行环境
JS允许同时存在多个全局执行环境,如:JS客户端的ifame的情况
4.7 深入理解变量作用域
每个JS执行环境都有一个和它相关联的作用域链它是一个对象列表或对象链.
查询x:变量名解析(variable name resolution)的过程,它开始查看作用域链的每一个对象,
如果有,返回值,如果没有继续查询下一个对象,以些类推.
作用域链的优先级:嵌套函数的调用对象>调用对象>全局对象
根据以上理解说明JS初始化的过程:
在JS解释器执行任何代码之前,创建全局对象
用预定义的值和函数来初始化全局对象中的属性,eg.Math,Infinity,parseInt
搜索函数外的var声明,创建全局对象相应的属性,初始化为undefined
创建全局的执行环境,作用域链只有一个对象-全局对象
依次执行代码
遇到var声明赋值语句给全局对象相应的属性赋值
遇到未声明赋值语句,在全局对象中增加相应的属性,并赋值
遇到函数调用,创建调用对象
搜索函数中的var声明和参数,创建调用对象相应的属性,初始化为undefined
创建函数执行环境,作用域链--第一对象:调用对象;第二对象:全局对象
依次执行代码
遇到var声明赋值语句给调用对象相应的属性赋值
遇到未声明赋值语句,在全局对象中增加相应的属性,并赋值
遇到函数调用,创建嵌套函数的调用对象
搜索嵌套函数中的var声明和参数,创建嵌套函数的调用对象相应的属性,初始化为undefined
创建嵌套函数执行环境,作用域链--第一对象:嵌套函数的调用对象;第二对象:调用对象;第三对象:全局对象
依此类推
eg1.
var scope="global";
function f(){
alert(scope);
var scope="local";
alert(scope);
}
f();
过程:
创建全局对象,搜索函数外的var声明语句,在全局对象中创建scope属性,scope=undefined
创建全局的执行环境,作用域链只有一个对象:全局对象
依次执行代码:
var scope="global"时,变量名解析开始,在全局对象属性中查找scope属性
把"global"赋给scope
遇到函数调用:创建调用对象
搜索函数中的var声明语句和参数,在调用对象中创建scope的属性,scope=undefined
创建函数执行环境,作用域链:调用对象>全局对象
依次执行代码:
alert(scope),查询scope,变量名解析,先搜索调用对象,找到scope属性,其值为undefined,执行
var scope="local",查询scope,变量名解析,先搜索调用对象,找到scope属性,scope="local"
alert(scope),查询scope,变量名解析,先搜索调用对象,找到scope属性,其值为"local",执行
eg2.
var scope="global";
function f(){
alert(scope);
scope="local";
alert(scope);
}
f();
过程:
创建全局对象,搜索函数外的var声明语句,在全局对象中创建scope属性,scope=undefined
创建全局的执行环境,作用域链只有一个对象:全局对象
依次执行代码:
var scope="global"时,变量名解析开始,在全局对象属性中查找scope属性
把"global"赋给scope
遇到函数调用:创建调用对象
搜索函数中的var声明语句和参数,没有找到var声明语句
创建函数执行环境,作用域链:调用对象>全局对象
依次执行代码:
alert(scope),查询scope,变量名解析,先搜索调用对象,没找到scope属性,再搜索全局对象,找到scope属性,其值为"global"执行
scope="local",查询scope,变量名解析,先搜索调用对象,没找到scope属性,,再搜索全局对象,找到scope属性,scope="local"
alert(scope),查询scope,变量名解析,先搜索调用对象,没找到scope属性,再搜索全局对象,找到scope属性,其值为"local",执行
eg3.
scope1="global";
alert(scope1);
function f(){
alert(scope2);
scope2="local";
}
f();
过程:
创建全局对象,没有找到var声明语句,没有自定义的全局对象属性
创建全局的执行环境,作用域链只有一个对象:全局对象
依次执行代码:
scope1="global"时,变量名解析开始,作用域链是没有找到scope1属性,在全局对象属性中创建scope1属性,并赋值为"global"
alert(scope1)时,变量名解析开始,作用域链是找到scope1属性,其值为"global",执行
遇到函数调用:创建调用对象
搜索函数中的var声明语句和参数,没有找到var声明语句
创建函数执行环境,作用域链:调用对象>全局对象
依次执行代码:
alert(scope2),查询scope2,变量名解析,作用域链是没有找到scope2属性,报错scope2 is not defined
例：
function square(num){
total=num*num; //这是操作全局变量。
return total;
}
val total=50;
val number=square(20);
alert(total);//total的值变成了400。
这些代码将导致全局变量total的值发生变化。
把这个函数写成这样才是正确的：
function square(num){
var total=num*num;
return total;
}
又如：
／／／／／输出 i am not fei cookie
要在方法1中 访问 方法2的变量。
必须借助于 全局变量。
在方法2中 操作全局变量 window.cookie=cookie;
这时全局变量被 改变。
在这方法一 中去访问。
例
var total;
square();
square1();
function square(){
total='aaaa';
}
function square1(){
alert(total);
}
认清js中var a=b=1和var a=1，b=1的区别
var a=b=1和var a=1,b=1完全不同 var a=b=1这个写法的首先条件是 需要先var b 否则 b是相当于没有声明的 这在JS中虽然不报错 但是不标准(如果b没有声明就使用他就会在全局声明一个b变量然后赋一个初始值，在某些IDE中会发出警告);
而var a=1,b=1则是 var a=1; var b=1的缩写
var a=b=1他们的内存空间是不同的，你在之后执行a=2；b依旧是1
学过指针的都知道 如果他们内存空间相同a改变了b一样会变
千万不要说什么 a=2的时候重新分了个新的内存空间这种可笑的话
再举个内存地址相同的例子
这里a和b的内存空间是不同的，但是a和b中的c是同一个
自己理解下吧 如果不理解就去学下C的指针
var a=b=1;是连引用，它们指向的都是同一个内存空间。
var a=1,b=1;是初始化定义变量的一种写法。它们分别开辟了两个不同的内存空间。
更多技术问题请加qq群533677775进行交流讨论吧
望采纳！
a=b=1你可以这样分开看：
var b=1;
var a = b;
b从1变成3了，a也跟着变，ab在内存里是同一引用。
而 var a=1 , b=1; 中的 ab只是恰好值一样，而他们之间没什么关系。
var a=b=1中的变量b会成为全局变量
var a=1, b=1中的a、b变量都为局部变量
var a = b = 1 ;
var a =1, b = 1;
没有区别，都是声明两个变量a,b，并且对a,b进行赋值为1；
1、用var a=b=1的方式
由上图可以明显看出来，变量b的作用域已经是全局的了，因为在函数外可以调用到（可以正常的输出变量）。
2、用var a=1,b=1的方式
由上图可以看出，变量a和变量b的作用域都是局部，因为它们在外部都不能调用到。
结论：var a=b=1中的变量b会成为全局变量，而var a=1,b=1中的a、b变量都为局部变量。
js中 声明变量时： var $i 和 var i 有什么区别吗 各自是什么意思
var $i=$("#controlID1");
var i=$("#controlID2");
function(){
//这里获取控件对象值
var controlValue1=$i.val();
var controlValue2=$(i).val();
}
就是这个区别,在调用的时候一个需要转成Jquery对象,一个不需要
var $i和var i都只是变量，加$只是多了一层含义，比如它可能是全局变量，增加代码的可读性
var $i,var i 不是同一个变量啊，
第一个的名字是$i,第二个的名字是i啊.
作用就是声明了两个变量。
获取控件对象值，在调用的时候一个需要转成Jquery对象，一个不需要，操作方法如下：
1、首先在非函数内使用var或let声明的变量拥有全局的作用域，是全局变量。
2、在函数内使用var或let声明的变量是局部变量，只能在函数内部使用。
3、let声明的变量有块作用域的概念，而var声明的变量没有块作用域的概念，在块作用域外也可以使用。
4、let和var在重新声明变量时，有所不同。在块中使用var重新声明变量，在块外的变量也会被重新定义；在块中使用let重新声明变量，在块外的变量不会被重新定义。
5、在同一个作用域下，使用let重新声明一个已经使用var声明的变量是不允许的，但var是可以重复声明变量的。
有没有var关键词声明可以用于区分JavaScript局部变量和全局变量吗？
js声明变量使用var声明与不使用var声明比较
Javascript声明变量的时候，虽然用var关键字声明和不用关键字声明，很多时候运行并没有问题，但是这两种方式还是有区别的。可以正常运行的代码并不代表是合适的代码。
var i=100 //显示申明i=100 //隐式申明
在函数中使用var关键字进行显式申明的变量是做为局部变量，而没有用var关键字，使用直接赋值方式声明的是全局变量。
当我们使用访问一个没有声明的变量时，JS会报错。而当我们给一个没有声明的变量赋值时，JS不会报错，相反它会认为我们是要隐式申明一个全局变量，这一点一定要注意。
望采纳 Thx
var声明的变量是是全局变量还是局部变量
楼主问的是什么语言， js么？
对于js, 在function 内部， 加var的是局部变量， 不加var的则是 全局变量；
在外部， var一般可以省略， 全局变量。
在函数作用域内 加var定义的变量是局部变量，不加var定义的就成了全局变量
js中let和var定义变量的区别
1、区别：
var定义的变量是全局变量或者函数变量。
let定义的变量是块级的变量。
2、全局变量：
指没有定义在任何函数内，直接定义在全局作用域中的变量。
特点：随处可用，可重用。
何时：希望随处可用，且可反复使用的变量，都要声明在函数之外的全局。
3、局部变量：
指定义在函数内的参数和变量，都是局部变量。
特点：仅函数内可用，出了函数不可用，不可重用。
何时：希望变量只在函数内有效时，都要在函数内创建变量。
let和var关键字的异同:
声明后未赋值，表现相同
'use strict';
(function() {
var varTest;
let letTest;
console.log(varTest); //输出undefined
console.log(letTest); //输出undefined
}());12345678
使用未声明的变量，表现不同:
(function() {
console.log(varTest); //输出undefined(注意要注释掉下面一行才能运行)
console.log(letTest); //直接报错：ReferenceError: letTest is not defined
var varTest = 'test var OK.';
let letTest = 'test let OK.';
}());1234567
重复声明同一个变量时，表现不同：
'use strict';
(function() {
var varTest = 'test var OK.';
let letTest = 'test let OK.';
var varTest = 'varTest changed.';
let letTest = 'letTest changed.'; //直接报错：SyntaxError: Identifier 'letTest' has already been declared
console.log(varTest); //输出varTest changed.(注意要注释掉上面letTest变量的重复声明才能运行)
console.log(letTest);
}());123456789101112
变量作用范围，表现不同
'use strict';
(function() {
var varTest = 'test var OK.';
let letTest = 'test let OK.';
{
var varTest = 'varTest changed.';
let letTest = 'letTest changed.';
}
console.log(varTest); //输出"varTest changed."，内部"{}"中声明的varTest变量覆盖外部的letTest声明
console.log(letTest); //输出"test let OK."，内部"{}"中声明的letTest和外部的letTest不是同一个变量
}());
js中let和var定义变量的区别，主要体现在作用于的不同。
var定义的变量是全局变量或者函数变量。
let定义的变量是块级的变量。
例如：
while(1){
let let1 = 2;
var var1 = 2;
}
alert(let1); //不可访问
alert(var1); //可以访问
也就是说，let只对它所在的最内侧块内有效，而var的范围至少是一个函数之内。
var定义的变量是全局变量或者函数变量；
let定义的变量是块级的变量。
区别的话，主要有几个
1：作用域不一样，var是函数作用域，而let是块作用域，也就是说，在函数内声明了var，整个函数内都是有效的，比如说在for循环内定义了一个var变量，实际上其在for循环以外也是可以访问的，而let由于是块作用域，所以如果在块作用域内（比如说for循环内）定义的变量，在其外面是不可被访问的，所以let用在for (let i; i < n; i++)是一种很推荐的写法
2. let不能在定义之前访问该变量，但是var是可以得。也就是说，let必须是先定义，再使用，而var先使用后声明也行，只不过直接使用但是没有却没有定义的时候，其值为undefined，这块要注意，这一块很容易出问题，这也是个人认为的let比var更好的地方，至于为啥会有这种区别呢，实际上var有一个变量提升的过程。也就是说，当这个函数的作用域被创建的时候，实际上var定义的变量都会被创建，并且如果此时没有初始化的话，则默认会初始化一个undefined。
3. let不能被重新定义，但是var是可以的。这个呢，我个人认为，从规范化的角度来说，是更推荐的，比如说，你在前面声明了一个变量，后来写代码，因为忘了之前的代码逻辑，又声明了一个同名的变量，如果这俩变量逻辑不一样，并且后面都要用的话，很容易出问题，且不容易维护。
总之呢，let从规范化的角度来说，要比var要进步了很大一步。所以一般情况下的话，推荐用let，const这些。当然啦，如果相对var，const和let有更深入的了解，推荐几篇小文章，这样你就会对其相关知识点有更加深入的了解了。Javascript基础之-var
Javascript基础之-var，let和const深入解析（一）
Javascript基础之-var，let和const深入解析（二）