“let”和“var”之间的区别是什么？

Question

引入ECMAScript 6这个让陈述.

我听说它被描述为局部变量，但我仍然不太确定它与无功功率，无功功率关键字。

有什么区别？什么时候应该让被用来代替无功功率，无功功率?

Answer 1

范围界定规则

主要区别在于范围规则。声明的变量无功功率，无功功率关键字的作用域是直接函数体（因此是函数作用域），而让变量的作用域为立即数封闭块表示为{ }（因此是块范围）。

函数run（）{var foo=“foo”；设bar=“bar”；console.log（foo，bar）；//Foo酒吧{var moo=“Mooo”设baz=“Bazz”；console.log（moo，baz）；//穆奥巴兹}console.log（moo）；//穆奥控制台.log（baz）；//引用错误}运行（）；

为什么让该语言引入了关键字，因为函数范围令人困惑，并且是JavaScript中错误的主要来源之一。

看看这个例子另一个堆栈溢出问题:

var函数=[]；//让我们创建3个函数对于（var i=0；i<3；i++）{//并将其存储在函数中funcs[i]=函数（）{//每个都应该记录其值。console.log（“我的值：”+i）；};}对于（var j=0；j<3；j++）{//现在让我们逐一看看函数[j]（）；}

我的价值观：3每次都输出到控制台函数[j]（）；由于匿名函数绑定到同一变量，因此调用了。

人们必须创建立即调用的函数来从循环中捕获正确的值，但这也很麻烦。

吊装

用声明的变量无功功率，无功功率关键字是吊装和已初始化这意味着即使在声明它们之前，也可以在其封闭范围内访问它们，但它们的值是未定义在到达声明语句之前：

功能检查提升（）{console.log（foo）；//未定义var foo=“foo”；console.log（foo）；//富}检查吊装（）；

让变量是已吊装，但未初始化直到他们的定义得到评估。在初始化之前访问它们会导致引用错误。该变量称为in时间死区从块的开始直到处理声明语句。

功能检查提升（）{console.log（foo）；//引用错误让foo=“foo”；console.log（foo）；//富}检查提升（）；

创建全局对象属性

在顶层，让，不像无功功率，无功功率，不在全局对象上创建属性：

var foo=“foo”；//全局范围的让bar=“bar”；//全局范围，但不是全局对象的一部分console.log（window.foo）；//富console.log（window.bar）；//未定义

重声明

在严格模式下，无功功率，无功功率将允许您在同一范围内重新声明同一变量，同时让引发语法错误。

'使用严格'；var foo=“foo1”；var foo=“foo2”；//没问题，“foo1”被替换为“foo2”。设bar=“bar1”；设bar=“bar2”；//语法错误：已声明标识符“bar”

Answer 2

让也可以用来避免闭包问题。它绑定新值，而不是保留旧引用，如下面的示例所示。

对于（var i=1；i<6；i++）{$（“#div”+i）点击（函数（）{console.log（i）；}）；}

<script src=“https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js“></script><p>单击每个数字将登录到控制台：</p><div id=“div1”>1<div id=“div2”>2<div id=“div3”>3<div id=“div4”>4<div id=“div5”>5

上面的代码演示了一个典型的JavaScript关闭问题。参考我变量存储在click处理程序闭包中，而不是我.

每个单击处理程序都会引用同一个对象，因为只有一个计数器对象可以容纳6个对象，所以每次单击都会得到6个对象。

一个通用的解决方法是将其封装在一个匿名函数中并传递我作为一个论点。现在也可以通过使用让相反无功功率，无功功率如下面的代码所示。

_{（在Chrome和Firefox 50中测试）}

for（设i=1；i<6；i++）{$（“#div”+i）点击（函数（）{console.log（i）；}）；}

<script src=“https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js“></script><p>单击每个数字将登录到控制台：</p><div id=“div1”>1<div id=“div2”>2<div id=“div3”>3</div><div id=“div4”>4<div id=“div5”>5

Answer 3

两者的区别是什么让和无功功率，无功功率?

• 使用无功功率，无功功率语句自始至终都是众所周知的函数它是从函数开始在中定义的。(*)
• 使用让语句仅在中已知街区从定义开始，它就在中定义。(**)

要理解差异，请考虑以下代码：

//我在这里不认识//这里不知道j//k在此已知，但未定义//我在这里不认识功能循环（arr）{//我在这里是已知的，但没有定义//此处不知道j//k在这里是已知的，但只有一个值，称为第二个时间循环//我在这里不认识对于（var i=0；i<arr.length；i++）{//我在这里是已知的，并且有一个值//此处不知道j//k在这里是已知的，但有一个值，只有第二个时间循环被调用//我在这里不认识};//我在这里是已知的，并且有一个值//此处不知道j//k在这里是已知的，但只有一个值，称为第二个时间循环//我在这里不认识for（设j=0；j<arr.length；j++）{//我在这里是已知的，并且有一个值//j在这里是已知的，并且有一个值//k在这里是已知的，但有一个值，只有第二个时间循环被调用//我在这里不认识};//我在这里是已知的，并且有一个值//此处不知道j//k在这里是已知的，但只有一个值，称为第二个时间循环//我在这里不认识}回路（[1,2,3,4]）；对于（var k=0；k<arr.length；k++）{//我在这里不认识//此处不知道j//k在这里是已知的，并且有一个值//我在这里不认识};for（设l=0；l<arr.length；l++）{//我在这里不认识//此处不知道j//k在这里是已知的，并且有一个值//l在这里是已知的，并且有一个值};回路（[1,2,3,4]）；//我在这里不知名//此处不知道j//k在这里是已知的，并且有一个值//我在这里不认识

在这里，我们可以看到我们的变量j个只在第一个for循环中知道，但在之前和之后都不知道。然而，我们的变量我在整个函数中是已知的。

此外，考虑到块范围的变量在声明之前是未知的，因为它们没有被提升。也不允许在同一块中重新声明同一块范围内的变量。这使得块范围的变量比全局或函数范围的变量更不容易出错，这些变量被提升，并且在多个声明的情况下不会产生任何错误。

---

使用安全吗让今天？

有些人会认为，将来我们将只使用let语句，而var语句将过时。JavaScript专家凯尔·辛普森写的一篇非常详尽的文章，阐述了为什么他认为情况不会如此.

然而，今天的情况绝对不是这样。实际上，我们需要问问自己使用让声明。这个问题的答案取决于您的环境：

• 如果您正在编写服务器端JavaScript代码(节点.js)，您可以安全地使用让声明。

• 如果您正在编写客户端JavaScript代码并使用基于浏览器的transpiler（例如练习者或babel-standalone公司)，您可以安全地使用让语句，但您的代码在性能方面可能不是最佳的。

• 如果您正在编写客户端JavaScript代码并使用基于节点的transpiler（如traceur shell脚本或巴别塔)，您可以安全地使用让声明。而且，由于您的浏览器只知道已传输的代码，因此性能缺陷应该受到限制。

• 如果您正在编写客户端JavaScript代码，并且不使用transpiler，则需要考虑浏览器支持。

  仍有一些浏览器不支持让完全：

---

如何跟踪浏览器支持

有关哪些浏览器支持让阅读此答案时的声明，请参阅这我能用吗第页.

---

（*）全局和功能范围内的变量可以在声明之前进行初始化和使用，因为JavaScript变量悬挂的.这意味着声明总是移动到范围的顶部。

（**）块作用域变量未提升

Answer 4

这里有一个解释让关键字用一些例子。

让工作原理非常类似无功功率，无功功率主要区别在于无功功率，无功功率变量是整个封闭函数

这张桌子维基百科上显示了哪些浏览器支持Javascript 1.7。

请注意，只有Mozilla和Chrome浏览器支持它。IE、Safari和其他可能不支持。

Answer 5

让

块范围

使用让关键字是块范围的，这意味着它们仅在块他们在其中被宣布。

在顶层（函数外部）

在顶层，使用让不要在全局对象上创建属性。

var全局变量=42；让blockScopedVariable=43；console.log（globalVariable）；//42console.log（blockScopedVariable）；//43console.log（this.globalVariable）；//42console.log（this.blockScopedVariable）；//未定义

函数内部

在函数内部（但在块外部），让具有与相同的范围无功功率，无功功率.

(() => {var函数ScopedVariable=42；让blockScopedVariable=43；console.log（functionScopedVariable）；//42console.log（blockScopedVariable）；//43})();console.log（functionScopedVariable）；//ReferenceError:未定义functionScopedVariableconsole.log（blockScopedVariable）；//ReferenceError:未定义blockScopedVariable

在块内

使用声明的变量让块内部不能在该块外部访问。

{var全局变量=42；让blockScopedVariable=43；console.log（globalVariable）；//42console.log（blockScopedVariable）；//43}console.log（globalVariable）；//42console.log（blockScopedVariable）；//ReferenceError:未定义blockScopedVariable

在循环内部

用声明的变量让in循环只能在该循环内引用。

对于（var i=0；i<3；i++）{var j=i*2；}控制台.log（i）；//三控制台.log（j）；//4for（设k=0；k<3；k++）{设l=k*2；}console.log（k类型）；//未定义console.log（l类型）；//未定义//尝试在此处执行console.log（k）或console.log（l）操作会引发ReferenceError。

带闭包的循环

如果您使用让而不是无功功率，无功功率在循环中，每次迭代都会得到一个新变量。这意味着您可以在循环中安全地使用闭包。

//记录三次，不是我们的意思。对于（var i=0；i<3；i++）{setTimeout（（）=>console.log（i），0）；}//按预期记录0、1和2。for（设j=0；j<3；j++）{setTimeout（（）=>console.log（j），0）；}

时间死区

因为时间死区，变量声明使用让在声明之前无法访问。尝试这样做会引发错误。

控制台.log（noTDZ）；//未定义var noTDZ=43；console.log（hasTDZ）；//ReferenceError:未定义hasTDZ设hasTDZ=42；

无需重新申报

不能使用多次声明同一变量让。也不能使用声明变量让与使用声明的另一个变量具有相同的标识符无功功率，无功功率.

变量a；变量a；//效果很好。让b；让b；//语法错误：已声明标识符“b”变量c；让c；//语法错误：标识符“c”已声明

常数

常数非常类似于让-它是块状的，有TDZ。然而，有两件事是不同的。

无重新签名

使用声明的变量常数无法重新分配。

常数a=42；a=43；//TypeError:赋值给常量变量。

注意，这并不意味着该值是不可变的。它的属性仍然可以更改。

常量对象={}；对象a=42；控制台.log（obj.a）；//42

如果您想拥有一个不可变对象，应该使用Object.freeze（）.

const obj=Object.freeze（｛a:40｝）；对象a=42；控制台.log（obj.a）；//40控制台.log（obj.b）；//未定义

需要初始值设定项

在使用声明变量时，始终必须指定值常数.

常数a；//语法错误：常量声明中缺少初始值设定项

Answer 6

接受的答案缺少一点：

{设a=123；};控制台.log（a）；//ReferenceError:未定义a

Answer 7

在最基本的术语中，

for（设i=0；i<5；i++）{//我可以接近✔️}//我不方便❌

---

对于（var i=0；i<5；i++）{//我可以接近✔️}//我可以接近✔️

---

⚡️ 沙盒四处游玩↓

Answer 8

以下是这两者之间的区别示例：

正如你所见变量j变量的值仍在for循环范围（块范围）之外，但让我来吧在for循环范围外未定义变量。

“使用严格”；console.log（“变量：”）；对于（var j=0；j<2；j++）{console.log（j）；}控制台日志（j）；console.log（“let：”）；for（设i=0；i<2；i++）{控制台.log（i）；}控制台.log（i）；

Answer 9

主要区别是范围差异，而让只能在范围它是声明的，就像在for循环中一样，无功功率，无功功率例如，可以在循环外部访问。从中的文档MDN公司（同样来自MDN的示例）：

让允许您声明在其上使用的块、语句或表达式的范围内受限的变量。这与无功功率，无功功率关键字，它全局定义变量，或局部定义整个函数的变量，而不管块范围如何。

声明的变量让将定义它们的块以及任何包含的子块作为其范围。这样，让工作原理非常类似无功功率，无功功率主要区别在于无功功率，无功功率变量是整个封闭函数：

函数varTest（）{变量x=1；if（真）{var x=2；//相同的变量！控制台.log（x）；//2}控制台.log（x）；//2}函数letTest（）{设x=1；if（真）{设x=2；//不同的变量console.log（x）；//2}控制台.log（x）；//1}`

在程序和功能的顶层，让，不像无功功率，无功功率，不在全局对象上创建属性。例如：

var x=“全局”；设y=“全局”；console.log（this.x）；//“全球”console.log（this.y）；//未定义

当在块内使用时，let将变量的作用域限制在该块内。请注意以下各项之间的差异无功功率，无功功率其范围在声明它的函数内。

变量a=1；var b=2；如果（a===1）{变量a=11；//范围是全球性的设b=22；//作用域在if-block中控制台.log（a）；//11控制台.log（b）；//22} 控制台.log（a）；//11控制台.log（b）；//2

另外，不要忘记它的ECMA6功能，所以它还没有完全支持，所以最好总是使用Babel等将其传输到ECMA5…有关访问的更多信息巴贝尔网站

Answer 10

有一些细微的差异-让作用域的行为与其他语言中的变量作用域差不多。

例如，它作用于封闭块，它们在声明之前不存在，等等。

然而值得注意的是让只是较新的Javascript实现的一部分，具有不同程度的浏览器支持.

Answer 11

• 变量未提升

  让将非起重机它们出现在块的整个范围内。相比之下，无功功率，无功功率可按如下方式起吊。

  {console.log（抄送）；//未定义。吊装引起的变异系数cc=23；}{控制台.log（bb）；//ReferenceError:bb未定义设bb=23；}

  实际上，佩尔·贝尔吉，两者都有无功功率，无功功率和让已吊装.

• 垃圾收集

  块范围让与闭包和垃圾收集有关以回收内存非常有用。考虑一下，

  函数过程（数据）{//...}var hugeData={..}；流程（hugeData）；var btn=文档.getElementById（“mybutton”）；btn.addEventListener（“点击”，功能点击（evt）{//....});

  这个点击处理程序回调不需要庞大的数据完全可变。理论上，之后进程（…）运行，巨大的数据结构庞大的数据可能会被垃圾收集。然而，一些JS引擎可能仍然需要保持这种巨大的结构，因为点击函数在整个范围内有一个闭包。

  然而，块范围可以使这个巨大的数据结构被垃圾收集。

  功能过程（数据）{//...}｛//此块内声明的任何内容都可以进行垃圾收集让hugeData={..}；流程（hugeData）；}var btn=文档.getElementById（“mybutton”）；btn.addEventListener（“点击”，功能点击（evt）{//....});

• 让循环

  让循环中可以重新绑定对于循环的每个迭代，请确保重新为其分配上一次循环迭代结束时的值。考虑一下，

  //打印5次对于（var i=0；i<5；++i）{setTimeout（函数（）{控制台.log（i）；}, 1000);  }

  但是，请更换无功功率，无功功率具有让

  //打印1、2、3、4、5。现在for（设i=0；i<5；++i）{setTimeout（函数（）{控制台.log（i）；}, 1000);  }

  因为让创建一个新的词汇环境，其中包含a）initialiser表达式b）每个迭代（在前面计算增量表达式）的名称，更多详细信息如下在这里.

Answer 12

区别在于范围每个变量声明的变量。

实际上，范围上的差异有许多有益的后果：

1. 让变量仅在其最近的封闭块({ ... }).
2. 让变量只能在出现的代码行中使用之后声明变量（即使它们被吊起了!).
3. 让变量不能由后续无功功率，无功功率或让.
4. 全球的让变量未添加到全局窗口对象。
5. 让变量是易于使用带闭包（它们不会导致竟态条件).

由实施的限制让减少变量的可见性，增加早期发现意外名称冲突的可能性。这样可以更容易地跟踪和推理变量，包括可达性（帮助回收未使用的内存）。

因此，让在大型程序中使用变量或以新的、意想不到的方式组合独立开发的框架时，变量不太可能导致问题。

无功功率，无功功率如果您确信在循环中使用闭包（5）或在代码中声明外部可见的全局变量（4）时需要单绑定效果，那么这可能仍然很有用。的使用无功功率，无功功率如果出口从transpiler空间迁移到核心语言。

示例

1.在最近的封闭块外不得使用：此代码块将引发引用错误，因为x个出现在用声明的块之外让:

{设x=1；}console.log（`x是${x}`）；//解析期间ReferenceError:“x未定义”。

相比之下，与无功功率，无功功率作品。

2.申报前不得使用：
此代码块将引发引用错误在代码可以运行之前，因为x个在声明之前使用：

{x=x+1；//解析期间ReferenceError:“x未定义”。设x；console.log（`x是${x}`）；//从不跑步。}

相比之下，与无功功率，无功功率解析和运行时不会引发任何异常。

3.无再次申报：以下代码演示了用声明的变量让以后不能重新声明：

设x=1；设x=2；//语法错误：已声明标识符“x”

4.未附加到的全局窗口:

var button=“我的名字太普通了，所以我会引发事故。”；let link=“虽然我的名字很常见，但我很难从其他JS文件访问。”；console.log（链接）；//好 啊console.log（window.link）；//未定义（好！）console.log（window.button）；//好 啊

5.易于使用，带封口：用声明的变量无功功率，无功功率循环内部的闭包不能很好地工作。下面是一个简单的循环，它输出变量我在不同的时间点具有：

for（设i=0；i<5；i++）{console.log（`i是${i}`），125/*ms*/）；}

具体而言，该输出：

i为0我是1我是2岁我是3岁我是4岁

在JavaScript中，我们使用变量的时间通常比创建变量的时间晚得多。当我们通过将闭包传递给延迟输出来证明这一点时设置超时:

for（设i=0；i<5；i++）{setTimeout（_=>console.log（`i是${i}`），125/*ms*/）；}

…只要我们坚持下去，产量保持不变让相反，如果我们使用变量i而是：

对于（var i=0；i<5；i++）{setTimeout（_=>console.log（`i是${i}`），125/*ms*/）；}

…循环意外输出“i is 5”五次：

我5岁我5岁我5岁我5岁我5岁

Answer 13

这里有一个例子来补充其他人已经写过的东西。假设您想创建一个函数数组，加法器函数，其中每个函数都接受一个Number参数，并返回参数和数组中函数索引的总和。正在尝试生成加法器函数使用循环无功功率，无功功率关键字不会像人们天真地期望的那样起作用：

//一组加法器函数。var加法器函数=[]；对于（var i=0；i<1000；i++）{//我们希望索引i处的函数将索引添加到其参数中。加法器函数[i]=函数（x）{//我在这里要做什么？返回x+i；};}var add12=加法器函数[12]；//哦哦。该函数被绑定到外部作用域中的i，当前为1000。console.log（添加12（8）===20）；//=>假控制台.log（add12（8）===1008）；//=>真的console.log（i）；//=>1000//情况变得更糟了。i=-8；控制台.log（add12（8）===0）；//=>真的

上述过程没有生成所需的函数数组，因为我的范围超出了对于创建每个函数的块。相反，在循环的末尾我在每个函数的闭包中指我中每个匿名函数在循环末尾的值（1000）加法器函数。这根本不是我们想要的：我们现在在内存中有一个由1000个不同函数组成的数组，具有完全相同的行为。如果我们随后更新我，突变将影响所有加法器函数.

但是，我们可以使用让关键词：

//让我们再试一次。//注意：我们正在使用另一个ES6关键字const来表示不需要的值//被重新分配。const和let具有类似的作用域行为。常量加法器函数=[]；for（设i=0；i<1000；i++）{//注意：这次我们使用的是更新的箭头函数语法，但是//使用上一示例中的“function（x）{…”语法//这里不会更改显示的行为。加法器函数[i]=x=>x+i；}const add12=加法器函数[12]；//耶！行为符合预期。console.log（添加12（8）===20）；//=>真的//我的范围没有扩展到for循环之外。console.log（i）；//=>ReferenceError:未定义i

这次，我是每个迭代的反弹对于循环。现在每个函数都保留我在创建函数时，以及加法器函数行为符合预期。

现在，想象一下这两种行为的混合，你可能会明白为什么不建议混合新的行为让和常数和老人在一起无功功率，无功功率在同一脚本中。这样做可能会导致一些非常混乱的代码。

const doubleAdderFunctions=[]；对于（var i=0；i<1000；i++）{常数j=i；双加法器函数[i]=x=>x+i+j；}const add18=双加法器函数[9]；const add24=双加法器函数[12]；//调试这样的情况并不有趣，尤其是当//代码比这个示例中的代码更复杂。控制台.log（add18（24）===42）；//=>假控制台.log（add24（18）===42）；//=>假控制台.log（add18（24）===add24（18））；//=>假console.log（添加18（24）===2018）；//=>假控制台.log（add24（18）===2018）；//=>假控制台.log（add18（24）===1033）；//=>真的控制台.log（add24（18）===1030）；//=>真的

不要让这种事发生在你身上。使用门楣。

注：这是一个教学示例，旨在演示无功功率，无功功率/让循环和函数闭包中的行为也很容易理解。这将是一种可怕的数字相加方式。但是，在其他环境中的现实世界中可能会遇到在匿名函数闭包中捕获数据的通用技术。基督教青年会。

Answer 14

解释摘自我在中等:

提升是一种JavaScript机制，其中包含变量和函数声明被解析器移动到其作用域的顶部在实际的代码执行由JavaScript解释器开始。所以，实际上变量或函数在哪里声明并不重要，它们将无论其范围是否为全局或本地。这意味着

控制台日志（hi）；var hi=“说hi”；

实际上被解释为

var hi=未定义；控制台日志（hi）；hi=“打招呼”；

所以，正如我们刚才看到的，无功功率，无功功率变量正在被提升到顶部它们的作用域，并且正在使用未定义的值进行初始化这意味着我们可以在实际操作之前分配它们的值在代码中这样声明：

hi=“打个招呼”console.log（hi）；//打个招呼变量hi；

关于函数声明，我们可以在像这样声明它们之前调用它们：

sayHi（）；//您好!函数sayHi（）{console.log（'Hi'）；};

另一方面，函数表达式没有被提升，因此我们将得到以下错误：

sayHi（）//输出：“TypeError:sayHi不是函数var sayHi=函数（）{console.log（'Hi'）；};

ES6引入了JavaScript开发人员让和常数关键字。While期间让和常数是块范围的，不起作用范围界定为无功功率，无功功率在讨论他们的起重行为。我们将从末尾开始，JavaScript提升让和常数.

console.log（hi）；//输出：初始化前无法访问“hi”让hi=“hi”；

正如我们在上面看到的，让不允许我们使用未申报的变量，因此解释器显式输出引用错误表明你好之前无法访问变量初始化。如果我们更改以上内容，也会出现相同的错误让到常数

console.log（hi）；//输出：初始化前无法访问“hi”const hi=“嗨”；

因此，最重要的是，JavaScript解析器搜索变量声明和函数，并将它们提升到其范围的顶部在代码执行之前，在内存中为它们赋值如果解释器在执行代码时遇到他们将识别它们，并能够使用它们执行代码赋值。用声明的变量让或常数保持在变量执行开始时未初始化用声明无功功率，无功功率正在使用值初始化未定义.

我添加了这个视觉插图，以帮助更好地理解如何吊装变量和函数保存在内存中

Answer 15

功能VS块范围：

两者之间的主要区别无功功率，无功功率和让是用声明的变量吗无功功率，无功功率是函数作用域.where函数用声明让是块作用域。例如：

函数testVar（）{if（真）{var foo='foo'；}console.log（foo）；}testVar（）；//日志“foo”函数testLet（）{if（真）{设bar=“bar”；}console.log（bar）；}testLet（）；//参考误差//bar的作用域是if语句的块

变量无功功率，无功功率:

当第一个函数测试变量调用变量foo，用声明无功功率，无功功率，仍然可以从外部访问如果声明。此变量foo公司将可用到处在测试变量 功能.

变量让:

当第二个函数testLet测试被称为变量bar，用声明让，只能在如果声明。因为变量是用声明的让是块作用域（其中块是花括号之间的代码，例如如果{},用于{},函数{}).

让变量无法提升：

之间的另一个区别无功功率，无功功率和让是用声明的变量让 不要被吊起来。示例是说明此行为的最佳方式：

变量让 不要获得提升：

console.log（letVar）；设letVar=10；//referenceError，变量未被提升

变量无功功率，无功功率 做吊装：

控制台.log（varVar）；var变量=10；//日志未定义，变量被提升

全球的让无法连接到窗口:

用声明的变量让在全局范围内（即不在函数中的代码）不会作为属性添加到全局范围内窗口对象。例如（此代码在全局范围内）：

var bar=5；设foo=10；console.log（bar）；//日志5console.log（foo）；//日志10console.log（window.bar）；//日志5，添加到窗口对象的变量console.log（window.foo）；//日志未定义，变量未添加到窗口对象

什么时候应该让被过度使用无功功率，无功功率?

使用让结束无功功率，无功功率只要你能，因为它的范围更明确。这减少了处理大量变量时可能发生的潜在命名冲突。无功功率，无功功率当您希望全局变量显式位于窗口对象（如果确实需要，请始终仔细考虑）。

Answer 16

ES6引入了两个新关键字(让和常数)替换为无功功率，无功功率.

当您需要块级减速时，可以使用let和const而不是var。

下表总结了var、let和const之间的差异

Answer 17

让很有趣，因为它允许我们这样做：

(() => {var计数=0；for（设i=0；i<2；++i）{for（设i=0；i<2；++i）{for（设i=0；i<2；++i）{console.log（计数++）；}}}})();

.as-console-wrapper{最大高度：100%！重要；}

这将导致计数[0，7]。

鉴于

(() => {var计数=0；对于（var i=0；i<2；++i）{对于（var i=0；i<2；++i）{对于（var i=0；i<2；++i）{console.log（计数++）；}}}})();

仅计数[0，1]。

Answer 18

看起来，至少在Visual Studio 2015中，TypeScript 1.5“var”允许在一个块中多次声明相同的变量名，而“let”则不允许。

这不会生成编译错误：

var x=1；var x=2；

这将：

设x=1；设x=2；

Answer 19

var-->功能范围let-->块范围const-->块范围

无功功率，无功功率

在这个代码示例中，变量我使用声明无功功率，无功功率。因此，它具有功能范围。这意味着您可以访问我仅从内部函数x。您无法从外部读取函数x

函数x（）{var i=100；控制台.log（i）；//100}console.log（i）；//错误。你不能这么做x（）；

在这个示例中，您可以看到我在内部声明如果块。但它是用无功功率，无功功率因此，它获得了功能范围。这意味着您仍然可以访问变量我里面函数x.因为无功功率，无功功率始终将范围限定为函数。即使变量我在内部声明如果块，因为它正在使用无功功率，无功功率它的作用域是父级函数x.

函数x（）{if（真）{var i=100；}控制台.log（i）；}x（）；

Now变量我在中声明函数y因此，我范围至函数y。您可以访问我里面函数y.但不是从外面函数y.

函数x（）{函数y（）{var i=100；控制台.log（i）；}y（）；}x（）；

函数x（）{函数y（）{var i=100；}console.log（i）；//错误}x（）；

let，常量

let和const具有块作用域。

常数和让行为相同。但不同的是，当您为常数你不能重新设计。但您可以重新设计价值观让.

在本例中，变量我在内部声明如果块。所以只能从内部访问如果块。我们不能从外面进入如果块。（此处常数工作方式与让)

if（真）{设i=100；控制台.log（i）；//输出：100}控制台.log（i）；//错误

函数x（）{if（真）{设i＝100；控制台.log（i）；//输出：100}控制台.log（i）；//错误}x（）；

另一个区别是（let，const）对无功功率，无功功率你可以访问吗无功功率，无功功率在声明之前定义变量。它将为您提供未定义.但如果你这样做让或常数它会给你一个错误。

console.log（x）；var x=100；

控制台.log（x）；//错误设x=100；

Answer 20

无功功率，无功功率是全局范围（可提升）变量。

让和常数是块范围。

测试.js

{设l=“let”；const c=“const”；var v=“var”；v2='var 2'；}console.log（v，this.v）；控制台.log（v2，this.v2）；控制台.log（l）；//ReferenceError:未定义l控制台.log（c）；//ReferenceError:c未定义

Answer 21

如果我当时读了说明书让 谢天谢地也可以用来避免自调用函数用于模拟仅私有成员-一种流行的设计模式会降低代码的可读性，使调试复杂化，不会增加真正的代码保护或其他好处，除非能够满足某人对语义的需求，所以停止使用它。/rant

var SomeConstructor；{让privateScope={}；SomeConstructor=函数SomeConstrator（）{this.someProperty=“foo”；privateScope.hiddenProperty=“bar”；}SomeConstructor.prototype.showPublic=函数（）{console.log（this.someProperty）；//foo公司}SomeConstructor.prototype.showPrivate=函数（）{console.log（privateScope.hiddenProperty）；//酒吧}}var myInstance=新建SomeConstructor（）；myInstance.showPublic（）；myInstance.showPrivate（）；console.log（privateScope.hiddenProperty）；//错误

请参阅“仿真专用接口'

Answer 22

使用时让

这个让关键字将变量声明附加到任意块的范围（通常为{ .. }配对）。换句话说，让隐式劫持任何块的变量声明范围。

让无法在中访问变量窗口对象，因为无法全局访问它们。

函数a（）{{//这是let变量的最大范围设x=12；}控制台.log（x）；}a（）；//未捕获引用错误：未定义x

使用时无功功率，无功功率

无功功率，无功功率ES5中的变量在函数中具有范围，这意味着变量在函数内有效，而不是在函数本身之外有效。

无功功率，无功功率变量可以在窗口对象，因为无法全局访问它们。

函数a（）{//这是var变量的最大范围{ var x=12；}控制台.log（x）；}a（）；//12

如果你想了解更多，请继续阅读以下内容

关于范围的一个最著名的面试问题也可以满足让和无功功率，无功功率如下所示；

使用时让

for（设i=0；i<10；i++）{设置超时(函数a（）{控制台.log（i）//打印0到9，这简直就是AWW！！！}, 100*i）；}

这是因为在使用让，对于每个循环迭代，变量都有作用域，并且有自己的副本。

使用时无功功率，无功功率

对于（var i=0；i<10；i++）{设置超时(函数a（）{控制台.log（i）//打印10乘以10}, 100*i）；}

这是因为在使用无功功率，无功功率，对于每个循环迭代，变量都具有作用域并具有共享副本。

Answer 23

一些黑客让:

1

让统计数据=[16,170,10]；let[年龄、身高、年级]=统计；console.log（高度）

2

设x=120，y=12；[x，y]=[y，x]；控制台.log（`x:${x}y:${y}`）；

三。

设节点={type:“标识符”，名称：“foo”};让{type，name，value}=节点；console.log（类型）；//“标识符”console.log（名称）；//“foo”console.log（值）；//未定义设节点={type:“标识符”};让{type:localType，name:localName=“bar”}=节点；console.log（localType）；//“标识符”console.log（本地名称）；//“酒吧”

吸气剂和setter让:

让jar={Cookie数量：10，获取厨师（）{返回this.numberOfCookies；},设置cookie（值）{this.numberOfCookies=值；}};console.log（jar.cookie）jar.cookies=7；console.log（jar.cookie）

Answer 24

下面显示了“let”和“var”在范围中的不同之处：

设gfoo=123；if（真）{设gfoo=456；}控制台.log（gfoo）；//123var hfoo=123；if（真）{var hfoo=456；}console.log（hfoo）；//456

这个gfoo公司，由定义让最初是在全球范围，当我们宣布gfoo公司再次进入if子句它的范围已更改当一个新值被分配给该范围内的变量时，它不影响全球范围。

鉴于hfoo网络，由定义无功功率，无功功率最初位于全球范围，但当我们在if子句，它考虑了全局范围hfoo，尽管再次使用var来声明它。当我们重新设计其值时，我们看到全局范围hfuo也受到了影响。这是主要区别。

Answer 25

我刚遇到一个必须使用的用例无功功率，无功功率结束让引入新的变量。这里有一个案例：

我想用动态变量名创建一个新变量。

let variableName=“a”；eval（“let”+variableName+'=10；'）；控制台.log（a）；//这不起作用

var variableName='a'；eval（“var”+variableName+'=10；'）；控制台.log（a）；//这个管用

上面的代码不起作用，因为评估引入了一个新的代码块。声明使用无功功率，无功功率将在此代码块之外声明变量，因为无功功率，无功功率声明函数范围中的变量。

让另一方面，在块范围内声明变量。所以，一变量只在中可见评估块。

Answer 26

让vs var。这都是关于范围.

var变量是全局变量基本上到处都可以访问，而让变量不是全局的只有在右括号杀死它们时才存在。

请参阅下面的示例，并注意lion（let）变量在两个console.log中的作用如何不同；它超出了第二个console.log的范围。

var cat=“cat”；let dog=“dog”；var动物=（）=>{var giraffe=“giraffe”；让lion=“lion”；console.log（cat）//将打印“cat”。console.log（dog）//将打印“dog”，因为dog是在此函数之外声明的（如varcat）。console.log（长颈鹿）//将打印“长颈鹿”。console.log（lion）//将打印“狮子”，因为狮子在范围内。}console.log（长颈鹿）//将打印“giraffe”，因为giraffes是一个全局变量（var）。console.log（lion）//将打印UNDEFINED，因为lion是一个“let”变量，现在已超出范围。

Answer 27

现在，我认为使用以下方法可以更好地将变量范围限定到语句块让:

函数printnums（）{//我在这里不方便for（设i=0；i<10；i+=）{控制台.log（i）；}//我在这里不方便//这里可以到达j对于（var j=0；j<10；j++）{console.log（j）；}//这里可以到达j}

我认为人们会在以后开始使用let，以便在JavaScript中使用类似于其他语言、Java、C#等的作用域。

人们对JavaScript中的作用域没有明确的理解，这是早先犯下的错误。

不支持使用让.

通过这种方法，JavaScript中的错误将被删除。

请参阅ES6深入：let和const以便更好地理解它。

Answer 28

如上所述：

区别在于范围界定。无功功率，无功功率范围最接近功能块和让作用域为最近的封闭块，其中可以小于功能块。如果在任何外部，两者都是全局的块。让我们看一个例子：

示例1：

在我的两个例子中，我都有一个函数我的函数.我的函数包含一个变量米瓦尔等于10。在我的第一个示例中，我检查了米瓦尔等于10(myvar==10) . 如果是，我可以声明一个变量米瓦尔（现在我有两个myvar变量）使用无功功率，无功功率关键字并为其分配一个新值（20）。在下一行中，我在控制台上打印它的值。在条件块之后，我再次打印米瓦尔在我的控制台上。如果您查看的输出我的函数,米瓦尔值等于20。

示例2：在我的第二个示例中，而不是使用无功功率，无功功率我声明的条件块中的关键字米瓦尔使用让关键字。现在我打电话的时候我的函数我得到两种不同的输出：myvar=20和myvar=10.

因此，区别很简单，即其范围。

Answer 29

我想将这些关键字链接到执行上下文，因为执行上下文在所有这一切中都很重要。执行上下文有两个阶段：创建阶段和执行阶段。此外，每个执行上下文都有一个可变环境和外部环境（其词汇环境）。

在执行上下文的创建阶段，var、let和const仍会将其变量存储在内存中，并在给定执行上下文的变量环境中使用未定义的值。区别在于执行阶段。如果在给变量赋值之前引用用var定义的变量，那么它就是未定义的。不会引发任何异常。

但是，在声明变量之前，不能引用用let或const声明的变量。如果尝试在声明之前使用它，则在执行上下文的执行阶段将引发异常。现在，由于执行上下文的创建阶段，变量仍在内存中，但引擎不允许您使用它：

函数a（）{b；让b；}a（）；>Uncaught ReferenceError:b未定义

对于用var定义的变量，如果引擎在当前执行上下文的变量环境中找不到该变量，那么它将向上进入范围链（外部环境）并检查外部环境的变量环境。如果在那里找不到它，它将继续搜索作用域链。let和const的情况并非如此。

let的第二个特点是它引入了块范围。块由花括号定义。示例包括功能块、if块、用于块等。当使用块内的let声明变量时，该变量仅在块内可用。事实上，每次运行块时，例如在for循环中，它都会在内存中创建一个新变量。

ES6还引入了用于声明变量的const关键字。const也是块范围的。let和const的区别在于，const变量需要使用初始值设定项声明，否则会生成错误。

最后，当涉及到执行上下文时，用var定义的变量将附加到“this”对象。在全局执行上下文中，这将是浏览器中的窗口对象。let或const的情况并非如此。

Answer 30

由于我目前正试图深入了解JavaScript，我将与大家分享我的简短研究，其中包括一些已经讨论过的优秀作品，以及其他一些不同角度的细节。

了解两者之间的差异无功功率，无功功率和让如果我们能理解功能和块式示波器.

让我们考虑以下情况：

（函数计时器（）{对于（var i=0；i<=5；i++）{setTimeout（函数notime（）{console.log（i）；}，i*1000）；}})();Stack VariableEnvironment//timer（）的一个Variable环境；//当计时器超时时，每个迭代的值都是相同的5.[设置超时，i][i=5]4.[设置超时，i]3.[设置超时，i]2.[设置超时，i]1.[设置超时，i]0.[设置超时，i]####################    （函数计时器（）{for（设i=0；i<=5；i++）{setTimeout（函数notime（）{console.log（i）；}，i*1000）；}})();Stack LexicalEnvironment-每个迭代都有一个新的词汇环境5.[设置超时，i][i=5]词汇环境4.[设置超时，i][i=4]词汇环境3.[设置超时，i][i=3]词汇环境2.[设置超时，i][i=2]词汇环境1.[setTimeout，i][i=1]词汇环境0.[设置超时，i][i=0]

什么时候计时器（）被称为执行上下文将同时包含可变环境以及所有词汇环境对应于每个迭代。

还有一个简单的例子

功能范围

功能测试（）{对于（var z=0；z<69；z++）{//托多}//z在循环外可见}

块范围

功能测试（）{for（设z=0；z<69；z++）{//待办事项}//z未定义：(}

简单地说，let和var的区别在于var是函数范围的，let是块范围的。