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

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

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

var _ = obj && obj._;

---

我想了解为什么它返回的结果是

obj.fn（）

（如果定义了）或

obj.\u

，而不是布尔结果。

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

其次，它允许您按照以下方式完成作业：

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

将返回布尔值

更新

请注意，这是基于我的测试。我不能完全依靠

它是一个不赋值的表达式。而是分配计算值

让我们看看这个表达式

一个示例表达式：

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._

你的表情：

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._

另一种说法是：

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._

另一种说法是：

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._

---

在JavaScript中，

|

和

&&

都是逻辑短路运算符，从左到右求值时返回第一个完全确定的“逻辑值”

在表达式

X | | Y

中，首先计算

X

，并将其解释为布尔值。如果该布尔值为“true”，则返回该值。不计算

Y

。（因为无论

Y

为真还是

Y

为假，

X | | Y

都已完全确定。）这就是短路部分

如果这个布尔值为“false”，那么我们仍然不知道

X | | Y

是true还是false，直到我们计算

Y

，并将其解释为布尔值。然后返回

Y

而

&&

也会执行相同的操作，只是如果第一个参数为false，它会停止计算

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

第二个棘手的部分是，当表达式的计算结果为“false”时，在JS1.0和1.1中，系统将返回一个布尔值“false”；而在JS1.2中，它返回表达式的实际值

在JS

false

，

0

，

-0

，

，
null
，
未定义
，
NaN
和
文档中。全部
全部

当然，为了讨论，我在这里引用逻辑值。当然，文本字符串
“false”
与值
false
不同，因此为true。
我们可以参考JS的规范（11.11）如下：

语义学

生产LogicalANDExpression:LogicalANDExpression&&BitwiseORExpression的计算如下：

评估逻辑表达式
2.调用GetValue（结果（1））

3.调用ToBoolean（结果（2））

4.如果结果（3）为假，则返回结果（2）。

5.计算按位或表达式

6.调用GetValue（结果（5））

7.返回结果（6）

有关规格比较，请参见：

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

与：

返回一个真实的表达式——而不仅仅是true或false——通常会使代码更短，并且仍然可读。这在| |中非常常见，而在&&&中则不常见。
我认为这里有一个基本的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' 

简单来说：

|
操作符返回第一个truthy值，如果没有truthy值，则返回最后一个值（falsy值）

&&
运算符返回第一个falsy值，如果没有falsy值，则返回最后一个值（即真实值）

就这么简单。在您的控制台中进行试验，以便自己查看


console.log（“&&&“Dog”）；//""
console.log（“猫”和“狗”）；//“狗”
console.log（“| |”Dog”）；//“狗”
console.log（“Cat”| |“Dog”）；//“Cat”
在大多数编程语言中，
&&
和
|
运算符返回布尔值在JavaScript中是不同的


或操作员：

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

例1：

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

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

例2：

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

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


和运算符：

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

例1：

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

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

例2：

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

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

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

x | | y
大致对应于：

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

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

和
x&&y
大致对应