Pourquoi l'utilisation de conjonctions dans les noms de méthode est-elle une mauvaise convention de dénomination? [fermé]

Dans mon équipe, nous travaillons en étroite collaboration avec quelques architectes logiciels. Ils approuvent toutes les décisions de conception de nos projets, font des revues de code, etc.

Nos projets consistent principalement en des fonctionnalités backend implémentées en PHP utilisant le framework Symfony 2. Donc, syntaxiquement, le code, les conventions de dénomination et la structure du projet semblent presque identiques à ce à quoi Java ressemblerait (Symfony 2 encourage une telle structure). Je le mentionne car les conventions spécifiques à Java s'appliquent également dans notre cas (si possible).

Récemment, ils ont suggéré quelque chose que je trouve très étrange: toutes les méthodes devraient avoir des conjonctions dans leur nom, par exemple getEntityOrNull, setValueOrExceptionetc.

Une telle convention de dénomination me semble très mal, mais je ne peux pas trouver d'arguments concrets ou d'articles / pages en ligne qui contestent spécifiquement cela.

Les seules choses que j'ai trouvées sont:

• ces informations doivent être présentes dans les annotations de la méthode, comme @returnou@throws
• l'utilisation de conjonctions ("et", "ou" etc.) dans les noms de méthode suggère généralement que le principe de responsabilité unique n'est pas correctement respecté

Quels sont les autres arguments concrets contre cette convention de dénomination?

Ils le font probablement en raison de conflits de noms. Je suppose que vous ne pouvez pas avoir deux méthodes nomméesgetEntity , l'une qui peut éventuellement déclencher une exception et l'autre qui revient null. Par conséquent, vous devez les nommer en conséquence.

Pour ma part, je n'aime pas la pratique d'avoir de nombreuses façons différentes d'appeler la même méthode, sauf si elle effectue une modification que seule cette classe particulière peut effectuer.

En d'autres termes, si getValueOrNullest simplement en train d'appeler getValueOrException, de capturer l'exception, et dans ce cas de revenir null, cela peut être effectué par l'appelant. Il encombre la classe avec des méthodes qui ne contribuent vraiment à rien d'utile. Je préférerais plutôt le getValue, et je sais que cela lève l'exception. Mieux encore, je préférerais savoir que toutes les méthodes get peuvent potentiellement générer des exceptions, et aucune ne retourne à la nullplace de sorte que le comportement soit uniforme tout au long de mon projet, ou inversement, toutes potentiellement retournentnull , et sachez que l'appelant devrait lever une exception si qui étaient souhaités.

Cependant, il est également vrai que vous n'êtes pas responsable de cela. Mon conseil est d'en parler, mais ne vous inquiétez pas des petites choses. En fin de compte, la responsabilité de telles conventions de dénomination incombe à leurs épaules, qu'elles suivent ou non vos conseils, et parce que ce sont leurs fesses en jeu, je pense que c'est leur prérogative de dire non, à mon humble avis.

Bien que l'utilisation de conjonctions indique souvent une violation du SRP, dans ce cas, elle indique simplement la valeur de retour du type de données algébrique d'un pauvre qui peut être l'une des deux valeurs, soit nullune valeur de «succès».

Ils utilisent une sorte de notation hongroise pour compenser les faiblesses du système de types, à savoir le manque de types non annulables. En d'autres termes, il n'y a aucun moyen de spécifier dans votre @returnannotation que la fonction ne retournera jamais null, et inversement, il n'y a aucun moyen de spécifier dans votre @returnannotation que la fonction peut éventuellement retourner null.

De plus, je pense que les @throwsannotations ne sont pas obligatoires en php, donc l'absence d'annotation n'indique pas l'absence d'exception, bien que cela soit mieux résolu en rendant l'annotation obligatoire dans votre guide de style.

Compte tenu de ces limites de la langue que vous utilisez, ce n'est pas un style totalement déraisonnable.

Dans mon code, je crée parfois des paires de méthodes avec des noms comme getEntity () et getEntityOrNull (). Le nom indique clairement le comportement attendu. Si getEntity () ne trouve aucune entité, une exception est levée. getEntityOrNull () renverra un null.

Ce faisant, le code appelant devient un peu plus clair. Si le code appelant doit avoir une entité, getEntity fera l'affaire. Si l'entité est une sorte de chose facultative, alors getEntityOrNull est la méthode de choix.

La même chose pourrait être accomplie avec une seule méthode mais qui transfère ensuite une partie de la charge au programme appelant. Vous devez toujours tester une valeur nulle ou vous avez besoin d'un bloc try / catch. Quoi qu'il en soit, c'est du code supplémentaire qui doit être dupliqué à chaque appel de la méthode.

Si vos architectes n'utilisent pas ces sortes de paires de méthodes, alors oui, je remettrais en question la nécessité du suffixe.

Jamais vraiment vu une méthode setValueOrException. Je ne peux pas penser à un bon cas d'utilisation commun pour cela.

Vous pourriez envisager de demander aux architectes pourquoi. Ceux que je connais sont toujours heureux d'expliquer leurs décisions. Souvent dans les moindres détails (et parfois atroces).

Vos deux arguments sont solides. Mais si ce sont eux qui sont chargés de décider de la convention de dénomination, essayez de ne pas vous sentir trop mal à l'idée que ce soit quelque chose avec lequel vous n'êtes pas d'accord.

Pendant que vous y êtes, vous devez les convaincre de ne pas utiliser les parties "get" et "set" à moins que ces méthodes ne définissent ou obtiennent directement une variable membre.