Pourquoi une fonction ne devrait-elle avoir qu’un seul sharepoint sortie?

J’ai toujours entendu parler d’une fonction de sharepoint sortie unique comme une mauvaise façon de coder, car vous perdez en lisibilité et en efficacité. Je n’ai jamais entendu personne discuter de l’autre côté.

Je pensais que cela avait quelque chose à voir avec CS, mais cette question a été rejetée lors de l’échange de documents.

Il existe différentes écoles de pensée et cela dépend en grande partie des préférences personnelles.

La première est qu’il y a moins de confusion s’il n’y a qu’un seul sharepoint sortie – vous avez un chemin unique dans la méthode et vous savez où chercher la sortie. Du côté négatif, si vous utilisez l’indentation pour représenter l’imbrication, votre code se trouve massivement en retrait à droite, et il devient très difficile de suivre toutes les scopes nestedes.

Une autre est que vous pouvez vérifier les conditions préalables et sortir tôt au début d’une méthode, de sorte que vous sachiez dans le corps de la méthode que certaines conditions sont vraies, sans que le corps entier de la méthode soit indenté à 5 miles à droite. Cela minimise généralement le nombre de scopes dont vous devez vous préoccuper, ce qui rend le code plus facile à suivre.

Un troisième est que vous pouvez sortir où vous voulez. Auparavant, cela était plus déroutant, mais maintenant que nous avons des éditeurs et des compilateurs à coloration syntaxique qui détectent du code inaccessible, il est beaucoup plus facile de traiter.

Je suis carrément dans le camp intermédiaire. Appliquer un sharepoint sortie unique est une ressortingction IMHO inutile, voire contre-productive, alors que le fait de quitter au hasard une méthode peut parfois conduire à une logique compliquée, où il devient difficile de voir si un bit de code donné sera ou non réalisé. Mais “gating” votre méthode permet de simplifier de manière significative le corps de la méthode.

Ma recommandation générale est que les instructions de retour doivent, si possible, être placées avant le premier code qui a des effets secondaires, ou après le dernier code ayant des effets secondaires. Je considérerais quelque chose comme:

   if (! argument) // Vérifier si non-nul
     retourner ERR_NULL_ARGUMENT;
   ... traiter un argument non nul
   si (ok)
     retourne 0;
   autre
     renvoyer ERR_NOT_OK;

plus clair que:

   int return_value;
   if (argument) // non nul
   {
     .. traiter un argument non nul
     .. régler le résultat de manière appropriée
   }
   autre
     resultat = ERR_NULL_ARGUMENT;
   résultat de retour

Si une certaine condition devait empêcher une fonction de faire quoi que ce soit, je préfère revenir en arrière rapidement de la fonction à un endroit au-dessus du point où la fonction ferait n’importe quoi. Une fois que la fonction a entrepris des actions avec des effets secondaires, je préfère revenir par le bas pour préciser que tous les effets secondaires doivent être pris en compte.

Si vous sentez que vous avez besoin de plusieurs points de sortie dans une fonction, la fonction est trop grande et fait trop.

Je vous recommande de lire le chapitre sur les fonctions dans le livre de Robert C. Martin, Clean Code.

Essentiellement, vous devriez essayer d’écrire des fonctions avec 4 lignes de code ou moins.

Quelques notes du blog de Mike Long :

  • La première règle des fonctions: elles devraient être petites
  • La deuxième règle des fonctions: elles devraient être plus petites que celle
  • Blocs dans les instructions if, tandis que les instructions, pour les boucles, etc. doivent contenir une ligne
  • … Et cette ligne de code sera généralement un appel de fonction
  • Il ne devrait pas y avoir plus d’un ou peut-être deux niveaux d’indentation
  • Les fonctions devraient faire une chose
  • Les énoncés de fonction doivent tous être au même niveau d’abstraction
  • Une fonction ne doit pas avoir plus de 3 arguments
  • Les arguments de sortie sont une odeur de code
  • Passer un drapeau booléen dans une fonction est vraiment horrible. Vous êtes par définition en train de faire deux choses dans la fonction.
  • Les effets secondaires sont des mensonges.

Le point d’entrée et de sortie unique était le concept original de programmation structurée par rapport au codage spaghetti par étapes. Il y a une croyance que plusieurs fonctions de sharepoint sortie requièrent plus de code puisque vous devez nettoyer correctement les espaces mémoire alloués aux variables. Envisagez un scénario où la fonction alloue des variables (ressources) et que sortir de la fonction rapidement et sans nettoyage adéquat entraînerait des fuites de ressources. De plus, la création d’un nettoyage avant chaque sortie créerait beaucoup de code redondant.

Avec la plupart des choses, cela dépend des besoins du livrable. Dans les temps anciens, le code spaghetti avec plusieurs points de retour a provoqué des memory leaks, car les codeurs qui préféraient cette méthode ne nettoyaient généralement pas bien. Il y avait aussi des problèmes avec certains compilateurs “perdant” la référence à la variable de retour lorsque la stack était extraite pendant le retour, dans le cas d’un retour d’une scope nestede. Le problème le plus général était celui du code rentrant, qui tente d’avoir l’état d’appel d’une fonction identique à son état de retour. Les mutateurs de oop ont violé ceci et le concept a été mis de côté.

Il existe des livrables, plus particulièrement les kernelx, qui nécessitent la vitesse offerte par plusieurs points de sortie. Ces environnements ont normalement leur propre gestion de la mémoire et des processus, ce qui réduit le risque de fuite.

Personnellement, j’aime avoir un seul sharepoint sortie, car je l’utilise souvent pour insérer un point d’arrêt dans l’instruction return et effectuer un code inspectant la façon dont le code a déterminé cette solution. Je pourrais simplement aller à l’entrée et passer à travers, ce que je fais avec des solutions largement nestedes et récursives. En tant que réviseur de code, plusieurs retours dans une fonction nécessitent une parsing beaucoup plus approfondie. Par conséquent, si vous le faites pour accélérer l’implémentation, vous volez Peter pour sauver Paul. Il faudra plus de temps dans les examens de code, ce qui invalidera la présomption d’une mise en œuvre efficace.

– 2 cents

S’il vous plaît voir cette doc pour plus de détails: NISTIR 5459

À mon avis, le conseil de quitter une fonction (ou une autre structure de contrôle) en un seul point est souvent survendu. Deux raisons sont généralement données pour sortir en un seul point:

  1. Le code de sortie unique est censé être plus facile à lire et à déboguer. (J’avoue que je ne pense pas beaucoup à cette raison, mais c’est donné. Ce qui est beaucoup plus facile à lire et à déboguer est le code à entrée unique.)
  2. Le code de sortie unique relie et renvoie plus proprement.

La deuxième raison est subtile et présente des avantages, surtout si la fonction renvoie une grande structure de données. Cependant, je ne m’en soucierais pas trop, sauf que …

Si un étudiant, vous voulez gagner les meilleures notes dans votre classe. Faites ce que l’instructeur préfère. Il a probablement une bonne raison de son sharepoint vue; donc, à tout le moins, vous apprendrez son sharepoint vue. Cela a de la valeur en soi.

Bonne chance.

J’étais un défenseur du style de sortie unique. Mon raisonnement est venu principalement de la douleur …

La sortie unique est plus facile à déboguer.

Étant donné les techniques et les outils dont nous disposons aujourd’hui, cette position est beaucoup moins raisonnable, car les tests unitaires et la journalisation peuvent rendre une sortie unique nécessaire. Cela dit, lorsque vous avez besoin de regarder du code s’exécuter dans un débogueur, il était beaucoup plus difficile de comprendre et de travailler avec du code contenant plusieurs points de sortie.

Cela est devenu particulièrement vrai lorsque vous deviez interjecter des assignations afin d’examiner l’état (remplacé par des expressions de surveillance dans les débogueurs modernes). Il était également trop facile de modifier le stream de contrôle de manière à cacher le problème ou à briser l’exécution.

Les méthodes de sortie unique étaient plus faciles à parcourir dans le débogueur et plus faciles à démêler sans rompre la logique.

La réponse est très dépendante du contexte. Si vous faites une interface graphique et que vous avez une fonction qui initialise les API et ouvre les fenêtres au début de votre main, elle sera pleine d’appels pouvant générer des erreurs, chacune provoquant la fermeture de l’instance du programme. Si vous avez utilisé des instructions IF nestedes et indentées, votre code pourrait rapidement devenir très asymésortingque. Revenir sur une erreur à chaque étape peut être meilleur et en fait plus lisible tout en étant tout aussi facile à déboguer avec quelques indicateurs dans le code.

Si, toutefois, vous testez des conditions différentes et renvoyez des valeurs différentes en fonction des résultats de votre méthode, il peut être préférable d’avoir un seul sharepoint sortie. J’avais l’habitude de travailler sur des scripts de traitement d’image dans MATLAB qui pourraient devenir très volumineux. Plusieurs points de sortie peuvent rendre le code extrêmement difficile à suivre. Les déclarations de changement étaient beaucoup plus appropriées.

La meilleure chose à faire serait d’apprendre au fur et à mesure. Si vous écrivez du code pour quelque chose, essayez de trouver le code d’autres personnes et de voir comment elles l’implémentent. Décidez quels bits vous aimez et quels bits vous ne voulez pas.