我应该使用`!IsGood`还是`IsGood == false`？

Question

我不断看到代码进行这样的检查，

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

我

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

讨厌这种语法，并且始终使用以下语法。

if (IsGood)
{
   DoSomething();
}

或者

if (!IsGood)
{
   DoSomething();
}

是否有任何理由使用“== true”或“== false”？

这是一个可读性的问题吗？ 人们只是不理解布尔变量吗？

另外，两者之间有性能差异吗？

Answer 1

我遵循与您相同的语法，它不那么冗长。

人们（更多的初学者）更喜欢使用 == true 只是为了确保这是他们想要的。 他们习惯于在条件中使用运算符...他们发现它更具可读性。 但一旦你变得更高级，你就会发现它很烦人，因为它太冗长了。

Answer 2

当我遇到时，我总是咯咯地笑（或者向某人扔东西，这取决于我的心情），

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

因为如果你不能依赖比较返回布尔值的事实，那么你也不能依赖将结果与 true 进行比较，所以代码应该变成

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

但是，当然，这真的应该是

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

但是，当然......

（啊，编译失败。回去工作。）

Answer 3

我更喜欢更短的变体。 但有时 == false 有助于使代码更短：

对于使用 C# 2.0 的项目中的现实场景，我认为这样做只有一个很好的理由：bool? 类型。 三态 bool? 很有用，并且可以通过这种方式轻松检查其可能值之一。

实际上，如果 IsGood 是 bool?，则不能使用 (!IsGood)。 但是编写 (IsGood.HasValue && IsGood.Value) 比 (IsGood == true) 更糟糕。

玩一下这个示例来了解一下：

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");
}

我刚刚发现了另一种情况，其中 if (!IsGood) { ... } 与 if (IsGood == false ) { ... }。 但这是不现实的;) 运算符重载可能会有所帮助:) （并且运算符 true/false AFAIK 在 C# 2.0 中不鼓励使用，因为它的预期目的是为用户定义类型提供类似于 bool? 的行为，现在你可以用标准类型得到它！）

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!");
                }
            }
        }
    }
}

所以...请谨慎使用运算符重载:(

Answer 4

根据Code Complete一本书Jeff 的名字来自 并高度评价以下是对待布尔值的方式。

if (IsGood)
if (!IsGood)

我过去常常实际比较布尔值，但我想为什么要在该过程中添加额外的步骤并将布尔值视为二流类型。 在我看来，比较返回一个布尔值，并且布尔类型已经是布尔值，所以为什么不只使用布尔值。

真正的争论归根结底是为你的布尔值使用好名字。 就像你上面所做的那样，我总是在问题的 for 中表达我的布尔对象。 如

• IsGood
• HasValue
• 等。

Answer 5

如果所讨论的变量确实应该用作布尔值（即使其类型不是布尔值），那么专门针对 true 或 false 进行测试的技术绝对是不好的做法 - 特别是在 C/C++ 中。 针对 true 进行测试可能（并且可能会）导致微妙的错误：

这些明显相似的测试给出相反的结果：

// 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;
}

这将显示以下结果：

isGood != true
isGood is true

如果您觉得需要测试用作布尔标志的变量针对 true/false （我认为不应该这样做），您应该使用始终测试 false 的习惯用法，因为 false 只能有一个值 (0)，而 true 可以有多个可能的值值（0 以外的任何值）：

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

有些人会认为这是 C/C++ 中的缺陷，这可能是真的。 但这是这些语言（可能还有许多其他语言）中的一个事实，因此我会坚持使用简短的习惯用法，即使在像 C# 这样不允许您使用整数值作为布尔值的语言中也是如此。

请参阅此问题，了解此问题实际上咬伤某人的示例...

• isalpha() == true 的计算结果为 false？？

Answer 6

我同意你的观点（也对此感到恼火）。 我认为 IsGood == true 计算结果为 bool 这只是一个轻微的误解，这就是 IsGood 的开始。

我经常看到 SomeStringObject.ToString() 的这些邻近实例。

也就是说，在类型处理比较宽松的语言中，这可能是合理的。 但在 C# 中则不然。

Answer 7

有些人发现针对已知值的显式检查更具可读性，因为您可以通过读取来推断变量类型。 我不知道一个是否比另一个更好。 他们都工作。 我发现，如果变量本质上持有“逆”，那么我似乎倾向于检查一个值：

if(IsGood) DoSomething();

或者

if(IsBad == false) DoSomething();

而不是

if(!IsBad) DoSomething();

但是，这对我来说并不重要，而且我确信它最终会成为相同的 IL 。

Answer 8

仅可读性......

如果您喜欢的方式在编译成机器代码时更有效。 但是我希望它们生成完全相同相同的机器代码。

Answer 9

从到目前为止的答案来看，这似乎是共识：

1. 在大多数情况下，简短的形式是最好的。 （IsGood 和 !IsGood）
2. 布尔变量应该写成正数。 （IsGood 而不是 IsBad）
3. 由于大多数编译器都会以任何一种方式输出相同的代码，因此没有性能差异，除了解释语言的情况之外。
4. 这个问题没有明显的赢家，可能会被视为编码风格的宗教战争中的一场战斗。

Answer 10

我更喜欢使用：

if (IsGood)
{
    DoSomething();
}

并且

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

我发现这更具可读性 - ! 太容易错过（无论是阅读还是打字）； 还有“if not IsGood then...”，当我听到它时听起来不太正确，而不是“if IsGood is false then...”，后者听起来更好。

Answer 11

有可能（虽然不太可能，但至少我希望）在 C 代码中 TRUE 和 FALSE 被 #define 为 1 和 0 以外的东西。例如，程序员可能决定使用 0 作为“true”，使用 -1 作为“false” “在特定的 API 中。 对于遗留的 C++ 代码也是如此，因为“true”和“false”并不总是 C++ 关键字，特别是在 ANSI 标准出现之前。

还值得指出的是，某些语言（尤其是 Perl、JavaScript 和 PHP 等脚本语言）可以对哪些值算作 true 和哪些值算作 false 有有趣的解释。 “foo == false”的含义可能与“!foo”略有不同（尽管再次强调，希望不大）。 这个问题被标记为“与语言无关”，并且语言可以将 == 运算符定义为不以与 ! 兼容的方式工作。 操作员。

Answer 12

我将以下内容视为 C/C++ 风格要求。

if ( true == FunctionCall()) {
  // stuff
}

原因是，如果您不小心将“=”而不是“==”，编译器将放弃为常量赋值。 与此同时，它会损害每个 if 语句的可读性。

Answer 13

有时它在可读性方面有用途。 有时，命名变量或函数调用最终可能会成为双重否定，这可能会令人困惑，而像这样明确预期的测试可以提高可读性。

一个很好的例子是 strcmp() C/C++，如果字符串相等则返回 0，否则 << 或> 0，取决于差异在哪里。 所以你会经常看到：

if(strcmp(string1, string2)==0) { /*do something*/ }

一般来说，但我会同意你的观点，这样

if(!isCached)
{
    Cache(thing);
}

读起来更清晰。

Answer 14

我更喜欢 !IsGood 方法，而且我认为大多数具有 C 风格语言背景的人也会更喜欢它。 我只是在这里猜测，但我认为大多数编写 IsGood == False 的人都来自更详细的语言背景，例如 Visual Basic。

Answer 15

唯一更糟糕的是

if (true == IsGood) {....

从来没有理解该方法背后的想法。

Answer 16

当简化为正则表达式时，!IsGood 模式比 IsGood == false 更容易找到。

/\b!IsGood\b/

与

/\bIsGood\s*==\s*false\b/
/\bIsGood\s*!=\s*true\b/
/\bIsGood\s*(?:==\s*false|!=\s*true)\b/

Answer 17

为了便于阅读，您可以考虑一个依赖于另一个属性的属性：

public bool IsBad => !IsGood;

然后，您可以真正理解其含义：

if (IsBad)
{
    ...
}

Answer 18

我更喜欢 !IsGood 因为对我来说，它更加清晰和简洁。 检查 boolean == true 是否是多余的，所以我会避免这样做。 但从语法上来说，我认为检查 IsGood == false 没有区别。

Answer 19

在许多语言中，区别在于，在一种情况下，编译器/解释器决定 true 或 false 的含义，而在另一种情况下，它是由代码定义的。 C 就是一个很好的例子。

if (something) ...

在上面的示例中，“something”与编译器的“true”定义进行了比较。 通常这意味着“不为零”。

if (something == true) ...

在上面的例子中，“某事”与“真实”进行了比较。 “true”的类型（以及因此的可比性）和“true”的值可能由语言和/或编译器/解释器定义，也可能不由语言和/或编译器/解释器定义。

通常两者并不相同。

Answer 20

你忘了：

if(IsGood == FileNotFound)

Answer 21

在我看来（尽管我没有证据支持这一点），从 C#/java 类型语言开始的人更喜欢“if (CheckSomething())”方法，而从其他语言（C++：特别是 Win32）开始的人C++）出于习惯倾向于使用其他方法：在 Win32 中，如果 CheckSomething 返回 BOOL（而不是 bool），“if (CheckSomething())”将不起作用； 在许多情况下，API 函数显式返回 0/1 int/INT，而不是 true/false 值（这就是 BOOL）。

出于习惯，我总是使用更详细的方法。 它们在语法上是相同的； 我不相信“冗长让我恼火”的废话，因为程序员不是需要被代码打动的人（计算机需要）。 而且，在现实世界中，任何查看我编写的代码的人的技能水平都会有所不同，并且我没有时间或意愿向可能不了解一些不重要的事情的人解释语句评估的特殊性。像那样的位。

Answer 22

啊，我有一些同事喜欢较长的形式，认为它比小形式更具可读性！

我开始“修复”这个问题，因为布尔值是自给自足的，所以我放弃了十字军东征... ^_^ 他们不喜欢在这里清理代码，无论如何，他们认为这使得分支之间的集成变得困难（这是事实，但是那么你就永远带着难看的代码生活......）。

如果你正确地书写了布尔变量名，它应该自然地读起来：
if (isSuccessful) 与 if (returnCode)

在某些情况下我可能会沉迷于布尔比较，例如：
if (PropertyProvider.getBooleanProperty(SOME_SETTING, true) == true) 因为它读起来不太“自然”。

Answer 23

出于某种原因，我总是喜欢

if (IsGood)

超过

if (!IsBad)

，这就是为什么我有点喜欢 Ruby 的 except（但它有点太容易滥用）：

unless (IsBad)

如果像这样使用，甚至更多：

raise InvalidColor unless AllowedColors.include?(color)

Answer 24

Cybis，在使用 C++ 进行编码时，您还可以使用 not 关键字。 它是很久以前的标准的一部分，所以这段代码是完全有效的：

if (not foo ())
   bar ();

编辑：顺便说一句，我忘了提及该标准还定义了其他布尔关键字，例如 和 (&&)， 位与 (&)、或 (||)、位或 (|)、异或 (^)。 ..它们被称为运算符同义词。

Answer 25

如果您确实认为需要：

if (Flag == true)

那么由于条件表达式本身就是布尔值，您可能希望将其扩展为：

if ((Flag == true) == true)

等等。 这口棺材还需要多少颗钉子？

Answer 26

如果你碰巧在 perl 中工作，你可以选择

unless($isGood)

Answer 27

我不使用 == 但有时我使用 != 因为它在我的脑海中更清晰。 但在我的工作中，我们不使用 != 或 ==。 我们尝试使用 hasXYZ() 或 isABC() 获取有意义的名称。

Answer 28

就我个人而言，我更喜欢鲍勃叔叔在《干净的代码》中谈论的形式：

(...)
    if (ShouldDoSomething())
    {
        DoSomething();
    }
(...)

bool ShouldDoSomething()
{
    return IsGood;
}

其中条件语句（除了最琐碎的条件之外）都放在谓词函数中。 那么布尔表达式的实现的可读性就不那么重要了。

Answer 29

我们倾向于在这里执行以下操作：

if(IsGood)

或者

if(IsGood == false)

这样做的原因是因为我们有一些由不再在这里（在 Delphi 中）的人编写的遗留代码，看起来像：

if not IsNotGuam then

这在过去给我们带来了很多痛苦，所以我们决定始终尝试检查阳性结果； 如果不可能，则将负数与假数进行比较。

Answer 30

我唯一一次能想到更冗长的代码有意义的是在 .NET Visual Basic 之前的版本中，其中 true 和 false 实际上是整数（true=-1，false=0），而布尔表达式如果计算为零且被认为是 false，对于任何其他非零值均为 true。 因此，在旧版 VB 中，列出的两种方法实际上并不等效，如果您只想在计算结果为 -1 时为 true，则必须显式地与“true”进行比较。 因此，如果计算结果为整数（因为它不为零），则计算结果为“+1”的表达式将为 true，但它不等于“true”。 我不知道为什么 VB 是这样设计的，但我在旧的 VB 代码中看到很多布尔表达式将变量与 true 和 false 进行比较。