web-dev-qa-db-fra.com

Meilleure pratique Boolean Affectation

Je suis tombé sur le suivant dans un programme que j'ai repris d'un autre développeur:

if (obj.Performance <= LOW_PERFORMANCE)
{
    obj.NeedsChange = true;
}
else
{
    obj.NeedsChange = false;
}

Je crois que ce code est redondant et moche, je l'ai donc changé à ce que je pensais être une simple affectation booléenne basée sur une comparaison:

obj.NeedsChange = obj.Performance <= LOW_PERFORMANCE;

En voyant cela, quelqu'un examine mon code a commenté que, bien que mon changement soit fonctionnel fonctionnel, cela pourrait confondre quelqu'un d'autre la regarder. Il croit que l'utilisation d'un opérateur ternaire rend cette mission plus claire, alors que je n'aime pas l'ajout de code plus redondant:

obj.NeedsChange = (obj.Performance <= LOW_PERFORMANCE) ? true : false;

Son raisonnement est que faire quelque chose de la manière la plus concise ne vaut pas la peine, s'il provoque un autre développeur de s'arrêter et de réfléchir exactement à ce que vous avez fait.

La vraie question ici est laquelle de ces trois méthodes d'attribution d'une valeur au booléen obj.NeedsChange est le plus clair et le plus maintenu?

clean-codemaintainabilityboolean
10
Zach Posten

Je préfère 2, mais je pourrais aller pour un petit ajustement:

obj.NeedsChange = ( obj.Performance <= LOW_PERFORMANCE );

Pour moi, les parenthèses facilitent la ligne d'analyser et indique clairement d'un coup d'œil que vous attribuez le résultat d'une comparaison et n'effectuez pas une double affectation. Je ne sais pas pourquoi cela est (comme je ne peux pas penser à une langue où les parenthèses empêcheraient une double affectation), mais si vous devez satisfaire à votre critique, cela sera peut-être un compromis acceptable.

39
Jacob Raihle

La variante 1 est facilement comprise, mais c'est son seul avantage. Je suppose automatiquement que quiconque écrit comme ça ne comprend pas vraiment ce que les booléens portent tous et écriront de la même manière infantile de code de nombreux autres égards.

Variante 2 est ce que j'écris toujours et attendez-vous à lire. Je pense que quiconque est confondu par cet idiome ne devrait pas être un écrivain professionnel de logiciels.

La variante 3 combine les inconvénients des 1 et 2. 'Nuff dit.

23
Kilian Foth

Chaque code est plus compliqué qu'il n'a pas besoin de déclencher un "Qu'est-ce que c'est censé faire?" sentir dans le lecteur.

Par exemple, le premier exemple me fait me demander ", y avait-il d'autres fonctionnalités dans la déclaration if/else à un moment donné qui a été supprimée?"

L'exemple (2) est simple, clair et fait exactement ce qui est nécessaire. Je le lis et comprends immédiatement ce que le code fait.

Le fluff supplémentaire de (3) me ferait de me demander pourquoi l'auteur l'a écrit de cette façon au lieu de (2). Là-bas devrait être une raison, mais dans ce cas, il ne semble pas y avoir, donc ce n'est pas utile du tout et plus difficile de lire car la syntaxe suggère quelque chose de cadeau qui n'est pas présent. Essayer d'apprendre ce qui est présent (quand rien n'est) rend le code plus difficile à lire.

13
enderland

Il est facile de voir que la variante 2 et la variante 1 sont liées via une série de refacteurs évidents et simples:

if (obj.Performance <= LOW_PERFORMANCE)
{
    obj.NeedsChange = true;
}
else
{
    obj.NeedsChange = false;
}

Ici, nous avons une duplication de code inutile, nous pouvons facturer la mission:

obj.NeedsChange = if (obj.Performance <= LOW_PERFORMANCE)
{
    true
}
else
{
    false
}

ou écrit plus concis:

obj.NeedsChange = if (obj.Performance <= LOW_PERFORMANCE) true else false

Maintenant, il devrait être immédiatement évident que cela attribuera true si la condition est vraie et assignez false si la condition est fausse, elle affectera simplement la valeur de la condition, c'est-à-dire équivalente à

obj.NeedsChange = obj.Performance <= LOW_PERFORMANCE

Les variantes 1 et 3 sont un code de recrue typique écrit par une personne qui ne comprend pas quelle est la valeur de retour d'une comparaison.

2
Jörg W Mittag

La plupart des développeurs seront en mesure de comprendre la 2e forme avec un coup d'œil. À mon avis sur la simplification, comme dans la 1ère forme, il n'est tout simplement pas nécessaire.

Vous pouvez améliorer la lisibilité en ajoutant des espaces et des bretelles telles que:

obj.NeedsChange =    obj.Performance <= LOW_PERFORMANCE;

ou

obj.NeedsChange = ( obj.Performance <= LOW_PERFORMANCE );

comme mentionné par Jacob Raihle.

1
Uday Shankar