Est-ce une bonne pratique de nommer la variable renvoyée "résultat"?
Est-ce une bonne pratique d'appeler la variable renvoyée par une méthode avec un nom de variable result?
Par exemple:
public Zorglub calculate() {
Zorglub result = [...]
[...]
return result;
}
Ou devrais-je le nommer par son type?
public Zorglub calculate() {
Zorglub zorglub = [...]
[...]
return zorglub;
}
J'ai vu les deux à l'état sauvage, si je dois en choisir une, quelles raisons pourraient me faire préférer l'ancien ou le dernier (ou un meilleur nom)?
Je pense principalement à Java.
S'il s'agit d'une variable de méthode, cela dépend vraiment de la lisibilité.
Étant donné que vous avez déjà le nom du type dans la déclaration de variable et le type de retour de la méthode, vous pourriez aussi bien utiliser result - il décrit le rôle de la variable.
La lecture croisée est facilitée si la variable est nommée result. Cela rend votre intention claire.
Si j'ai besoin d'une variable de retour (ce qui arrive en fait rarement), je l'appelle toujours ret et je la définis toujours juste en dessous de la fonction tête. La fonction a déjà un nom, qui dit tout sur ce qu'elle retourne.
Si j'ai myFunction je pourrais nommer sa variable de retour myFunctionReturnValue pour dire exactement la même chose, seulement je dois le dire explicitement à chaque fois. Étant donné que les fonctions doivent généralement être courtes, il n'est pas nécessaire de fournir une telle explication. Et même si je perds la trace, je peux passer à la déclaration et atterrir juste en dessous de la définition de la fonction.
Mais tout autre nom, qui n'implique pas implicitement (comme ret ou result) ni explicitement (comme myFunctionReturnValue ou myFunctionResult), que c'est le la fonction de retour des fonctions en cours est trop générique.
Dans votre deuxième exemple, zorglub est un choix terrible. Tout ce que la déclaration me dit vraiment, c'est que vous avez créé une variable, dont le nom est égal à l'annotation de type trouvée juste à côté du nom. C'est à peu près aussi utile que int someInt ou Zorglub z.
Dans votre premier exemple, quand je regarde le code, je vois d'abord le nom de la fonction, qui me dit, que cette fonction calcule un Zorglub. En lisant la deuxième ligne, je vois "ok, voici le zorglub, qui va être retourné, mais il ne peut évidemment pas être renvoyé tout de suite et est donc stocké dans la variable result" (comme un côté note: Si vous n'allez pas réaffecter la valeur, alors vous déclarez mieux la variable finale pour communiquer cela), puis je pense "alors maintenant voyons ce qui lui arrive avant qu'elle ne soit retournée". Contrairement au premier exemple, je n'ai pas besoin de lire plus loin pour savoir que ceci est la variable, qui va être retournée et que Je veux suivre le corps de la fonction si je veux le comprendre.
Vous voudrez peut-être lire Programmation Spartiate , ce qui est plutôt lié à votre question.
Dans votre deuxième exemple, vous confondez le type du résultat avec ce que c'est.
Zorglub zorglub;
me dit juste que c'est un Zorglub, deux fois. Trois fois si je prends la peine de lire le type de retour de la méthode. cependant,
double variance;
par exemple, me donne un indice sur la valeur de retour signifie, en termes de sémantique du programme. Cela peut ou non être plus clair que simplement l'appeler result, selon la taille de la méthode - c'est un appel de jugement pour chaque méthode IMO.
Si vous jouez avec de nombreux objets Zorglub dans vos méthodes, vous "pourriez" faire une erreur et renvoyer la mauvaise, ou/et vous pourriez être tenté de nommer les autres zorglub1, zorglub2, etc.
Si vous le nommez result, vous n'avez aucune chance de faire une telle erreur. De plus, je trouve que c'est un bon nom; J'ai également vu returnedValue ou returnedObject plusieurs fois, c'est aussi clair bien qu'un peu long.
Personnellement, je ne suis pas complètement à l'aise d'utiliser result comme nom de variable. Assez juste, cela me dit que la valeur associée est le résultat d'un calcul - cependant, je suppose que cela est vrai pour environ (ou plus) 90% des variables/champs utilisés dans un programme.
De plus, comme plusieurs autres réponses l'ont noté, il peut être utilisé pour marquer la valeur à renvoyer d'une méthode/fonction. Cependant, si je garde mes méthodes courtes, concentrées sur une seule chose et en restant constamment sur un seul niveau d'abstraction, je n'aurai pas beaucoup de variables locales et il sera trivial de voir ce qu'une méthode va retourner.
Je préfère donc garder mes méthodes courtes et propres, et nommer mes variables pour exprimer ce qui signifie de la valeur qu'elles détiennent, plutôt que son rôle local à l'intérieur de la méthode englobante. Cependant, (par exemple dans le code hérité) Zorglub result peut être plus facile à comprendre que Zorglub zorglub.
dois-je le nommer par son type?
Non jamais. C'est ce qu'on appelle les systèmes hongrois et est trivialement obsolète par l'idée d'utiliser un programme qui peut afficher le type de n'importe quelle variable chaque fois que vous en avez besoin.
Chaque fois que vous devez nommer n'importe quoi dans le code, vous devez fournir des noms descriptifs, significatifs et lisibles. Le cas d'une variable de retour est un exemple particulièrement bon de cas où les gens ont tendance à devenir complaisants à propos de la dénomination.
Si vous avez une fonction clairement nommée et que vous n'avez besoin que d'une seule ligne de code, vous pouvez ignorer entièrement la dénomination. Rendre vos méthodes courtes et uniques est toujours l'idéal que vous devriez viser. Cependant, il arrive que vous ayez parfois besoin de remplir une fonction avec plusieurs lignes de code. Dans ces cas, il est toujours conseillé de nommer votre variable pour qu'elle corresponde à l'objectif de votre fonction.
Si le but de la fonction est de renvoyer le résultat d'un calcul ou d'un algorithme de décision, alors result est un nom parfaitement adéquat pour votre variable à utiliser, mais que se passe-t-il si votre fonction renvoie un élément d'une liste? Et si votre fonction sert un autre objectif qui n'a rien à voir avec les mathématiques ou les listes? Dans ces cas, il est préférable de fournir à la variable un nom significatif qui se rapporte à la raison pour laquelle la fonction a été créée. Bien sûr, vous pouvez simplement utiliser result si vous le souhaitez, car il s'agit d'un nom qui ne risque pas de se heurter à quoi que ce soit d'autre, mais du point de vue de la lisibilité, il est plus logique de nommer votre variable de manière plus significative et plus contextuelle.
J'utilise personnellement le nom result pour la valeur à renvoyer de la fonction/méthode. Il indique clairement que c'est la valeur à renvoyer. Le nommer par type ne semble pas utile, car il peut y avoir plus d'une variable de ce même type.
Quelle est la différence? ce sont juste 2 mots différents qui feront la même chose, donc le vrai problème est celui qui vous semble le plus clair?
Le "résultat" ou "zorglub".
Je préférerais utiliser ZorglubResult pour un démarreur pour voir que le résultat retourne deZorglub plus facile à comparer avec d'autres résultats que vous pourriez avoir et son résultat comme vous pouvez le voir. .
Dans une fonction récursive, il est souvent efficace de porter le résultat d'étape en étape, pour réaliser une optimisation d'appel de queue. Pour signaler à l'utilisateur qu'il n'a pas besoin de fournir un paramètre, il peut être raisonnable de nommer un paramètre "résultat":
def removeOccurence [A] (slice: Seq[A], original: Seq[A]) = {
@scala.annotation.tailrec
def remove (leftOriginal: Seq[A], result: Seq[A]) : Seq[A] =
trimStart (slice, leftOriginal) match {
case (h :: tail) => remove (tail, h +: result)
case (Nil) => result.reverse
}
remove (original, Nil)
}
Mais le plus souvent, j'utilise "porter" et "sofar", que j'ai vu dans la nature, et qui portent l'idée encore mieux, dans la plupart des cas.
Une deuxième raison est bien sûr, si votre sujet suggère le mot "résultat", par exemple si vous faites une évaluation arithmétique. Vous pouvez analyser la formule, remplacer les variables par des valeurs et calculer un résultat à la fin.
Une troisième raison a déjà été mentionnée, mais j'ai une petite déviation: vous écrivez une méthode qui effectue un travail, disons qu'elle évalue une forme de '' max ''.
def max = {
val result = somethingElseToDo
if (foo) result else default
}
Au lieu d'appeler le résultat '' result '', nous pourrions l'appeler '' max '', mais dans certaines langues vous pouvez omettre les parenthèses lors de l'appel d'une méthode, donc max serait un appel récursif à la méthode elle-même.
En général, je préférerais un nom qui indique le résultat. Mais si ce nom est déjà pris, peut-être par plus d'une variable, attribut ou méthode, car il existe un champ GUI, une représentation sous forme de chaîne, un numérique et un pour la base de données, l'utilisation d'un autre augmente la probabilité de confusion. Dans les méthodes courtes de 3 à 7 lignes, "résultat" ne devrait pas être un problème pour un nom.
En Object Pascal, ce n'est pas un choix. Vous devez affecter une valeur à la variable Result quelque part dans le code de la fonction.
Exemple:
function AddIntegers( A,B: Integer): Integer;
begin
Result := A + B;
end;
Donc, pour moi, c'est assez naturel d'avoir une variable "Résultat" (ou "Retorno", comme je l'orthographe en portugais pour éviter tout conflit de nom avec les mots réservés de la langue) pour recevoir une valeur de retour.
Bien sûr, si c'est une expression très simple dans un langage dérivé de C, je ne prendrai pas la peine de déclarer une variable de résultat - renvoyant l'expression directement.
ce n'est pas seulement ce que vous nommez le résultat (je suis particulier à "r"), mais aussi comment il est utilisé. par exemple, si vous allez avoir une variable de retour, alors chaque instruction de retour devrait la renvoyer. ne pas avoir 'return r;' à la fin, mais saupoudrez des choses comme 'return m * x + b; "dans toute la méthode/fonction. utilisez" r = m * x + b; retourner r; "à la place.
J'aime les combiner, montre de quoi il s'agit et qu'il est destiné à être rendu.
donc dans votre exemple ce serait resultZorglub
si ce que c'est n'a pas vraiment d'importance ce ne serait que résultat (pas resultString)
Je ne vois pas beaucoup de différence entre définir une valeur de retour à un moment donné et ensuite utiliser des conditions pour ignorer tout le code qui pourrait le modifier, et returning tout de suite, alors je vais pour le retour direct, donc il n'y a pas de variable result.
Si vous avez une valeur intermédiaire qui peut ou non être modifiée par du code conditionnel, ce n'est pas (encore) un résultat, donc elle ne devrait certainement pas être nommée ainsi.
Quand je travaillais en C++ et je suppose que cela peut s'appliquer en Java Je l'ai fait.
par exemple.
int Width() const
{
Requires(....);
Requires(....);
//calculation
Ensures(...);
Ensures(...);
return Result;
}
Ceci est conçu par contrat, car le bloc de vérification doit être à la fin de la méthode. Mais le retour doit être le dernier. Nous avions la règle que le résultat de retour était la seule chose qui pouvait suivre le bloc assurer.