与javascript中的布尔/布尔比较

您应该使用==或===与js中的布尔值/布尔值进行比较吗？ 问题是：

> true == new Boolean(true)
< true
> true === new Boolean(true)
< false

}

您可以尝试使用该方法获取包装布尔值的基础值：

function isTrue(b) { 
   return b.valueOf() === true; 
}

isTrue(true);                      // true
isTrue(new Boolean(true));         // true
isTrue(false);                     // false
isTrue(new Boolean(false));        // false
isTrue("true");                    // false

但是，我应该注意，可以为自定义类型甚至内置类型重写此函数，例如：

Boolean.prototype.valueOf = function () { return true; }; 
isTrue(false);                     // true

还要注意，这个简单的示例不处理

null

或

未定义的值

但一般来说，我不会在库中使用这种方法进行通用参数验证。我认为，如果用户传入一个
新布尔值（true）
，他们可能有这样做的特定原因（或者说，这是他们代码中的一个bug）。
一般来说，如果你知道你在处理对象变量，那么从性能和可读性的角度来看，坚持使用
.valueOf（）会更好===一些布尔值，而不是使用非严格的equals。例如：

var b = new Boolean(true);
b.valueOf() === true; // true

通常最好避免没有特定原因的布尔对象，因为这种混淆会很快导致bug。它还可以在重要的时候产生更精简、更快的代码

var b = new Boolean(foo);

// ...

if (!b) {
  // This always executes, leading to some impossibly hidden bugs.
}

我想出了这个解决办法

function typeOf(obj) {
  return Object.prototype.toString.call(obj).slice(8, -1);
}

function foo(bar){
  if((typeOf(bar) === 'Boolean' && bar.valueOf() === true) || bar === true){
     // is this perfect though ?
  }
}



> Object.prototype.toString.call(true)
< "[object Boolean]"
> Object.prototype.toString.call(false)
< "[object Boolean]"
> Object.prototype.toString.call(Boolean(true))
< "[object Boolean]"
> Object.prototype.toString.call(Boolean(false))
< "[object Boolean]"
> Object.prototype.toString.call(new Boolean(true))
< "[object Boolean]"
> Object.prototype.toString.call(new Boolean(false))
< "[object Boolean]"
> Object.prototype.toString.call(undefined)
< "[object Undefined]"
> Object.prototype.toString.call(null)
< "[object Null]"
> Object.prototype.toString.call(1)
< "[object Number]"

功能类型（obj）{
返回Object.prototype.toString.call（obj.slice）（8，-1）；
}
函数foo（bar）{
if（（typeOf（bar）=='Boolean'&&bar.valueOf（）==true）| | bar==true）{
//这是完美的吗？
}
}
>Object.prototype.toString.call（true）
<“[对象布尔值]”
>Object.prototype.toString.call（false）
<“[对象布尔值]”
>Object.prototype.toString.call（布尔值（true））
<“[对象布尔值]”
>Object.prototype.toString.call（布尔值（false））
<“[对象布尔值]”
>Object.prototype.toString.call（新布尔值（true））
<“[对象布尔值]”
>Object.prototype.toString.call（新布尔值（false））
<“[对象布尔值]”
>Object.prototype.toString.call（未定义）
<“[对象未定义]”
>Object.prototype.toString.call（null）
<“[对象空值]”
>Object.prototype.toString.call（1）
<“[对象编号]”
没有充分的理由使用
new Boolean（）
。这些对象的行为不像布尔对象
new Boolean（false）
是真实的。除了@Barmar，很少有情况下需要
x==true
。如果您正在检查真实性，
x
就足够了；如果你想知道它是否是准确的
true
，你需要写
x==true
@Amadan我的观点是如果你使用
new Boolean
，那么
x
根本不起作用，因为
new Boolean（true）
和
new Boolean（false）
都是真实的。@Barmar：我同意你的观点。我想我不清楚。1） 不要使用
Boolean
，2）如果你使用基本布尔，不要使用
x==true
@p.s.w.g
typeof bar===“Boolean”&&bar
，这和
bar==true
不一样吗？你的
数字.p.valueOf
示例毫无意义，因为123一开始就是真的。我建议编辑来修正这个错误。@impinball这不是毫无意义的。在不重写该方法的情况下，
isTrue（123）
→ <代码>错误
。请记住，此方法不会测试a
b
是否真实，而是测试其原始值是否完全等于
true
。哦。没有意识到这一点。@pswg我仍然保留了我的编辑，因为它还提到了真实性/错误性，这也可能会起作用。@impinball谢谢，我编辑它是为了提供一个更清楚的示例，说明如何颠覆这个方法。我只是意识到我可以只做
bar.valueOf（）==true
。
var b = new Boolean(foo);

// ...

if (!b) {
  // This always executes, leading to some impossibly hidden bugs.
}

function typeOf(obj) {
  return Object.prototype.toString.call(obj).slice(8, -1);
}

function foo(bar){
  if((typeOf(bar) === 'Boolean' && bar.valueOf() === true) || bar === true){
     // is this perfect though ?
  }
}



> Object.prototype.toString.call(true)
< "[object Boolean]"
> Object.prototype.toString.call(false)
< "[object Boolean]"
> Object.prototype.toString.call(Boolean(true))
< "[object Boolean]"
> Object.prototype.toString.call(Boolean(false))
< "[object Boolean]"
> Object.prototype.toString.call(new Boolean(true))
< "[object Boolean]"
> Object.prototype.toString.call(new Boolean(false))
< "[object Boolean]"
> Object.prototype.toString.call(undefined)
< "[object Undefined]"
> Object.prototype.toString.call(null)
< "[object Null]"
> Object.prototype.toString.call(1)
< "[object Number]"