该代码记录6，共6次：

(function timer() {
  for (var i=0; i<=5; i++) {
    setTimeout(function clog() {console.log(i)}, i*1000);
  }
})();

但是这段代码...

(function timer() {
  for (let i=0; i<=5; i++) {
    setTimeout(function clog() {console.log(i)}, i*1000);
  }
})();

...记录以下结果：

0
1
2
3
4
5

为什么？

是因为let将每个项目绑定到内部范围的方式不同，而var保留了i的最新值吗？

func main(){
     var array [10]int
     sliceA := array[0:5]
     append(sliceA, 4)
     fmt.Println(sliceA)
}

错误：已评估但未使用append（sliceA，4）

不知道为什么 切片附加操作未运行...

我想对Swift的某些属性使用惰性初始化。我当前的代码如下所示：

lazy var fontSize : CGFloat = {
  if (someCase) {
    return CGFloat(30)
  } else {
    return CGFloat(17)
  }
}()

事实是，一旦设置fontSize，它就永远不会改变。所以我想做这样的事情：

lazy let fontSize : CGFloat = {
  if (someCase) {
    return CGFloat(30)
  } else {
    return CGFloat(17)
  }
}()

这是不可能的。

仅此有效：

let fontSize : CGFloat = {
  if (someCase) {
    return CGFloat(30)
  } else {
    return CGFloat(17)
  }
}()

所以-我想要一个可以延迟加载但永远不会改变的属性。正确的方法是什么？ 使用let并忘记了懒惰的init？ 还是我应该使用lazy var而不考虑物业的固定性质？

也许很简单的问题。

我应该在JavaScript中的哪里使用var关键字。 在我看来，使用它是否有相同的效果（但是我仍然在学习语言）

例如，这两个对我来说似乎是相同的：

(function(){
  var a = "mundo"
  alert("Hola, " + a )
})()

和

(function(){
  a = "mundo"
  alert("Hola, " + a )
})()

但是，当然必须有一个更复杂的例子来显示差异。

我在控制台中遇到bar.boy()的问题，在该控制台中尝试输出函数本身可以工作，但不能输出变量或常量。

如您在此处看到的，尽管您认为var / let包含bar.boy()的内容，但是Swift却以某种方式找不到它...

给出以下代码：

string someString = null;
switch (someString)
{
    case string s:
        Console.WriteLine("string s");
        break;
    case var o:
        Console.WriteLine("var o");
        break;
    default:
        Console.WriteLine("default");
        break;
}

为什么switch语句匹配case string s？

据我所知，case string s与s == null不匹配，因为（有效）(null as string) != null的评估结果为false。 VS Code上的智能感知告诉我o也是string。 有什么想法吗？

类似于：C＃7切换案例，带有空检查

我是Clojure的新手，你能不能给我解释现实场景。 我的意思是，在哪里使用Ref，Var，Agent，Atom。 我读过书，但是，仍然无法理解现实世界的例子。

是否有一个VB.NET等同于C＃var关键字？

我想用它来检索LINQ查询的结果。

我刚刚开始在Visual Studio中使用ReSharper（在关于SO的许多建议之后）。 为了试一试，我打开了一个最近的ASP.NET MVC项目。 我注意到它提出的第一个也是最常见的事情之一就是将我的大部分/全部显式声明改为int。 例如：

//From This:
MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);
//To This:
var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

等等，即使是简单的类型，如int,bool等。

为什么要推荐这个？ 我不是来自计算机科学或.NET背景，最近“陷入”.NET开发，所以我真的很想了解正在发生的事情以及它是否有益。

之前我问过一个问题，为什么我看到这么多的例子都使用了var关键字并得到了答案，虽然它只是匿名类型所必需的，但仍然使用它来使代码“更快”/更容易和“只是因为”。

在这个链接（“C＃3.0 - Var不是Objec”）之后，我看到var被编译成IL中的正确类型（你会在中间的文章中看到它）。

我的问题是IL代码在使用var关键字时会有多少（如果有的话），如果在任何地方使用它，它是否会接近于代码性能的可衡量水平？

在C＃中使用var关键字是隐式类型声明。 var的Java等价语法是什么？

因此，在PHPDoc中，可以在成员变量声明之上指定SomeObj来提示其类型。 然后是一个IDE，例如。 PHPEd将知道它正在使用什么类型的对象，并且能够为该变量提供代码洞察。

<?php
  class Test
  {
    /** @var SomeObj */
    private $someObjInstance;
  }
?>

这很有效，直到我需要对一个对象数组做同样的事情，以便在稍后迭代这些对象时能够获得正确的提示。

那么，有没有办法声明一个PHPDoc标记来指定成员变量是一个SomeObjs的数组？ 例如，@var数组是不够的，@var array(SomeObj)似乎没有效果。

ECMAScript 6引入了let声明。 我听说它被描述为“本地”变量，但我仍然不太确定它与let关键字的行为有何不同。

有什么区别？ 何时应该使用let超过var？

在与同事讨论了在C＃3中使用'var'关键字之后，我想知道人们对通过var的类型推断的适当用途有什么看法？

例如，我在可疑的情况下懒得使用var，例如:-

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

var的更合理用途如下： -

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

有趣的是，LINQ似乎有点灰色，例如：

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

很明显，结果将是一个实现IEnumerable的类型，但是以声明新对象的var的方式并不完全明显。

对于LINQ对象来说，情况更糟，例如：

var results = from item in someList
              where item != 3
              select item;

这并不比等效的foreach（someList中的var item）{// ...}等效更好。

关于类型安全存在一个真正的问题 - 例如，如果我们将该查询的结果放入一个接受IEnumerable＆lt; int＆gt;的重载方法中。 和IEnumerable＆lt; double＆gt; 调用者可能会无意中传入错误的类型。

var确实保持了强类型，但问题是这个类型在定义上是不是立即显而易见是危险的，当重载意味着当你无意中将错误的类型传递给方法时可能不会发出编译器错误时会被放大。

javascript中变量的范围是什么？ 它们的内部是否与函数外部相同？ 或者甚至重要吗？ 此外，如果全局定义变量，那么它们存储在哪里？