天道酬勤,学无止境

for 循环中 counter 变量的作用域是什么?(What is the scope of the counter variable in a for loop?)

问题

我在 Visual Studio 2008 中收到以下错误:

Error 1 A local variable named 'i' cannot be declared in this scope because it would give a different meaning to 'i', which is already used in a 'child' scope to denote something else

这是我的代码:

for (int i = 0; i < 3; i++)
{
  string str = "";
}

int i = 0; // scope error
string str = ""; // no scope error

我知道一旦循环终止str就不再存在,但我也认为i的范围也仅限于for循环。

所以i与在for循环之外声明的变量具有相同的作用域?

编辑:

为了清楚起见,我使用的是 C#。 我正在讨论删除“C”标签。 但是,由于正确答案解释了两者之间的区别,我认为保留两个标签是有意义的。

我在上面的代码注释中有一个错误:

for (int i = 0; i < 3; i++)
{
  string str = "";
}

int i = 0; // scope error
string str = ""; // also scope error,
                 // because it's equivalent to declaring
                 // string str =""; before the for loop (see below)
回答1

我认为你们都混淆了 C++ 和 C#。

在 C++ 中,过去在 for 表达式中声明的变量的作用域在它后面的块之外。 这在前段时间发生了变化,因此在 for 表达式中声明的变量的范围在它后面的块的内部。 C# 遵循这种后面的方法。 但两者都与此无关。

这里发生的事情是 C# 不允许一个作用域在外部作用域中隐藏具有相同名称的变量。

所以,在 C++ 中,这曾经是非法的。 现在是合法的。

for (int i; ; )
{
}
for (int i; ; )
{
}

同样的事情在 C# 中也是合法的。 有三个作用域,其中未定义“i”的外部作用域和两个子作用域,每个作用域都声明了自己的“i”。

但你正在做的是:

int i;
for (int i; ; )
{
}

这里有两个作用域。 一个外层声明了一个“i”,一个内层也声明了一个“i”。 这在 C++ 中是合法的——外部的“i”是隐藏的——但在 C# 中是非法的,无论内部作用域是 for 循环、while 循环还是其他什么。

试试这个:

int i;
while (true)
{
    int i;
}

这是同样的问题。 C# 不允许在嵌套作用域中具有相同名称的变量。

回答2

在 for 循环之后增量器不存在。

for (int i = 0; i < 10; i++) { }
int b = i; // this complains i doesn't exist
int i = 0; // this complains i would change a child scope version because the for's {} is a child scope of current scope

您不能在 for 循环之后重新声明 i 的原因是因为在 IL 中它实际上会在 for 循环之前声明它,因为声明发生在范围的顶部。

回答3

是的。 语法上:新范围位于由卷曲字符串定义的块内。 功能上:在某些情况下,您可能想要检查循环变量的最终值(例如,如果您中断)。

回答4

只是一些背景信息:序列没有出现。 只有作用域的概念——方法作用域,然后是for循环的作用域。 因此,“一旦循环终止”是不准确的。

因此,您发布的内容与此相同:

int i = 0; // scope error
string str = ""; // no scope error

for (int i = 0; i < 3; i++)
{
  string str = "";
}

我发现这样思考会让答案更“适合”我的心智模型。

标签

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 在if语句中初始化的变量的作用域是什么?(What's the scope of a variable initialized in an if statement?)
    问题 我是Python的新手,所以这可能是一个简单的范围界定问题。 Python文件(模块)中的以下代码使我有些困惑: if __name__ == '__main__': x = 1 print x 在我使用过的其他语言中,此代码将引发异常,因为x变量位于if语句本地,并且不应在其外部存在。 但是此代码将执行并打印1。有人可以解释此行为吗? 是否在模块中创建的所有变量都是全局的/可用于整个模块? 回答1 Python变量的作用域是分配给它们的最里面的函数,类或模块。 控制块(如if和while块)不计数,因此在if内分配的变量仍作用于函数,类或模块。 (由生成器表达式或list / set / dict理解定义的隐式函数与lambda表达式一样进行计数。您不能将赋值语句填充到其中任何一个中,但是lambda参数和for子句目标是隐式赋值。) 回答2 是的,它们在同一个“本地范围”中,实际上这样的代码在Python中很常见: if condition: x = 'something' else: x = 'something else' use(x) 请注意, x不会在条件之前声明或初始化,例如在C或Java中。 换句话说,Python没有块级作用域。 不过,请注意以下示例 if False: x = 3 print(x) 这显然会引发NameError异常。 回答3
  • 范围和块之间有什么区别?(What is the difference between scope and block?)
    问题 我在书中看到了一段代码,内容如下: x = 10; if(x ==10) { // start new scope int y = 20; // known only to this block x = y * 2; } 范围和块都一样吗? 回答1 作用域是您可以引用变量的地方。 块定义了block scope仅在该块内部定义了在块内部定义的变量,并且在块结束后不能引用该变量。 因此,在这段代码中,如果您尝试执行以下操作: x = 10; if(x ==10) { // start new scope int y = 20; // known only to this block x = y * 2; } y = 5; // error y is out of scope, not it is not defined 因为这里有本地范围 Java中的其他作用域是class scope (例如),类的成员具有类作用域,因此可以在类内部的任何地方访问它。 范围的基本规则是: 参数声明的范围是该声明在其中出现的方法的主体。 局部变量声明的范围是从声明出现的位置到该块的末尾。 在for语句的标头的初始化部分中出现的局部变量声明的范围是for语句的主体以及标头中的其他表达式。 方法或字段的范围是类的整个主体。 这使类的非静态方法可以使用该类的字段和其他方法。 回答2
  • C语言中完整的“ for”循环语法是什么?(What is the full “for” loop syntax in C?)
    问题 在阅读其他人的代码时,我看到了一些非常奇怪for循环。 我一直在尝试为C中的for循环搜索完整的语法说明,但是这非常困难,因为“ for”一词出现在无关的句子中,这使得Google几乎无法进行有效的搜索。 阅读此主题后,这个问题浮现在脑海,这让我再次感到好奇。 在for这里: for(p=0;p+=(a&1)*b,a!=1;a>>=1,b<<=1); 在中间条件下,有一个逗号分隔两段代码,这个逗号是做什么的? 我理解右边的逗号,因为它使a>>=1和b<<=1 。 但是在循环退出条件下,会发生什么? 当p==0时, a==1或两者同时发生时,它是否退出? 如果有人可以帮助我理解这一点,或者使我指向完整的for循环语法说明,那将是很好的。 回答1 逗号不排除for循环; 它是逗号运算符。 x = (a, b); 将首先执行a,然后执行b,然后将x设置为b的值。 for语法为: for (init; condition; increment) ... (在某种程度上(暂时忽略continue和break ))等效于: init; while (condition) { ... increment; } 因此,您的for循环示例等效于(再次忽略continue和break ) p=0; while (p+=(a&1)*b,a!=1) { ... a>>=1,b<<=1; }
  • C#中的lambda变量的作用域是什么?(What is the scope of a lambda variable in C#?)
    问题 我对lambda变量的范围感到困惑,例如以下内容 var query = from customer in clist from order in olist .Where(o => o.CustomerID == customer.CustomerID && o.OrderDate == // line 1 olist.Where(o1 => o1.CustomerID == customer.CustomerID) // line 2 .Max(o1 => o1.OrderDate) // line 3 ) select new { customer.CustomerID, customer.Name, customer.Address, order.Product, order.OrderDate }; 在第1行中,我声明了一个lambda变量'o',这意味着我无法在第2行中再次声明它(或者如果我尝试,至少编译器会抱怨),但是即使'o1'已经存在,它也不会抱怨第3行?? lambda变量的范围是什么? 回答1 方括号给出了线索​​-在声明变量的范围内捕获了lambda变量: .Where(o => ... olist.Where(o1 => ...).Max(o1 => ...)) // |----------------------------------------
  • JavaScript闭包与匿名函数(JavaScript closures vs. anonymous functions)
    问题 我的一个朋友和我目前正在讨论JS中的闭包,什么不是闭包。 我们只想确保我们真正正确地理解了它。 让我们来看这个例子。 我们有一个计数循环,并希望延迟在控制台上打印counter变量。 因此,我们使用setTimeout和闭包来捕获计数器变量的值,以确保它不会输出N倍于值N的值。 没有闭包或接近闭包的错误解决方案是: for(var i = 0; i < 10; i++) { setTimeout(function() { console.log(i); }, 1000); } 这当然会在循环后输出i 10倍的值,即10。 因此,他的尝试是: for(var i = 0; i < 10; i++) { (function(){ var i2 = i; setTimeout(function(){ console.log(i2); }, 1000) })(); } 按预期打印0到9。 我告诉他,他没有使用闭包捕获i ,但他坚持认为自己是。 我通过将for循环体放在另一个setTimeout (将他的匿名函数传递给setTimeout )中,再次打印10乘10来证明他没有使用闭包。 如果我将他的函数存储在var并在循环后执行它,并打印10次,则同样适用。所以我的观点是他并没有真正捕获i的值,因此他的版本不是闭包。 我的尝试是: for(var i = 0; i < 10; i++)
  • Javascript/ECMAScript 中函数的作用域是什么?(What is the scope of a function in Javascript/ECMAScript?)
    问题 今天和一位同事讨论了 JavaScript 中的嵌套函数: function a() { function b() { alert('boo') } var c = 'Bound to local call object.' d = 'Bound to global object.' } 在这个例子中,试验指出 b 在 a 的主体之外是不可到达的,就像 c 一样。 但是, d 是 - 在执行 a() 之后。 在 ECMAScript v.3 标准中寻找这种行为的确切定义,我没有找到我正在寻找的确切措辞; Sec.13 p.71 没有说,就是函数声明语句创建的函数对象要绑定到哪个对象上。 我错过了什么吗? 回答1 这是静态范围。 函数内的语句在该函数内的作用域内。 然而,Javascript 有一个奇怪的行为,那就是如果没有var关键字,您就隐含了一个全局变量。 这就是你在测试中看到的。 你的“d”变量是可用的,因为它是一个隐含的全局变量,尽管它是写在函数体内的。 另外,要回答问题的第二部分:函数存在于它声明的任何范围内,就像变量一样。 旁注:您可能不想要全局变量,尤其是不想要的隐含变量。 建议您始终使用 var 关键字,以防止混淆并保持一切整洁。 旁注: ECMA 标准可能不是找到有关 Javascript 答案的最有用的地方,尽管它肯定不是一个糟糕的资源。 请记住
  • 如何通过c:set将参数传递给jsp:include? JSP中变量​​的作用域是什么?(How to pass parameter to jsp:include via c:set? What are the scopes of the variables in JSP?)
    问题 我在welcome.jsp上有这个 <c:set var="pgTitle" value="Welcome"/> <jsp:include page="/jsp/inc/head.jsp" /> 而在head.jsp中: <title>Site Name - ${pgTitle}</title> 但是变量为空,输出仅为 Site Name - 我已经阅读了许多文章,但我无法弄清楚问题出在哪里。 如果我在同一welcome.jsp中的其他位置回显${pgTitle} ,则输出正常。 我在两个页面上都包含了核心标签库。 回答1 这是因为pgTitle变量是在页面范围内设置的。 在这里检查(很抱歉,我无法获得官方文档)。 如果要执行此操作,则必须至少在请求范围内设置变量。 要在请求范围内设置变量,请使用<c:set>上的scope属性: <c:set var="pgTitle" value="Welcome" scope="request" /> 根据您的评论,在Web开发中,变量的范围很重要,因为它定义了变量的使用位置(类似于在类中声明为字段的变量和在方法中局部声明的变量)。 JSP中有四个范围称为上下文: 页面范围(由PageContext处理)。 仅当在当前页面中将其设置为属性时,才能访问变量。 这意味着,只有当前页面可以访问这些属性,包含的页面是不同的页面
  • 范围和块(Scopes and blocks)
    问题 在 ruby​​ 中, module 、 class和def关键字定义了一个新的范围。 我很困惑为什么块中定义的局部变量不存在于块之外。 块参数是另一个作用域门吗? 例如: (1..2).each { |n| numer = 'czesc' } numer # => NameError: undefined local variable or method `czesc' for main:Object 或者更简单: def kon; end kon { kot = 3 } kot # => NameError: undefined local variable or method `kot' for main:Object 我想,也许它没有持久化,因为它是在方法的参数中定义的,但以下内容适用于普通参数: def pokaz(cos) p cos end pokaz(co = "to") co # => "to" 回答1 在 ruby​​ 中, module 、 class和def关键字定义了一个新的范围。 Ruby 中有六个作用域结构:模块体、类体、方法体和脚本体创建新的作用域,块体和“stabby lambda”文字体创建新的嵌套作用域。 我很困惑为什么块中定义的局部变量不存在于块之外。 因为块体有自己的词法作用域。 作用域是嵌套的,这意味着它可以从外部作用域访问局部变量
  • 在for循环中声明的变量范围(Scope of variable declared in for loop)
    问题 让我解释一下疑问。 我在main方法内部有一个int i = 9 。 现在我在相同的main方法中有for循环。看下面的例子 class Test { public static void main(String... args) throws Exception{ int i =39; for (int i = 0; i < 10; i++) { // error:i already defined } } } 对于上面的示例,它显示了i已经被定义的编译时错误。从这个错误中,我认为声明为for条件的i的范围也在循环之外。 现在看下面的例子 class Test { public static void main(String... args) throws Exception{ for (int i = 0; i < 10; i++) { } System.out.println(i); // error: cannot find symbol i } } 在上面的示例中,它在for循环外部显示了找不到符号i的错误。 如果找不到,则在for循环条件中声明我。那么为什么显示i已在第一个示例中定义 回答1 按照块的定义 块是平衡括号之间的零个或多个语句的组,可在允许单个语句的任何地方使用。 所以 { //block started } //block ended
  • 在node.js中存储模块变量的范围是什么?(In what scope are module variables stored in node.js?)
    问题 当我在node.js模块中执行此操作时: var abc = '123'; 去哪儿了? 我的意思是:在浏览器中,它进入window.abc (如果未在函数中执行或以其他方式执行) 如果我执行此操作: abc = '123'; 然后我可以在global.abc找到它,但这不是我想要的。 回答1 与浏览器不同,在浏览器中,默认情况下将变量分配给全局空间(即窗口),而在Node中,除非您将变量显式分配给module.exports,否则变量的作用域是模块(文件)。 实际上,当您运行node myfile.js或require('somefile.js') ,文件中的代码将按以下方式包装: (function (exports, require, module, __filename, __dirname) { // your code is here }); 回答2 所有其他答案都是100%正确的,但我想我会在Node.js应用程序中添加一个扩展的/确定的范围列表,以防万一有人通过Google接触到这一点,同时又开始学习Node.js或JavaScript: 全球范围 任何在任何文件中未使用var关键字声明的内容,都可以从在节点服务器的同一实例中运行的任何位置进行访问: // foo.js bar = 'baz'; // qux.js console.log(bar); //
  • 细说 javascript 中变量声明 var、let、const 的区别
    变量声明,每种编程语言必不可少的语法,在javascript中,变量的声明相对其他语言来说,算是比较简单的。 作用域(Scope)是什么作用域是程序的执行环境,它包含在当前位置可访问的变量和函数。在 ES5 语法中,有全局作用域和局部作用域,ES6 则新增了块级作用域。全局作用域是最外层的作用域,在函数外面定义的变量属于全局作用域,可以被任何其他子作用域访问。在浏览器中,window 对象就是全局作用域。在编写前端代码过程中,其中有一条优化规则就是少使用全局变量,因为全局变量容易导致程序BUG,并且不容易查找。局部作用域的基本单元是 function,只在函数体内有效。局部作用域是在函数内部的作用域。在局部作用域定义的变量只能在该作用域以及其子作用域被访问。javascript中,变量声明使用 var、const、let 来声明变量,var 为ES5的语法,const和let为ES6之后的语法。ES6 的 let 和 const 为新引入的关键字,它们不会被提升,而且是块作用域。也就是说被大括号包围起来的区域声明的变量外部将不可访问。下面我们就来说说各自的区别。 var 声明var 声明,为ES5的语法,var 声明的变量总是归属于包含函数(即全局,如果在最顶层的话)。在 javaScript 函数内部声明的变量(使用 var)是局部变量,所以只能在函数内部访问它
  • JS变量和函数式编程-var、let、const、全局变量、局部变量、块级作用域、循环作用域
    变量 变量作用域 全局变量 在函数外声明的变量作用域是全局的 全局变量在 JavaScript 程序的任何地方都可以访问 var carName = "Volvo"; // 这里可以使用 carName 变量 function myFunction() { // 这里也可以使用 carName 变量 } 函数内的局部变量 在函数内声明的变量作用域是局部的(函数内) 函数内使用** var** 声明的变量只能在函数内访问,如果不使用 var 则是全局变量。 // 这里不能使用 carName 变量 function myFunction() { var carName = "Volvo"; // 这里可以使用 carName 变量 } // 这里不能使用 carName 变量 块级作用域 使用 var 关键字声明的变量不具备块级作用域的特性,它在 {} 外依然能被访问到。 { var x = 2; } // 这里可以使用 x 变量 在 ES6 之前,是没有块级作用域的概念的。 ES6 可以使用 let 关键字来实现块级作用域。 let 声明的变量只在 let 命令所在的代码块 {} 内有效,在 {} 之外不能访问。 { let x = 2; } // 这里不能使用 x 变量 循环作用域 使用 var 关键字 使用 var 关键字,它声明的变量是全局的,包括循环体内与循环体外 var
  • 详解javascript变量作用域、匿名函数及闭包
    一、JavaScript变量作用域(scope)首先需要明白的几个要点:1.JavaScript的变量作用域是基于其特有的作用域链的。2.JavaScript没有块级作用域。3.函数中声明的变量在整个函数中都有定义。(就后面第三点的说明)4 .所有在最外层定义(非函数体内定义)的变量都拥有全局作用域所有末定义直接赋值的变量,系统会自动声明为拥有全局作用域的变量所有window对象的属性拥有全局作用域(下面作者还提到全局变量都可以通过window.*来访问,明白这一点很重要,但是否准确?此外目前存在的疑问还有:即使可以以这中方式来访问全局变量那是否能认为全局对象由window来统一管理,还是window只是保存了一个拷贝而已?)1.JavaScript的作用域链首先看一个很简单的例子,下面的代码中,定义一个全局变量n,n的作用域是全局的。<script language="javascript" type="text/javascript"> var n=1; function show(){ var m=2; alert(n); //显示结果为1 } show(); </script>运行代码后,结果为1。原理就是JavaScript作用域是层层包含的,外层的作用域在内层有效,执行的时候,从内层向外层查找。当函数show执行的时候,首先在函数show内部查找变量n,没有找到
  • JavaScript变量作用域链闭包this指向
    变量 作用域 作用域链 闭包 this 变量:作用往内存中存储数据 为什么有作用域? 因为变量需要运行环境;这个环境我们叫做作用域 1:全局作用域咋浏览器或者程序刚开始运行时候产生的。 2:全局作用域销毁:在关闭浏览器或者关闭程序时。 所以:我们声明的全局变量;都是window 对象下的属性, 所以:js 中最大的对象是window,所有的数据在window下活跃, 所以:全局作用域中最大的对象就是window 每次改变变量的值,都是给window 属性重新赋值。 window 属性为声明的变量 或者定义的函数名字。 变量与函数名字是如何成为window 下的属性的? 因为js 运行经过三个阶段: 1:语言分析 2:预编译 在全局作用域形成之初,预编译会创建GO对象;也是全局先将所有声明的变量;提升到作用域最顶端。在将所有定义的函数,提升到作用域的顶端 并赋值为 函数在堆中指针 注意: 变量声明先提升;然后函数定义在提升。所用的变量用值;都是使用最近的一次赋值。 ----> 所以经过预编译后;变量和函数名字就成为了window的属性 3:解析执行 每执行一行代码:都会对window下的属性进行重新赋值 —> 也就是数据发生的改变 作用域分类 全局作用域: window 对象下是最大的作用域其他的作用域都必须在全局作用域下 局部作用域因为函数体中有声明的变量,函数在执行时候
  • 在R中如何使用“ <<-”(作用域分配)?(How do you use “<<-” (scoping assignment) in R?)
    问题 我刚读完R入门中有关范围定义的内容,并对<<-分配感到非常好奇。 手册显示了<<-一个(非常有趣的)示例,我认为我能理解。 我仍然缺少的是什么时候有用的上下文。 因此,我很想从您那里读到一些示例(或示例的链接),这些示例说明何时使用<<-可能很有趣/有用。 使用它可能会有什么危险(看起来很容易松动),以及您可能想共享的任何提示。 回答1 <<-与闭包一起维护状态最有用。 这是我最近的一篇文章的一部分: 闭包是由另一个函数编写的函数。 闭包之所以称为闭包,是因为它们封闭了父函数的环境,并且可以访问该函数中的所有变量和参数。 这很有用,因为它允许我们具有两个级别的参数。 一级参数(父级)控制函数的工作方式。 另一个级别(孩子)负责这项工作。 以下示例显示了如何使用该思想生成幂函数系列。 父函数( power )创建实际上完成艰苦工作的cube ( square和cube )。 power <- function(exponent) { function(x) x ^ exponent } square <- power(2) square(2) # -> [1] 4 square(4) # -> [1] 16 cube <- power(3) cube(2) # -> [1] 8 cube(4) # -> [1] 64 通过在两个级别上管理变量的能力
  • forEach 循环内的 JavaScript 变量范围(JavaScript variable scope inside forEach loop)
    问题 在下面的代码中,有一个回调函数用于 forEach 循环遍历返回的结果。 forEach 循环中的变量 'error' 和回调中的变量'error' 是否相同? session.getAll(options, function (error, varbinds) { varbinds.forEach(function (vb) { if (error) console.log('getALL Fail '); else console.log(vb.value); }); }); 回答1 是的,它是同一个变量。 我不确定你知道多少。 所以,我要详细解释一下。 JavaScript 中的作用域是在函数级别*。 将函数定义视为树上的点。 树上的每个点都是一个范围。 使用变量时,您只能使用当前范围内的内容以及向上到顶部(全局范围)的祖先可用的任何内容。 以下是一些规则和示例,可以帮助您更好地理解: *更新:ES6 const和let是块级的 内部函数可以访问外部函数级变量 function a() { var a = 4; function b() { alert(a); /* a = 4 */ } } 参数定义在相同的范围内,就好像它们在下面一行定义一样 function a(a) { // variable "a" is at same scope as the example
  • 循环内的JavaScript闭合–简单的实际示例(JavaScript closure inside loops – simple practical example)
    问题 var funcs = []; // let's create 3 functions for (var i = 0; i < 3; i++) { // and store them in funcs funcs[i] = function() { // each should log its value. console.log("My value: " + i); }; } for (var j = 0; j < 3; j++) { // and now let's run each one to see funcs[j](); } 它输出以下内容: 我的价值:3 我的价值:3 我的价值:3 而我希望它输出: 我的值:0 我的价值:1 我的价值:2 当由于使用事件侦听器而导致功能运行延迟时,会发生相同的问题: var buttons = document.getElementsByTagName("button"); // let's create 3 functions for (var i = 0; i < buttons.length; i++) { // as event listeners buttons[i].addEventListener("click", function() { // each should log its value. console
  • 变量“ a”的范围是什么?(What is the scope of the variable “a”?)
    问题 可能重复: Python变量范围问题 Python手册将范围定义为: 范围定义了块中名称的可见性。 如果在块中定义了局部变量,则其范围将包括该块。 如果定义发生在功能块中,则范围将扩展到定义块中包含的任何块,除非所包含的块为名称引入了不同的绑定。 我有这个程序: import random def f(): a = "Is the scope static?" if random.randint(0, 1) == 1: del a print a 打印失败的可能性为50%: >>> f() Is the scope static? >>> f() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 5, in f UnboundLocalError: local variable 'a' referenced before assignment 这样,我认为打印语句有50%的可能性不在'a'的范围内,但我可能是错的。 Python中范围的“正确”解释是什么? Python中变量的范围是静态定义的吗? 变量“ a”的范围是什么? 回答1 名称a的范围覆盖整个函数f ,并且纯粹是静态的。 这是不是在所有正确的说,“有50
  • 为什么 Coffeescript 认为阴影是一个坏主意(Why is Coffeescript of the opinion that shadowing is a bad idea)
    问题 我想切换到 Coffeescript 有一段时间了,昨天我以为我终于被卖了,但后来我偶然发现了 Armin Ronachers 文章关于在 Coffeescript 中的阴影。 Coffeescript 现在确实放弃了阴影,这个问题的一个例子是,如果您对嵌套循环使用相同的迭代器。 var arr, hab, i; arr = [[1, 2], [1, 2, 3], [1, 2, 3]]; for(var i = 0; i < arr.length; i++){ var subArr = arr[i]; (function(){ for(var i = 0; i < subArr.length; i++){ console.log(subArr[i]); } })(); } 因为 cs 仅在我无法在 coffeescript 中执行此操作时才声明变量 阴影已被有意删除,我想了解为什么 cs-authors 想要摆脱这样的功能? 更新:这是一个更好的示例,说明为什么阴影很重要,源自 github 上有关此问题的问题 PS:我不是在寻找一个答案,告诉我我可以插入带有反引号的普通 Javascript。 回答1 如果你阅读了关于这张票的讨论,你会看到 CoffeeScript 的创造者 Jeremy Ashkenas 解释了禁止显式阴影之间的一些推理: 我们都知道,与词法作用域相比
  • JavaScript 中的文档是什么?它的作用域是什么?(What is document in JavaScript and what is its scope?)
    问题 var document = "temp"; function showDocument() { alert(document); // temp or HTML DOM Document } 它为我显示了“HTML DOM 文档”,应该是这样。 它是一个对象、保留关键字、只读对象吗? 如果它是一个对象,它应该是可编辑的。 如果它是一个保留关键字,JavaScript 应该抛出一个错误/异常。 如果它是只读的,我如何修改只能通过document访问的 DOM 本身? 回答1 它是全局 ( window ) 对象的只读属性。 它的值是一个表示当前 HTML/XML/加载到窗口中的任何文档的本机对象。 要修改 DOM,请使用 DOM 操作 API。 编辑——澄清一下, window对象的“document”属性(或者,如果你喜欢,称为“document”的全局变量)本身是不可变的,它的值不能被 JavaScript 更改。 然而,该值是对对象的引用,该对象在各种方面都是可变的。