Est-ce qu'il ya une différence appréciable entre si et if-else?

Question

Compte tenu des extraits de code suivant, est-il une différence appréciable?

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

   return false;
}

vs.

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

Ou serait mieux ici le principe de sortie unique avec ce morceau de code ...

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

   return toBeReturned;
}

Quelle est la différence de performance perceptible? Vous sentez-vous un est plus ou moins maintenable / lisible que les autres?

Answer 1

Dans le second exemple, vous dire très clairement que les deux conditions sont mutuellement exclusives.
Avec le premier, il est si clair, et dans le (peu probable) que la cession à input est ajouté entre les deux ifs, la logique changerait.
quelqu'un suppose que dans l'avenir, ajoute input = 0 avant le second cas.
Bien sûr, cela est peu probable, mais si nous parlons ici maintenabilité, if-else dit clairement qu'il existe des conditions mutuellement exclusives, tout un tas de ifs ne le font pas, et ils ne sont pas si dépendants entre eux comme le sont si -else blocs.

modifier. Maintenant que je vois, dans cet exemple particulier, les forces de clause de retour l'exclusivité de mutuelle, mais encore une fois, nous parlons maintenabilité et la lisibilité

Quoi qu'il en soit, sur la performance, si cela est codé en Java vous ne devriez pas prendre soin de la performance d'un couple de blocs si, si elle était intégrée C dans un matériel vraiment lent, peut-être, mais certainement pas avec java.

Answer 2

Utilisez ce formulaire décrit le mieux votre intention.

Ne pas suivre le seul principe de sortie si les choses sont ce simple, mais - il est tout simplement plus confondant

.

Answer 3

• Dans le premier:

  quelqu'un éventuellement, par une raison étrange et quand vous n'êtes pas à la recherche ajoutera une déclaration d'ajout qui fera cette méthode échouer dans certaines conditions étranges, tout le monde (ou pire, une seule personne) passeront 4 heures. en regardant le code source et le débogage de l'application a finalement trouvé qu'il y avait quelque chose au milieu.

• La seconde est certainement mieux, non seulement il empêche ce scénario, mais contribue également à indiquer clairement, il ce ou cette autre pas plus.

  Si tout le code que nous écrivons dans un if où 10 longues lignes au plus, ce ne serait pas vraiment question, mais malheureusement, ce ne est pas le cas, il existe d'autres programmeurs qui, par une raison quelconque pensent que si le corps doit être> 200 longues lignes ... de toute façon.

• Je ne suis pas comme le troisième, il me oblige à chercher la variable de retour, et il est plus facile de trouver le mot-clé return

A propos des performances de vitesse, ils sont (presque) identiques. Ne vous inquiétez pas à ce sujet.

Answer 4

Dans votre dernier exemple, ne pas faire ceci:

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

   return toBeReturned;
}

mais (notez l'utilisation de Java de finale ):

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;
}

En ce faisant, vous faites votre intention claire et cela est une aubaine pour les IDEs de soutien « programmation par intention » (il n'y a pas besoin de « compiler » pour voir les erreurs potentielles, même sur une AST partielle, un bon IDE peut examiner la source incomplète en temps réel et vous donner des avertissements instantanés).

De cette façon, vous êtes que ne pas oublier d'initialiser votre valeur de retour. Ceci est très bien si plus tard vous décidez que vous avez besoin après tout une autre condition.

Je le fais tout le temps et même moreso depuis que je commencé à utiliser IntelliJ IDEA (version 4 ou plus, il y a longtemps) et cela m'a sauvé tant d'erreurs de distraction stupide ...

Certaines personnes soutiennent que cela est trop beaucoup de code pour un cas aussi simple, mais qui est tout à fait manque le point: le point est de faire si claire intention que le code se lit facilement et peut être facilement étendu plus tard, sans oublier accidentellement à assign toBeReturned et sans oublier accidentellement de revenir d'une clause plus tard, vous pouvez ajouter.

Dans le cas contraire, si « concision » était le nom du jeu, alors j'écrire:

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

Si les deux doStuff et doOtherStuff retournerait vrai.

Answer 5

sémantiquement - non. Côté performance cela dépend de compilateur, à savoir si elle peut repérer que les deux conditions ne peuvent pas être vrai à la fois. Je serais prêt à parier standard peut compilateur du Soleil. Que ce soit pour utiliser seul principe de sortie dépend des goûts. Je déteste personnellement.

Answer 6

Version n ° 1 et n ° 2 peut être plus rapide que # 3, mais je suppose que la différence de performance est minime. Je préfère se concentrer sur lisibilité .

Personnellement, je ne serais jamais utiliser la version n ° 2. Entre 1 et 3, je choisirais celui qui donne le plus de code lisible pour le cas en question. Je ne suis pas comme beaucoup de points de sortie dans mes méthodes, car il rend le code difficile à analyser. Cependant, il y a des cas où l'écoulement devient plus clair quand nous quitter immédiatement pour certains cas particuliers, et poursuivre les principaux cas.

Answer 7

Pensez à ce cas lorsque les deux exemples ne seront pas similaires:

    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;
    }

vs.

    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;
    }

La première approche est probablement plus flexible , mais les deux formules ont leur utilisation dans des circonstances différentes.

En ce qui concerne la performance, je pense que les différences sont petites pour être pris en considération, pour toute application java régulière, codé par les programmeurs sains d'esprit:)

.

Answer 8

Dans votre cas, le second se serait seulement obtenir appelé si le premier en cas d'échec il est moins important ici, mais si votre premier se fait quelque chose et ne revenait pas, le second cas (qui serait alors toujours faux) serait encore testé à moins qu'il était dans un autre, si.

En d'autres termes, il y a des cas où la différence entre if-else, si et si, si des questions, mais ce n'est pas un d'entre eux.

Exemple: Essayez et puis essayer après avoir enlevé l'autre. Vous obtenez deux sorties différentes:

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

Answer 9

Entre les premier et deuxième extraits, il n'y a vraiment pas de différence. Cependant, le troisième extrait est tout à fait inefficace. Parce que vous attendez de rendre le contrôle du programme à l'appelant jusqu'à la dernière ligne de code dans la méthode, alors que les deux premiers extraits de code de traitement des déchets d'alimentation / mémoire de retour contrôle dès qu'elle détermine l'une des conditions pour être vrai.