为什么逻辑运算符（&& 和 ||）不总是返回布尔结果？

Question

为什么这些逻辑运算符返回一个对象而不是布尔值？

var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} );

var _ = obj && obj._;

我想了解为什么它返回 obj.fn() 的结果（如果已定义）或 obj._ ，但不返回布尔结果。

Answer 1

在 JavaScript 中，|| 和 && 都是逻辑短路运算符，从左到右计算时返回第一个完全确定的“逻辑值”。

在表达式 X || 中Y、X 首先被求值，并解释为布尔值。如果此布尔值为“true”，则返回它。并且 Y 不会被评估。 （因为 Y 为 true 或 Y 为 false 并不重要，X || Y 已完全确定。）短路部分。

如果这个布尔值为“false”，那么我们仍然不知道 X || 是否成立。在我们计算 Y 并将其解释为布尔值之前，Y 要么是 true 要么是 false。那么Y就会被返回。

&& 的作用相同，只是如果第一个参数为 false 则停止计算。

第一个棘手的部分是，当表达式被评估为“true”时，则返回表达式本身。在逻辑表达式中这算作“true”，但您也可以使用它。这就是为什么您会看到返回实际值的原因。

第二个棘手的部分是，当表达式被评估为“false”时，那么在 JS 1.0 和 1.1 中系统将返回一个布尔值“false”；而在 JS 1.2 中它返回表达式的实际值。

在 JS 中 false、0、-0、""、null、<代码>未定义，<代码>NaN和<代码>document.all全部算作 false。

当然，我在这里引用逻辑值是为了讨论。当然，文字字符串 "false" 与值 false 不同，因此为 true。

Answer 2

用最简单的术语来说：

|| 运算符返回第一个真值，如果没有一个真值，则返回最后一个值（这是一个假值）。

&& 运算符返回第一个假值，如果没有假值，则返回最后一个值（这是一个真值）。

真的就是这么简单。在您的控制台中进行实验，亲自看看。

console.log("" && "Dog");    // ""
console.log("Cat" && "Dog"); // "Dog"
console.log("" || "Dog");    // "Dog"
console.log("Cat" || "Dog"); // "Cat"

Answer 3

var _ = ((obj.fn && obj.fn() ) || obj._ || ( obj._ == {/* something */}))? true: false 

将返回布尔值。

更新

请注意，这是基于我的测试。我不应该被完全依赖。

它是一个不分配true 或false 值的表达式。相反，它分配计算值。

我们来看看这个表达式。

表达式示例：

var a = 1 || 2;
// a = 1

// it's because a will take the value (which is not null) from left
var a = 0 || 2;
// so for this a=2; //its because the closest is 2 (which is not null)

var a = 0 || 2 || 1;    //here also a = 2;

您的表达式：

var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} );

// _ = closest of the expression which is not null
// in your case it must be (obj.fn && obj.fn())
// so you are gettig this

另一个表达式：

var a = 1 && 2;
// a = 2

var a = 1 && 2 && 3;
// a = 3 //for && operator it will take the fartest value
// as long as every expression is true

var a = 0 && 2 && 3;
// a = 0

另一个表达式：

var _ = obj && obj._;

// _ = obj._

Answer 4

在大多数编程语言中，&& 和 || 运算符返回布尔值。 在 JavaScript 中情况有所不同。

---

OR 运算符：

它返回验证为 true 的第一个操作数的值（如果有），否则返回最后一个操作数的值< /strong>（即使它验证为 false）。

示例 1：

var a = 0 || 1 || 2 || 3;
        ^    ^    ^    ^
        f    t    t    t
             ^
             first operand that validates as true
             so, a = 1

示例 2：

var a = 0 || false || null || '';
        ^    ^        ^       ^
        f    f        f       f
                              ^
                              no operand validates as true,
                              so, a = ''

---

AND 运算符：

返回验证为 true 的最后一个操作数的值（如果所有条件都验证为 true），否则返回验证为 false 的第一个操作数的值。

示例 1：

var a = 1 && 2 && 3 && 4;
        ^    ^    ^    ^
        t    t    t    t
                       ^
                       last operand that validates as true
                       so, a = 4

示例 2：

var a = 2 && '' && 3 && null;
        ^    ^     ^    ^
        t    f     t    f
             ^
             return first operand that validates as false,
             so, a = ''

---

结论：

如果您希望 JavaScript 的工作方式与其他编程语言的工作方式相同，请使用 Boolean() 函数，如下所示：

var a = Boolean(1 || 2 || 3);// a = true

Answer 5

您应该将短路运算符视为条件，而不是逻辑运算符。

<代码>x || y 大致对应于：

if ( x ) { return x; } else { return y; }  

和 x && y 大致对应于：

if ( x ) { return y; } else { return x; }  

鉴于此，结果是完全可以理解的。

---

来自 MDN 文档：

逻辑运算符通常与布尔（逻辑）值一起使用。当它们是时，它们返回一个布尔值。 但是，&&和 ||运算符实际上返回指定操作数之一的值，因此如果这些运算符与非布尔值一起使用，它们将返回非布尔值。

并且 下表包含所有逻辑运算符的返回值。

Answer 6

我认为您在这里有基本的 JavaScript 方法问题。

现在，JavaScript 是一种松散类型的语言。因此，它处理逻辑运算的方式和方式与 Java 和 C++ 等其他标准语言不同。 JavaScript 使用称为“类型强制”的概念来确定逻辑运算的值，并始终返回第一个 true 类型的值。例如，看一下下面的代码：

var x = mystuff || document;
// after execution of the line above, x = document

这是因为 mystuff 是一个先验未定义的实体，在测试时将始终评估为 false因此，JavaScript 会跳过此步骤并测试下一个实体的 true 值。由于 JavaScript 已知文档对象，因此它返回一个 true 值，并且 JavaScript 返回此对象。

如果您想要返回一个布尔值，则必须将逻辑条件语句传递给如下函数：

var condition1 = mystuff || document;

function returnBool(cond){
  if(typeof(cond) != 'boolean'){ //the condition type will return 'object' in this case
     return new Boolean(cond).valueOf();
  }else{ return; }
}    
// Then we test...
var condition2 = returnBool(condition1);
window.console.log(typeof(condition2)); // outputs 'boolean' 

Answer 7

我们可以参考这里的 JS 规范（11.11）：

Semantics

产生式 LogicalANDExpression :LogicalANDExpression &&BitwiseOREExpression 的计算如下：

1. Evaluate LogicalANDExpression。

2.调用GetValue(结果(1))。

3.调用ToBoolean(结果(2))。

4.如果 Result(3) 为 false，则返回 Result(2)。

5.评估 BitwiseOREExpression。

6.调用GetValue(结果(5))。

7.返回结果(6)。

请参阅此处了解规范

Answer 8

首先，它必须是真实的才能返回，所以如果你正在测试真实性，那么它没有什么区别

其次，它允许你按照以下方式进行作业：

function bar(foo) {
    foo = foo || "default value";

Answer 9

比较：

var prop;
if (obj.value) {prop=obj.value;}
else prop=0;

与：

var prop=obj.value||0;

返回一个真实的表达式 - 而不仅仅是 true 或 false - 通常会使你的代码更短并且仍然可读。这对于 || 来说很常见，对于 && 则不太常见。