为什么在JavaScript中使用if（myBoolean===true）是一种好的做法？

作为对这一问题的后续行动：-

---

为什么在JavaScript中使用if myBoolean===true是一种好的做法？作为一个相对缺乏经验的JavaScript用户，我试图找出在什么特定的现实场景中，您最终会得到一个布尔值true或truthy值，因此，您需要检查myBoolean===是否为真，而不是myBoolean

我将质疑这个问题的前提：我不认为这是一个好的实践，也不认为这是一个普遍的共识-

使用===true的唯一原因是，如果您不确定myBoolean实际上是一个布尔值，并且如果不是，您希望结果为false。有这样的用例，但它们非常有限。99.9%的情况下，只要myBoolean足够，即使对于1、foo和其他truthy值也是如此

有时出于其他原因使用严格相等是个不错的主意，因为如果操作数类型不同，JavaScript的松散相等规则相当复杂。但是，如果您使用某个对象作为标志，那么在其上使用===几乎没有任何意义

我看到===与布尔值一起使用的一个特殊地方是受jQuery启发的代码，其中回调函数可以通过返回false来取消操作，但不必返回任何内容。当函数没有显式返回值时，调用该函数的结果是未定义的，这当然是错误的。因此，希望检查函数是否返回false（而不仅仅是未定义）的代码将执行以下操作：

if (callback(args) === false) {
    // The callback explicitly returned false (not just a falsey value), cancel
    // ...
}

---

但这是一个相对少见的用例，当然它涉及===假而不是===真…

我将质疑这个问题的前提：我不认为这是一个好的实践，也不认为这是一个普遍的共识-

使用===true的唯一原因是，如果您不确定myBoolean实际上是一个布尔值，并且如果不是，您希望结果为false。有这样的用例，但它们非常有限。99.9%的情况下，只要myBoolean足够，即使对于1、foo和其他truthy值也是如此

有时出于其他原因使用严格相等是个不错的主意，因为如果操作数类型不同，JavaScript的松散相等规则相当复杂。但是，如果您使用某个对象作为标志，那么在其上使用===几乎没有任何意义

我看到===与布尔值一起使用的一个特殊地方是受jQuery启发的代码，其中回调函数可以通过返回false来取消操作，但不必返回任何内容。当函数没有显式返回值时，调用该函数的结果是未定义的，这当然是错误的。因此，希望检查函数是否返回false（而不仅仅是未定义）的代码将执行以下操作：

if (callback(args) === false) {
    // The callback explicitly returned false (not just a falsey value), cancel
    // ...
}

但这是一个相对不常见的用例，当然它涉及===false而不是===true…

一些随机示例：

function CreateSomeObject(param)
{
   if (param == "1")
   {
      return new Stuff();
   }

   return null;
}

var myBoolean = CreateSomeObject("1") || true;

if (myBoolean === true)
{
  //doesn't execute
}

if (myBoolean)
{
   //executes just fine
}

一些随机的例子：

function CreateSomeObject(param)
{
   if (param == "1")
   {
      return new Stuff();
   }

   return null;
}

var myBoolean = CreateSomeObject("1") || true;

if (myBoolean === true)
{
  //doesn't execute
}

if (myBoolean)
{
   //executes just fine
}

---

对于null only，您希望这样做，尽管我从未使用过它，因为它感觉更为冗长和长字符串。使用或避免它都没有问题。这更像是您希望编写代码的风格。

如果仅为null，您希望这样做，尽管我从未使用过它，因为它感觉更为冗长和长字符串。使用它或避免它都没有问题。这更像是你想要编写代码的风格。

我构建了一个稍微复杂的答案，然后意识到主要原因在于虚假的价值观，而不是真实的价值观。通常，一个函数返回一种类型的东西，并且只有一个falsy值——字符串函数的空字符串，或者数字函数的0，或者其他任何值

但是，当您不确定某项内容是否已定义时，它可能具有指导意义：

waitForResponse(request, 5000);
if(!request.ResponseValue) {
    alert('Server failed to respond');
}

vs

尽管我认为你应该检查未定义而不是粗野：

if(typeof request.ResponseValue === 'undefined') {
   //...
}

---

顺便说一句，typeof很快，至少上次我检查时是用Chrome的。

我构建了一个稍微复杂的答案，然后意识到主要原因是虚假的值，而不是真实的值。通常，一个函数返回一种类型的东西，并且只有一个falsy值——字符串函数的空字符串，或者数字函数的0，或者其他任何值

但是，当您不确定某项内容是否已定义时，它可能具有指导意义：

waitForResponse(request, 5000);
if(!request.ResponseValue) {
    alert('Server failed to respond');
}

vs

尽管我认为你应该检查未定义而不是粗野：

if(typeof request.ResponseValue === 'undefined') {
   //...
}

---

顺便说一句，typeof很快，至少上次我检查的时候是在Chrome中。

就我个人而言，我不喜欢这样的说法，比如使用x是一种很好的做法。在我看来，这完全取决于上下文：如果您想检查某个对象是否存在，ifobjectX将像objectX===undefined或typeof objectX==='undefined'一样执行，即使typeof objectX=='undefined'

为什么有些人 ，与Douglas Crockford一样，强烈主张使用值和类型检查===是因为falsy和truthy值在极少数情况下会产生意外的结果：

var falsy = '';
if (falsy)
{//only when falsy is truthy, but an empty string is falsy
    console.log('could be seen as counter-intuitive: var was declared and assigned an empty string, but is falsy');
}
var obj = {falsy:''}
if (!obj.falsy)
{
   console.log('I might assume falsy is not set, although it was:');
   console.log(obj.hasOwnProperty('falsy'));//true
}

同样，这可能只是我的观点，但在绝大多数情况下，这不会破坏您的代码。我甚至更进一步：Douglas Crockford可能会声称使用falsy值检查不是一个好主意，但他确实喜欢逻辑OR | |运算符：

var falsy ='';
var someVar = falsy || 'default value';//this relies heavily on falsy values

严格比较的唯一可靠参数是：

如果您需要将变量设置为布尔值，请再次选择falsy=！！法尔西；强制为布尔值 严格的比较稍微快一点，但是在你能够注意到差异之前，你必须做大量的比较 话虽如此，我确实倾向于使用非常严格的比较，同样，这可能是个人的事情，但我想知道变量的实际类型是什么：假设'1'==1的计算结果为true，但'1'==1为false，它至少允许您将var强制为所需的类型：

var foo = '00001';
var elements = [foo = ('00000' + (+(foo)+1)).substr(-5)];
while(elements[+(foo)-1])
{
    foo = ('00000' + (+(foo)+1)).substr(-5);
    elements.push(foo = ('00000' + (+(foo)+1)).substr(-5));
}

现在这不是你所说的好代码，但是有很多类型的杂耍正在进行。在旅程结束时，您可能想知道分配给foo的值。这在本代码段中不是问题，但假设您希望在while循环中使用foo的数值，如果它是奇数：

var foo = '00001';
var elements = [foo = ('00000' + (+(foo)+1)).substr(-5)];
while(elements[+(foo)-1])
{
    foo = ('00000' + (+(foo)+1)).substr(-5);
    elements.push(foo = ('00000' + (+(foo)+1)).substr(-5));
    if (+(foo)%2 === 1)
    {
        foo = +(foo);
        //do stuff with foo
    }
}

检查天气与否的最简单方法是在循环完成后使用字符串直接检查foo:if foo===+foo

---

我很清楚这个例子有点牵强，但我遇到了一个与此非常相似的例子。在这种情况下，强类型语言的优势才真正显现出来。说到它：新日期>=someDateObject vs日期>=someDateObject。。。在你的控制台中尝试一下，你很快就会明白我在说什么。

就我个人而言，我不喜欢这样的说法，比如使用x是一种很好的做法。在我看来，这完全取决于上下文：如果您想检查某个对象是否存在，ifobjectX将像objectX===undefined或typeof objectX==='undefined'一样执行，即使typeof objectX=='undefined'

有些人，如Douglas Crockford，强烈主张使用值和类型检查===的原因是falsy和truthy值在极少数情况下会产生意外的结果：

var falsy = '';
if (falsy)
{//only when falsy is truthy, but an empty string is falsy
    console.log('could be seen as counter-intuitive: var was declared and assigned an empty string, but is falsy');
}
var obj = {falsy:''}
if (!obj.falsy)
{
   console.log('I might assume falsy is not set, although it was:');
   console.log(obj.hasOwnProperty('falsy'));//true
}

同样，这可能只是我的观点，但在绝大多数情况下，这不会破坏您的代码。我甚至更进一步：Douglas Crockford可能会声称使用falsy值检查不是一个好主意，但他确实喜欢逻辑OR | |运算符：

var falsy ='';
var someVar = falsy || 'default value';//this relies heavily on falsy values

严格比较的唯一可靠参数是：

如果您需要将变量设置为布尔值，请再次选择falsy=！！法尔西；强制为布尔值 严格的比较稍微快一点，但是在你能够注意到差异之前，你必须做大量的比较 话虽如此，我确实倾向于使用非常严格的比较，同样，这可能是个人的事情，但我想知道变量的实际类型是什么：假设'1'==1的计算结果为true，但'1'==1为false，它至少允许您将var强制为所需的类型：

var foo = '00001';
var elements = [foo = ('00000' + (+(foo)+1)).substr(-5)];
while(elements[+(foo)-1])
{
    foo = ('00000' + (+(foo)+1)).substr(-5);
    elements.push(foo = ('00000' + (+(foo)+1)).substr(-5));
}

现在这不是你所说的好代码，但是有很多类型的杂耍正在进行。在旅程结束时，您可能想知道分配给foo的值。这在本代码段中不是问题，但假设您希望在while循环中使用foo的数值，如果它是奇数：

var foo = '00001';
var elements = [foo = ('00000' + (+(foo)+1)).substr(-5)];
while(elements[+(foo)-1])
{
    foo = ('00000' + (+(foo)+1)).substr(-5);
    elements.push(foo = ('00000' + (+(foo)+1)).substr(-5));
    if (+(foo)%2 === 1)
    {
        foo = +(foo);
        //do stuff with foo
    }
}

检查天气与否的最简单方法是在循环完成后使用字符串直接检查foo:if foo===+foo

---

我很清楚这个例子有点牵强，但我遇到了一个与此非常相似的例子。在这种情况下，强类型语言的优势才真正显现出来。说到它：新日期>=someDateObject vs日期>=someDateObject。。。在你的控制台中尝试一下，你很快就会明白我的意思。

如果我比较null、0或有时为false，我通常只使用strict equals===。如果我比较null、0或有时为false，我通常只使用strict equals===。你为什么要这样做？myBoolean在这里甚至不是一个布尔值，它是一个有时包含true的对象……为了示例：如果该函数返回null，它可能是一个布尔值。在我的问题中，真实世界场景（而不是假设的示例）明确地说了这一点。不过谢谢你的帮助：这里的陷阱是防止一些糟糕的编程。漏洞的想法是，您永远不知道var myBoolean可能包含什么。这在现实世界中肯定会发生。你为什么要这样做？myBoolean在这里甚至不是一个布尔值，它是一个有时包含true的对象……为了示例：如果该函数返回null，它可能是一个布尔值。在我的问题中，真实世界场景（而不是假设的示例）明确地说了这一点。不过谢谢你的帮助：这里的陷阱是防止一些糟糕的编程。洞的想法是，你永远不知道什么是var mym

---

等等。这在现实世界中肯定会发生。这不仅仅是样式，比如说函数返回字符串或false来指示发生了什么。如果您只使用==，那么当它返回时，您将得到一些奇怪的结果，因为==false为true。但是false不是0还返回true，如果您不知道它可能会导致问题。它不仅仅是样式，比如说函数返回字符串或false以指示发生了什么。如果您只使用==，那么当它返回时，您将得到一些奇怪的结果，因为==false为true。但是false不是0还返回true，如果您不知道，则可能会导致问题。您的第一个if语句不正确。该日志将不会运行，因为它是falsy，因此if语句失败。第二个将成功运行日志。@Chad，你说得对。。。这是我想说清楚的，但我没有澄清什么可能被视为违反直觉。在这种情况下，如果你的陈述不正确，我将编辑我的回答。该日志将不会运行，因为它是falsy，因此if语句失败。第二个将成功运行日志。@Chad，你说得对。。。这就是我想澄清的，但我没有澄清什么可能被视为违反直觉，在这种情况下，将编辑我的答案这是一个没有任何正确答案的问题，主观。这是一个没有任何正确答案的问题，主观。