我一直想知道，在一般情况下，将一个临时变量在循环之前声明，相对于在循环内部重复声明，是否会有任何（性能）差异？以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 更好。在尽可能狭窄的作用域内声明和初始化变量。不要在声明和初始化之间留下巨大的空隙，也不要污染不必要的命名空间。
我运行了你的A和B示例各20次，在1.5.0版本的JVM上循环1亿次。
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
区别在于所有操作都捕获相同的outer变量，但每个操作都有自己单独的inner变量。
Outer不应该是9吗？ - nawfal以下是我在.NET中编写和编译的内容。
double r0;
for (int i = 0; i < 1000; i++) {
r0 = i*i;
Console.WriteLine(r0);
}
for (int j = 0; j < 1000; j++) {
double r1 = j*j;
Console.WriteLine(r1);
}
这是我从.NET Reflector获取的信息，当CIL转换为代码时得到。
for (int i = 0; i < 0x3e8; i++)
{
double r0 = i * i;
Console.WriteLine(r0);
}
for (int j = 0; j < 0x3e8; j++)
{
double r1 = j * j;
Console.WriteLine(r1);
}
在编译之后，两者看起来完全一样。在托管语言中，代码被转换为CL/字节码，并在执行时转换为机器语言。因此，在机器语言中，一个double甚至可能不会被创建在堆栈上，它只是一个寄存器，因为代码表明它是WriteLine函数的临时变量。针对循环有一整套优化规则。所以普通人不必担心，尤其是在托管语言中。也有一些情况可以优化托管代码，例如，如果您必须使用string a; a+=anotherstring[i]来连接大量字符串，则与使用StringBuilder相比，性能差异非常大。还有许多这样的情况，编译器无法优化您的代码，因为它无法弄清楚更大范围内的意图，但是它几乎可以为您优化基本操作。
这是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。
如果你添加一个= 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...
我做了一个简单的测试：
int b;
for (int i = 0; i < 10; i++) {
b = i;
}
对比
for (int i = 0; i < 10; i++) {
int b = i;
}
1º:
0x00000000004004b6 <+0>: push rbp
0x00000000004004b7 <+1>: mov rbp,rsp
0x00000000004004ba <+4>: mov DWORD PTR [rbp-0x4],0x0
0x00000000004004c1 <+11>: jmp 0x4004cd <main+23>
0x00000000004004c3 <+13>: mov eax,DWORD PTR [rbp-0x4]
0x00000000004004c6 <+16>: mov DWORD PTR [rbp-0x8],eax
0x00000000004004c9 <+19>: add DWORD PTR [rbp-0x4],0x1
0x00000000004004cd <+23>: cmp DWORD PTR [rbp-0x4],0x9
0x00000000004004d1 <+27>: jle 0x4004c3 <main+13>
0x00000000004004d3 <+29>: mov eax,0x0
0x00000000004004d8 <+34>: pop rbp
0x00000000004004d9 <+35>: ret
对比
第二个
0x00000000004004b6 <+0>: push rbp
0x00000000004004b7 <+1>: mov rbp,rsp
0x00000000004004ba <+4>: mov DWORD PTR [rbp-0x4],0x0
0x00000000004004c1 <+11>: jmp 0x4004cd <main+23>
0x00000000004004c3 <+13>: mov eax,DWORD PTR [rbp-0x4]
0x00000000004004c6 <+16>: mov DWORD PTR [rbp-0x8],eax
0x00000000004004c9 <+19>: add DWORD PTR [rbp-0x4],0x1
0x00000000004004cd <+23>: cmp DWORD PTR [rbp-0x4],0x9
0x00000000004004d1 <+27>: jle 0x4004c3 <main+13>
0x00000000004004d3 <+29>: mov eax,0x0
0x00000000004004d8 <+34>: pop rbp
0x00000000004004d9 <+35>: ret
两个代码生成完全相同的汇编结果，这难道不证明这两个代码产生了相同的结果吗？
它是与语言相关的 - 如果我没记错，C# 会进行优化，因此没有任何区别，但是 JavaScript（例如）每次都会执行整个内存分配过程。
我会始终使用A（而不是依赖于编译器），并可能重写为：
for(int i=0, double intermediateResult=0; i<1000; i++){
intermediateResult = i;
System.out.println(intermediateResult);
}
这仍然限制了intermediateResult的作用范围在循环内，但不会在每次迭代期间重新声明。
在我的看法中，b是更好的结构。在a中，当你的循环结束后，intermediateResult的最后一个值会一直存在。
编辑： 这对于值类型没有太大影响，但是对于引用类型来说可能会有一些负担。个人而言，我喜欢尽早解除变量的引用以进行清理，而b可以为您完成这项工作。
my关键字）、C#和Java等，这是我使用过的五种语言。 - Powerlord好的，你可以为此编写一个作用域：
{ //Or if(true) if the language doesn't support making scopes like this
double intermediateResult;
for (int i=0; i<1000; i++) {
intermediateResult = i;
System.out.println(intermediateResult);
}
}