Есть ли какая-то заметная разница между если и если-ж?

Question

Учитывая следующие фрагменты кода, есть ли какая-то заметная разница?

public boolean foo(int input) {
   if(input > 10) {
       doStuff();
       return true;
   }
   if(input == 0) {
       doOtherStuff();
       return true;
   }

   return false;
}

против.

public boolean foo(int input) {
   if(input > 10) {
      doStuff();
      return true;
   } else if(input == 0) {
      doOtherStuff();
      return true;
   } else {
      return false;
   }
}

Или единственный принцип выхода будет лучше здесь с этим куском кода ...

public boolean foo(int input) {
   boolean toBeReturned = false;
   if(input > 10) {
      doStuff();
      toBeReturned = true;
   } else if(input == 0) {
      doOtherStuff();
      toBeReturned = true;
   }

   return toBeReturned;
}

Есть ли ощутимая разница в производительности? Вы чувствуете себя более или менее ремонтом / читабельными, чем другие?

Answer 1

Со второго примера вы говорите очень четко, что оба условия являются взаимоисключающими.
С первым, это не так четко, и в (маловероятно) событие, которое назначение input Добавляют между как IFS, логика изменится.
Предположим, кто-то в будущем добавляет input = 0 до второго, если.
Конечно, это вряд ли произойдет, но если мы говорим о ремонтопригодности здесь, если-els ясно, что есть взаимоисключающие условия, в то время как куча IFS не так, и они не так зависят друг от друга -Эльс блоки.

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

Во всяком случае, о производительности, если это закодировано в Java, вы не должны заботиться о производительности пары блоков, если бы она была встроена в действительно медленное оборудование, может быть, но, конечно, не с Java.

Answer 2

Используйте любую форму лучше всего описывает ваше намерение.

Не следите за единственным принципом выхода, если все это просто, хотя - это просто делает его более запутанным.

Answer 3

• Во-первых:

  Кто-то в конечном итоге, по какой-то странной причине и когда вы не смотрите, добавьте некоторые добавления оператора, которое сделает этот метод сгота с определенными странными условиями, все (или худшие, один человек) потратит 4 часа. Наблюдая за исходным кодом и отладка приложения, наконец, найден, что в середине было что-то.

• Второй определенно лучше, не только предотвращает этот сценарий, но и помогает четко указать, это это или это другое больше не надо.

  Если весь код, который мы пишем в if Куда не более 10 строк в большей степени, это не имеет значения, но, к сожалению, это не так, существует другие программисты, которые по какой-то причине считают, что если тело должно быть> 200 строк ... В любом случае.

• Мне не нравится третий, это заставляет меня искать возвратную переменную, и легче найти return ключевое слово

О скоростных характеристиках, они (почти) идентичны. Не беспокойтесь об этом.

Answer 4

В вашем последнем примере не делайте этого:

public boolean foo(int input) {
   boolean toBeReturned = false;
   if(input > 10) {
      doStuff();
      toBeReturned = true;
   } else if(input == 0) {
      doOtherStuff();
      toBeReturned = true;
   }

   return toBeReturned;
}

Но это (обратите внимание на использование Java финал):

public boolean foo(int input) {
   final boolean toBeReturned;    // no init here
   if(input > 10) {
      doStuff();
      toBeReturned = true;
   } else if(input == 0) {
      doOtherStuff();
      toBeReturned = true;
   } else {
      toBeReturned = false;
   }
   return toBeReturned;
}

При этом вы делаете свое намерение ясно, и это боготворение для IDES, поддерживающих «программирование путем намерения» (нет необходимости «компилировать», чтобы увидеть потенциальные ошибки, даже в частичной AST, хорошая IDE может рассматривать неполный источник в реальном время и дать вам мгновенные предупреждения).

Таким образом, вы Конечно Не забыть инициализировать ваше возвращаемое значение. Это отлично, если позже вы решите, что после всего, что вам нужно другое состояние.

Я делаю это все время и даже Moreso, поскольку я начал использовать INTELLIJ IDEAD (версия 4 или около того, давным-давно), и это спас меня так много глупых ошибок отвлечения ...

Некоторые люди будут утверждать, что это слишком много кода для такого простого случая, но это совершенно не хватает точки: точка - сделать ясно, что код легко читает и может быть легко расширен, не случайно забывающую Tobereturned. и не случайно забывая вернуться из более позднего пункта, вы можете добавить.

В противном случае, если «краткость» было названием игры, то я бы написал:

public boolean foo(int a) {
  return a > 10 ? doStuff() : a == 0 ? doOtherStuff() : false; 
}

Где оба досмотр а также Doothestuff. вернется правдой.

Answer 5

Семантически - нет. Производительность-мудрое зависит от компилятора, т. Е. Независимо от того, может ли оно обнаружить, что оба условия не могут быть верны сразу. Могу поспорить, что стандартный компилятор Sun может. Следует ли использовать один принцип выхода, зависит от вкусов. Я лично ненавижу это.

Answer 6

Версия № 1 и № 2 может быть быстрее, чем № 3, но я полагаю, что разница производительности минимальна. Я бы предпочел сосредоточиться на читаемость.

Лично я бы никогда не использовал версию № 2. Между # 1 и № 3 я бы выбрал тот, который дает самый читаемый код для рассматриваемого дела. Мне не нравятся много точек выхода в моих методах, потому что это делает код трудно проанализировать. Тем не менее, есть случаи, когда поток становится понятным, когда мы сразу выходим сразу для некоторых особых случаев и продолжаем с основными случаями.

Answer 7

Подумайте об этом случае, когда два примера не будут похожи:

    public boolean foo(int input) {
        if (input > 10) {
            // doStuff();
            return true;
        }
        System.out.println("do some other intermediary stuff");
        if (input == 0) {
            // doOtherStuff();
            return true;
        }

        return false;
    }

против.

    public boolean foo(int input) {
        if (input > 10) {
            // doStuff();
            return true;
        } 
        //System.out.println("doing some intermediary stuff... doesn't work");
        else if (input == 0) {
            // doOtherStuff();
            return true;
        } else {
            return false;
        }
        return false;
    }

Первый подход, вероятно, более гибкий, но оба формулы Иметь их использование в разных обстоятельствах.

Что касается характеристики, я думаю, что различия должны быть небольшими для того, чтобы их принять во внимание, для любого обычного приложения Java, закодированной Sane Programmemers :).

Answer 8

В вашем случае вторым, если бы позвонили, только если первым, если не удалось, поэтому здесь менее важно, но если ваш первый, если сделал что-то и не вернулся, второй, если (который бы тогда всегда был ложным) все равно будет тестировать, если был в остальном - если.

Другими словами, есть случаи, когда разница между If-else-if и if-If-Elsers, но это не один из них.

Пример: попробуйте это, а затем попробуйте его после удаления остального. Вы получаете два разных выхода:

int someNumber = 1;
if(someNumber < 5)
{
    someNumber += 5;
    Console.WriteLine("First call.");
}
else if(someNumber >= 5)
{
    Console.WriteLine("Second call.");
}

Answer 9

Между первой и второй фрагментами, нет никакой разницы. Однако третий фрагмент довольно неэффективна. Поскольку вы ждете, чтобы вернуть контроль над программой до вызывающего абонента до последней строки кода в методе, вы обрабатываете питание / память отходов, тогда как первый двух фрагментов кода возвращает управление, как только он определяет одно из условий, чтобы быть правдой.