我一直想知道，在一般情况下，在循环之前声明一个丢弃的变量，而不是在循环内部重复，使任何(性能)差异? Java中的一个(非常无意义的)例子:
A)循环前声明:
double intermediateResult;
for(int i=0; i < 1000; i++){
intermediateResult = i;
System.out.println(intermediateResult);
}
B)声明(重复)内部循环:
for(int i=0; i < 1000; i++){
double intermediateResult = i;
System.out.println(intermediateResult);
}
哪个更好，a还是b?
我怀疑重复的变量声明(例b)在理论上会产生更多的开销，但编译器足够聪明，所以这无关紧要。例b的优点是更紧凑，并且将变量的作用域限制在使用它的地方。尽管如此，我还是倾向于根据示例a编写代码。
编辑:我对Java案例特别感兴趣。
当前回答
这是VB.NET的一个陷阱。在这个例子中，Visual Basic的结果不会重新初始化变量:
For i as Integer = 1 to 100
Dim j as Integer
Console.WriteLine(j)
j = i
Next
' Output: 0 1 2 3 4...
第一次输出0 (Visual Basic变量声明时有默认值!)，之后每次输出i。
如果你加上a = 0，你可能会得到你所期望的:
For i as Integer = 1 to 100
Dim j as Integer = 0
Console.WriteLine(j)
j = i
Next
'Output: 0 0 0 0 0...
其他回答
我把A和B的例子各运行了20次，循环了1亿次。(jvm - 1.5.0)
A:平均执行时间:0.074秒
B:平均执行时间:0.067秒
令我惊讶的是B稍微快一点。 尽管现在的计算机速度很快，但很难说你是否能准确地测量这一点。 我也会用A的方式来编码，但我想说这并不重要。
这取决于语言和确切的用法。例如，在c# 1中，这没有什么区别。在c# 2中，如果局部变量是通过匿名方法(或c# 3中的lambda表达式)捕获的，则会产生非常显著的差异。
例子:
using System;
using System.Collections.Generic;
class Test
{
static void Main()
{
List<Action> actions = new List<Action>();
int outer;
for (int i=0; i < 10; i++)
{
outer = i;
int inner = i;
actions.Add(() => Console.WriteLine("Inner={0}, Outer={1}", inner, outer));
}
foreach (Action action in actions)
{
action();
}
}
}
输出:
Inner=0, Outer=9
Inner=1, Outer=9
Inner=2, Outer=9
Inner=3, Outer=9
Inner=4, Outer=9
Inner=5, Outer=9
Inner=6, Outer=9
Inner=7, Outer=9
Inner=8, Outer=9
Inner=9, Outer=9
不同之处在于，所有的操作都捕获相同的外部变量，但每个操作都有自己独立的内部变量。
我总是使用A(而不是依赖于编译器)，也可能重写为:
for(int i=0, double intermediateResult=0; i<1000; i++){
intermediateResult = i;
System.out.println(intermediateResult);
}
这仍然将intermediateResult限制在循环的范围内，但不会在每次迭代期间重新声明。
作为一般规则，我将变量声明在最内部的可能范围内。如果你不在循环外使用intermediateResult，那么我会用B。
这是更好的形式
double intermediateResult;
int i = byte.MinValue;
for(; i < 1000; i++)
{
intermediateResult = i;
System.out.println(intermediateResult);
}
1)这样声明一次时间既是变量，而不是每次为周期。 2)任务比其他选项都要大。 3)所以最佳实践规则是迭代之外的任何声明。
