Devrais-je utiliser l’instruction return / continue au lieu de if-else?

En C, C ++ et C # lors de l’utilisation d’une condition dans une instruction de fonction ou de boucle, il est possible d’utiliser une instruction continue ou de retour le plus tôt possible et de supprimer la twig else d’une instruction if-else Par exemple:

while( loopCondition ) { if( innerCondition ) { //do some stuff } else { //do other stuff } } 

devient

  while( loopCondition ) { if( innerCondition ) { //do some stuff continue; } //do other stuff } 

et

 void function() { if( condition ) { //do some stuff } else { //do other stuff } } 

devient

 void function() { if( condition ) { //do some stuff return; } //do other stuff } 

La variante “après” peut être plus lisible si les twigs if-else sont longues car cette modification élimine l’indentation pour la twig else.

Une telle utilisation de retour / continuer est-elle une bonne idée? Existe-t-il des problèmes de maintenance ou de lisibilité?

Le compilateur générera presque certainement le même code. Même si ce n’était pas le cas, la différence serait probablement sans importance. Par conséquent, l’argument pertinent est certainement comment les gens le liraient.

Par conséquent, la question est de savoir à quel point “// fait des choses” et “fais d’autres choses” sont similaires. S’ils sont conceptuellement similaires, utilisez if / else. Si elles sont différentes sur le plan conceptuel, utilisez continuer / revenir.

Mon approche personnelle du choix est que si le corps de la partie if est très court (3 ou 4 lignes maximum), il est judicieux d’utiliser la variante return/continue . Si le corps est long, il est plus difficile de garder une trace du stream de contrôle, je choisis donc la version else .

En conséquence, normalement, cette approche limite l’utilisation du style de return/continue pour ignorer certaines données et éviter un traitement ultérieur plutôt que de le traiter en utilisant l’une des méthodes suivantes (qui convient mieux à if/else ).

Cela dépend un peu de la longueur des twigs. L’utilisation de return / continue que vous décrivez est bonne si la vérification initiale est courte et le corps long. Si les parties if et else sont toutes deux longues, je les extrairais pour séparer des fonctions.

Je recommande de lire Code Complete, cela discute beaucoup de choses comme ça.

Le code serait plus lisible si les critères de terminaison sont traités en premier. Je préfère toujours vérifier les conditions qui nécessitent une pause ou un retour plutôt que celles qui nécessiteraient une longue exécution de code. Je préfère:

  if (termination condn) return; // code // code 

à

 if (success condn) { // code // code } else return; 

Cela facilite la lecture et la compréhension du code.

La réponse facile est que tout dépend.

Mon sentiment général est que si la condition est rare, une condition garde (par exemple, une vérification de la valeur nulle) ou une condition d’erreur, j’ai tendance à utiliser return ou continue

Si c’est un cas attendu, j’ai tendance à utiliser votre première approche.

Notez cependant que j’ai dit “tend”. La frontière entre ces conditions est vague et sujette à changement en fonction du projet et des personnes avec lesquelles je travaille.

Je préfère d’habitude

 while( loopCondition ) { if( innerCondition ) { DoStuff(); } else { DoOtherStuff(); } } 

continue peut être difficile à suivre si la longueur de DoStuff dépasse le seuil de 1-2 lignes (et qu’il est assez facile de passer à côté de l’intention). Cela semble être une bonne occasion de reformuler la logique en quelques méthodes plus petites.

Ne sacrifiez pas la lisibilité pour une optimisation prématurée.

Par exemple:

 void function() { if( condition ) { //do some stuff } else { //do other stuff } } 

est dans la plupart des cas équivalent binary à

 void function() { if( condition ) { //do some stuff return; } //do other stuff } 

(ie le code résultant est probablement le même). Mais la lisibilité de l’ancien est bien meilleure, car on voit clairement que le code sera soit X, soit Y.

1) Validation de l’état d’entrée ou d’object . Code suivant:

 void function() { if( condition ) { //do some stuff return; } //do other stuff } 

est bon lorsque la condition est une condition nécessaire pour que la fonction fonctionne. C’est une étape de validation d’entrée ou de validation d’état d’object. Il est alors bon d’utiliser l’application return immédiatement, cette fonction n’a pas fonctionné du tout.

2) traitement en plusieurs étapes . While / continue est utile lorsque la boucle extrait des éléments d’une collection et les traite en plusieurs étapes:

 while(foo = bar.getNext()) { if(foo.empty()) continue; if(foo.alreadyProcessed()) continue; // Can we take a shortcut? if(foo.tryProcessThingsYourself()) continue; int baz = foo.getBaz(); if(baz < 0) { int qux = foo.getQux(); if(qux < 0) { // Error - go to next element continue; } } // Finally -- do the actual processing baz = baz * 2; foo.setBaz(baz); } 

L'exemple montre à quel point il est naturel d'utiliser continuer dans le scénario lorsque des séries de traitements en plusieurs étapes sont effectuées, chaque traitement pouvant être interrompu par diverses conditions à différents endroits.

Avis: exemple concret de socle posté, qui suit ce que 2) dit.

3) règle générale . J'utilise continue et retour quand cela correspond au fait que quelque chose a été interrompu. J'utilise autre , lorsque l' autre fait partie du traitement réel.

Un problème de maintenance possible est que, si une fonction a plusieurs retours, il est alors plus difficile de coller un point d’arrêt ou un traçage lors du débogage. Ce n’est que rarement un problème, mais lorsque vous ratez un sharepoint retour, c’est pénible. Je ne pense pas que ce soit tellement important pour continuer dans les boucles, car la condition de la boucle et le sumt de la boucle sont tous deux uniques.

En dehors de cela: ce que tout le monde dit. Faites ce qui est le plus lisible, ce qui dépend de la longueur relative, de l’importance et de la probabilité de “certains trucs” et “d’autres trucs”. Plus le cas est court, banal et peu probable, moins il est gênant pour lui d’avoir un stream de contrôle des cas particuliers.

comme d’autres l’ont dit, n’utilisez le retour / continuer que si les choses sont courtes.

Personnellement, je n’utilise continue que s’il est possible d’écrire sur une ligne comme:

 while( loopCondition ) { if( innerCondition ) continue; //do other stuff } 

Si ce n’est pas possible de l’écrire comme ceci sans que le code ne devienne moche, alors si / else.

Pour les sourires, j’ai fait une recherche dans le code de base de mon entreprise pour “continue;” juste pour avoir une idée de l’endroit où il est utilisé. Nous utilisons 695 fois, sur 59 projets réunis dans une même solution, environ 1 500 fichiers sources.

Les principales façons de les utiliser sont un filtre rapide:

 foreach (Frobozz bar in foo) { if (QuickFilterExclude(bar)) continue; // extensive processing } 

Une reprise d’une exception attendue:

 foreach (Frobozz bar in foo) { Baz result = new Baz(kDefaultConfiguration); try { Baz remoteResult = boo.GetConfiguration(); } catch (RemoteConnectionException) { continue; } result.Merge(remoteResult); ReportResult(result); } 

Et enfin dans l’appareil d’Etat.

J’utilise généralement la méthode if-return lorsque je saute d’une méthode ou d’une boucle car il n’y a rien à faire.

Si le corps est plus long en raison d’un travail important, je suggère d’utiliser if-else et peut-être en utilisant #region pour donner un nom raisonnable aux blocs et les rendre facilement réductibles pour que les personnes puissent étudier le stream de contrôle. Que ou faire des méthodes séparées 🙂

J’ai eu ce qui suit dans mon code:

  while(){ boolean intersect = doesIntersect(interval_1,interval_2); if(!intersect){ array.add(interval_2); if(// another condition){ // Do some thing here } continue; } // other stuff to do if intersect } 

Étais confus de savoir si je devais utiliser continuer là ou utiliser autre chose, mais j’ai décidé que la condition interne if pourrait rendre l’autre moins lisible, j’ai donc utilisé continuer.

Je pense que la lisibilité est ce qui compte!