Различие между объявлением переменных прежде или в цикле?

Даже если я буду знать, что мой компилятор достаточно умен, я не буду любить полагаться на него и буду использовать a) вариант.

b) вариант имеет смысл мне, только если отчаянно необходимо сделать intermediateResult недоступный после тела цикла. Но я не могу вообразить такое отчаянное положение, так или иначе....

РЕДАКТИРОВАНИЕ: Jon Skeet сделал очень правильное замечание, показав, что объявление переменной в цикле может иметь фактическое семантическое значение.

Я думаю, что это зависит от компилятора и твердо дать общий ответ.

Коллега предпочитает первую форму, говоря, что это - оптимизация, предпочитая снова использовать объявление.

я предпочитаю второй (и попытайтесь убедить моего коллегу!;-)), считав, что:

• Это уменьшает объем переменных туда, где они необходимы, который является хорошей вещью.
• Java оптимизирует достаточно, чтобы не иметь никакого значительного значения в производительности. IIRC, возможно, вторая форма еще быстрее.

Так или иначе, это падает в категории преждевременной оптимизации, которые полагаются в качестве компилятора и/или JVM.

Хорошо я выполнил Ваш A и примеры B 20 раз каждый, цикличное выполнение 100 миллионов раз. (JVM - 1.5.0)

А: среднее время выполнения:.074 секунд

B: среднее время выполнения:.067 секунд

К моему удивлению B были немного быстрее. С такой скоростью, как компьютеры являются теперь его твердым, чтобы сказать, могли ли Вы точно измерить это. Я кодировал бы его путь также, но я скажу, что это действительно не имеет значения.

Это зависит от языка и точного использования. Например, в C# 1 это не имело никакого значения. В C# 2, если локальная переменная получена анонимным методом (или лямбда-выражение в C# 3) она может сделать очень signficant различие.

Пример:

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 переменная.

Это - глюк в 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...

Это является языковозависимым - IIRC C# оптимизирует это, таким образом, нет никакого различия, но JavaScript (например), сделает целую хижину выделения памяти каждый раз.

По-моему, b является лучшей структурой. В a слоняется поблизости последнее значение intermediateResult после того, как Ваш цикл закончен.

Редактирование: Это не имеет большое значение с типами значения, но ссылочные типы могут быть несколько тяжелыми. Лично, мне нравится, когда переменные разыменовываются как можно скорее для очистки, и b делает это для Вас,

Я подозреваю, что несколько компиляторов могли оптимизировать обоих, чтобы быть тем же кодом, но конечно не всеми. Таким образом, я сказал бы, что Вы более обеспечены с первым. Единственная причина для последнего состоит в том, если Вы хотите удостовериться, что заявленная переменная используется [только 111] в Вашем цикле.