Compte tenu des extraits de code suivants, y a-t-il une différence appréciable?
public boolean foo(int input) {
boolean toBeReturned = false;
if(input > 10) {
doStuff();
toBeReturned = true;
} else if(input == 0) {
doOtherStuff();
toBeReturned = true;
}
return toBeReturned;
}
9 Réponses :
Utilisez le formulaire le mieux décrit votre intention.
Ne suivez pas le principe de sortie unique si les choses sont aussi simples, mais cela le rend plus confus.
sémantiquement - non. Performance-sage Cela dépend du compilateur, c'est-à-dire qu'il puisse repérer que les deux conditions ne peuvent pas être vraies à la fois. Je parierais que le compilateur Sun Sun peut. S'il faut utiliser un principe de sortie simple dépend des goûts. Je déteste personnellement ça.
entre les premier et deuxième extraits, il n'y a vraiment aucune différence. Cependant, le troisième extrait est assez inefficace. Parce que vous attendez de retourner le contrôle du programme à l'appelant jusqu'à la dernière ligne de code dans la méthode, vous gaspillez la puissance de traitement / la mémoire, tandis que les deux premiers coups de code retournent le contrôle de retour dès qu'il détermine l'une des conditions d'être vraie. < / p>
Vous êtes presque certainement incorrect - tout compilateur moderne optimisera chacune d'elles au même code. Et quel que soit le "contrôle de retour au programme" ne prend aucune puissance ou mémoire de traitement
Peut-être que vous avez mal compris. Où je voulais dire que le gaspillage de la puissance de traitement se produit est si la première condition est valide à vrai. Dans ses deux premiers exemples, le flux de contrôle serait renvoyé à la méthode d'appel au lieu de continuer avec une validation inutile. Donc, corrigez-moi si je me trompe, mais de dire que l'exécution de indistile code "ne prend aucun pouvoir de traitement" n'est pas vrai, non?
Nan. Suite à votre phrase sémantiquement, le troisième extrait est assez inefficace. Parce que vous attendez de retourner ... jusqu'à la dernière ligne de code ... vous gaspillez la puissance de traitement ». Vous ne critiquez que le troisième extrait que vous avez démissionné 1 et 2 déjà. Mon assertion est debout.
Après avoir relu ma réponse, vous avez raison grâce à ma sémantique. Je n'ai pas expliqué à fond pourquoi je pensais à l'origine que l'extrait 3 pourrait perdre du temps de traitement / de la puissance. Je me rends également réalisée après avoir relu le point que le point que j'allais faire à propos de l'extrait 3 serait discutable grâce à la partie "sinon" du code. Quoi qu'il en soit, j'ai au moins pris note de la variable "totabered" lors de la relecture de l'OP. Cette variable (en plus de m'aider quelque peu sauver-face) crée plus de frais généraux (prend plus de mémoire), ce qui le rend inefficace. Donc, à l'OP, ne codez pas de blocs comme Snippet 3 si vous pouvez l'éviter. :)
Avec le deuxième exemple, vous indiquez très clairement que les deux conditions sont mutuellement exclusives. Edit: Maintenant que je vois, dans cet exemple particulier, la clause de retour force l'exclusivité mutuelle, mais à nouveau, nous parlons de la maintenabilité et de la lisibilité.
Quoi qu'il en soit, sur la performance, si cela est codé dans Java, vous ne devriez pas vous soucier de la performance d'un couple de plusieurs blocs, s'il était incorporé C dans un matériel vraiment lent, peut-être, mais pas avec Java.
Avec le premier, il n'est pas aussi clair et dans l'événement (improbable) qu'une affectation à entrée est ajoutée entre les deux ifs, la logique changerait.
Supposons que quelqu'un dans le futur ajoute entrée = 0 avant le second si.
Bien sûr, cela est peu susceptible de se produire, mais si nous parlons de la maintenabilité ici, si-d'autre dit clairement qu'il y a des conditions mutuellement exclusives, tandis qu'un tas d'IFS ne le fait pas, et ils ne sont pas aussi dépendants entre eux, comme si -Les blocs.
La version n ° 1 et n ° 2 peut être plus rapide que n ° 3, mais je suppose que la différence de performance est minimale. Je préférerais me concentrer sur lisibilité .
Personnellement, je n'utiliserais jamais la version n ° 2. Entre # 1 et n ° 3, je choisirais celui qui donne le code le plus lisible pour le cas en question. Je n'aime pas beaucoup de points de sortie dans mes méthodes, car cela rend le code difficile à analyser. Cependant, il y a des cas où le flux devient plus claire lorsque nous quittons immédiatement certains cas spéciaux et continuons par les cas principaux.
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("doing some intermediary stuff... doesn't work");
else if (input == 0) {
// doOtherStuff();
return true;
} else {
return false;
}
return false;
}
Dans votre cas, la seconde si elle ne serait appelée que si le premier s'il est échoué, il est donc moins important ici, mais si votre premier si vous avez fait quelque chose et que vous n'aviez pas revenu, le second si (qui serait toujours toujours faux) serait toujours Testé à moins que c'était dans un autre - si.
En d'autres termes, il y a des cas où la différence entre si, si et si, si importe, mais ce n'est pas l'un d'entre eux.
Exemple: essayez ceci puis essayez-le après avoir retiré l'autre. Vous obtenez deux sorties différentes:
dans le premier:
Quelqu'un éventuellement, par une raison d'étrange et lorsque vous ne regardez pas, vous ajouterez une déclaration supplémentaire qui rendra cette méthode échouera dans certaines conditions étranges, tout le monde (ou pire, une seule personne) dépensera 4 heures. En regardant le code source et déboguer l'application pour finalement trouvé qu'il y avait quelque chose au milieu.
La seconde est définitivement meilleure, non seulement elle empêche ce scénario, mais aide également à énoncer clairement, il ce ou cet autre pas plus.
Si tout le code que nous écrivons dans un Je n'aime pas la troisième, cela me force à rechercher la variable de retour, et il est plus facile de trouver le mot-clé
À propos des performances de la vitesse, ils sont (presque) identiques. Ne vous inquiétez pas pour ça. si où 10 lignes longues au plus, cela importerait vraiment, mais malheureusement, ce n'est pas le cas, il existe d'autres programmeurs qui, par une raison quelconque, pensent que un corps si le corps devrait être> 200 lignes de long ... Quoi qu'il en soit.
Dans votre dernier exemple, ne faites pas cela:
public boolean foo(int a) {
return a > 10 ? doStuff() : a == 0 ? doOtherStuff() : false;
}
Comment inventé que ° & $ §? *! principe de sortie simple? Vraiment, a-t-il déjà fait du code plus lisible?
Beaucoup (y compris moi) diraient que oui, ça fait.
Dans Ceci cas, # 1 et # 2 fonctionne de l'identique (l'autre est redondant). Toutefois, si les expressions pourraient être vraies (c.-à-d .:
entrée> 5 et0 == (entrée% 2) ) alors ce serait une histoire entièrement différente. Considérez le domaine de la condition que vous testez et comment cela pourrait changer dans les mises à jour futures. En ce qui concerne la Principal de sortie simple Je l'ai vu faire du code beaucoup plus et Autre code beaucoup moins lisible, alors considérez-le qu'un outil n'est pas un commandement.