Dois-je utiliser `!IsGood` ou `IsGood == false` ?

Question

Je continue à voir du code qui fait des vérifications comme ceci

if (IsGood == false)
{
   DoSomething();
}

ou ceci

if (IsGood == true)
{
   DoSomething();
}

Je déteste cette syntaxe, et utilise toujours la syntaxe suivante.

if (IsGood)
{
   DoSomething();
}

o

if (!IsGood)
{
   DoSomething();
}

Y a-t-il une raison d'utiliser ' == true ou == false ' ?

Est-ce un problème de lisibilité ? Les gens ne comprennent-ils pas les variables booléennes ?

Par ailleurs, y a-t-il une différence de performance entre les deux ?

Answer 1

Je suis la même syntaxe que vous, c'est moins verbeux.

Les personnes (plus débutantes) préfèrent utiliser == true juste pour être sûr que c'est ce qu'ils veulent. Ils ont l'habitude d'utiliser l'opérateur dans leur conditionnel... ils le trouvent plus lisible. Mais une fois que vous êtes plus avancé, vous avez trouvé cela irritant parce que c'est trop verbeux.

Answer 2

Je glousse toujours (ou je jette quelque chose sur quelqu'un, selon mon humeur) quand je tombe sur

if (someBoolean == true) { /* ... */ }

parce que si vous ne pouvez pas compter sur le fait que votre comparaison renvoie un booléen, vous ne pouvez pas non plus compter sur le fait de comparer le résultat à true, donc le code devrait devenir

if ((someBoolean == true) == true) { /* ... */ }

mais, bien sûr, cela devrait être

if (((someBoolean == true) == true) == true) { /* ... */ }

mais, bien sûr...

(ah, la compilation a échoué. Retour au travail.)

Answer 3

Je préférerais plus court variante. Mais parfois == false permet de rendre votre code encore plus court :

Pour les scénarios de la vie réelle dans les projets utilisant C# 2.0, je ne vois qu'une seule bonne raison de procéder ainsi : bool? type. Trois états bool? est utile et il est facile de vérifier une de ses valeurs possibles de cette manière.

En fait, vous ne pouvez pas utiliser (!IsGood) si IsGood es bool? . Mais l'écriture (IsGood.HasValue && IsGood.Value) est pire que (IsGood == true) .

Jouez avec cet échantillon pour vous faire une idée :

bool? value = true; // try false and null too

if (value == true)
{
    Console.WriteLine("value is true");
}
else if (value == false)
{
    Console.WriteLine("value is false");
}
else
{
    Console.WriteLine("value is null");
}

Il y a un autre cas que je viens de découvrir où if (!IsGood) { ... } n'est pas la même chose que if (IsGood == false) { ... } . Mais celui-ci n'est pas réaliste ;) La surcharge d'opérateurs peut aider ici :) (et l'opérateur true/false qui AFAIK est déconseillé en C# 2.0 parce que son but est de fournir un comportement similaire à celui des bool?s pour les types définis par l'utilisateur et maintenant vous pouvez l'obtenir avec les types standards !)

using System;

namespace BoolHack
{
    class Program
    {
        public struct CrazyBool
        {
            private readonly bool value;

            public CrazyBool(bool value)
            {
                this.value = value;
            }

            // Just to make nice init possible ;)
            public static implicit operator CrazyBool(bool value)
            {
                return new CrazyBool(value);
            }

            public static bool operator==(CrazyBool crazyBool, bool value)
            {
                return crazyBool.value == value;
            }

            public static bool operator!=(CrazyBool crazyBool, bool value)
            {
                return crazyBool.value != value;
            }

            #region Twisted logic!

            public static bool operator true(CrazyBool crazyBool)
            {
                return !crazyBool.value;
            }

            public static bool operator false(CrazyBool crazyBool)
            {
                return crazyBool.value;
            }

            #endregion Twisted logic!
        }

        static void Main()
        {
            CrazyBool IsGood = false;

            if (IsGood)
            {
                if (IsGood == false)
                {
                    Console.WriteLine("Now you should understand why those type is called CrazyBool!");
                }
            }
        }
    }
}

Alors... s'il vous plaît, utilisez la surcharge des opérateurs avec prudence :(

Answer 4

Selon Code complet un livre Jeff tient son nom de et tient en haute estime ce qui suit est la façon dont vous devriez traiter les booléens.

if (IsGood)
if (!IsGood)

J'avais l'habitude de comparer les booléens, mais je me suis dit pourquoi ajouter une étape supplémentaire au processus et traiter les booléens comme des types de second ordre. A mon avis, une comparaison renvoie un booléen et un type booléen est déjà un booléen, alors pourquoi ne pas simplement utiliser le booléen.

En réalité, le débat se résume à l'utilisation de bons noms pour vos booléens. Comme vous l'avez fait ci-dessus, je formule toujours mes objets booléens à la manière d'une question. Par exemple

• IsGood
• HasValue
• etc.

Answer 5

La technique consistant à tester spécifiquement contre true ou false est définitivement une mauvaise pratique si la variable en question est réellement censée être utilisée comme une valeur booléenne (même si son type n'est pas booléen) - surtout en C/C++. Tester contre true peut (et va probablement) conduire à des bugs subtils :

Ces tests apparemment similaires donnent des résultats opposés :

// needs C++ to get true/false keywords
// or needs macros (or something) defining true/false appropriately
int main( int argc, char* argv[])
{
    int isGood = -1;

    if (isGood == true) {
        printf( "isGood == true\n");
    }
    else {
        printf( "isGood != true\n");
    }

    if (isGood) {
        printf( "isGood is true\n");
    }
    else {
        printf( "isGood is not true\n");
    }

    return 0;
}

Cela affiche le résultat suivant :

isGood != true
isGood is true

Si vous ressentez le besoin de tester une variable qui est utilisée comme un indicateur booléen contre vrai/faux (ce qui ne devrait pas être fait à mon avis), vous devriez utiliser l'idiome de toujours tester contre faux parce que faux ne peut avoir qu'une seule valeur ( 0 ) alors qu'un vrai peut avoir plusieurs valeurs possibles (tout ce qui est autre que 0 ):

if (isGood != false) ...  // instead of using if (isGood == true)

Certaines personnes penseront qu'il s'agit d'un défaut du C/C++, et c'est peut-être vrai. Mais c'est une réalité dans ces langages (et probablement dans beaucoup d'autres). Je m'en tiendrais donc à l'idiome court, même dans des langages comme C# qui ne permettent pas d'utiliser une valeur entière comme un booléen.

Voir cette question SO pour un exemple de cas où ce problème a réellement touché quelqu'un...

• isalpha() == true est évalué à false ??