为什么 || JavaScript 中的 (or) 和 && (and) 运算符的行为与 C 中的不同（返回非布尔值）？

Question

Consider the following code.

 console.log("All" && 1); // 1 console.log("All" || 1); // "All"

As you can see, the first expression, "All" && 1 , evaluates to 1 . Which is surely not a boolean value (not a true ). I expected here more specifically true. Because I didn't force result as String .

The second expression, "All" || 1 "All" || 1 , to evaluate to All . Which is also not a boolean value.

In C language, the both expression evaluates to 1 . As I force the result to convert in string.

#include <stdio.h>

int main() {
    printf("%d\n", "All" && 1); // 1
    printf("%d\n", "All" || 1); // 1
    return 0;
}

Why does JavaScript behave differently? More specifically Why JS returning a non boolean value?

Answer 1

The logical operators in C always evaluate to boolean values. In C, the int 1 represents true and the int 0 represents false . That's the reason why both the expressions, "All" && 1 and "All" || 1 "All" || 1 , evaluate to 1 . Both of them are logically true. For clarification, consider the following program.

#include <stdio.h>

int main() {
    printf("%d\n", 20 && 10); // 1
    printf("%d\n", 20 || 10); // 1
    return 0;
}

In the above program, the expressions 20 && 10 and 20 || 10 20 || 10 still evaluate to 1 even though there is no 1 in those expressions. This makes sense because both those expressions are logically true. Hence, they evaluate to 1 which is equivalent to true in JavaScript.

If JavaScript behaved the way C did then the expressions "All" && 10 and "All" || 10 "All" || 10 would evaluate to the boolean value true . However, that's not the way the logical operators behave in JavaScript. That's not to say that they are buggy.

Values in JavaScript have a notion of truthiness and falsity. For example, the values true , "All" , 10 , [10, 20] , { foo: 10 } , and x => 2 * x are all truthy. On the other hand, the values false , "" , 0 , undefined , and null are falsy.

The logical operators of JavaScript don't always evaluate to boolean values like C does. Instead, they evaluate to one of their operands. The && operator evaluates to its left operand if it's falsy. Otherwise, it evaluates to the right operand. Similarly, the || operator evaluates to its left operand if it's truthy. Otherwise, it evaluates to the right operand.

Now, the value "All" is truthy. Hence, "All" && 1 evaluates to the right operand (ie 1 ) whereas "All" || 1 "All" || 1 evaluates to the left operand (ie "All" ). Notice that both 1 and "All" are truthy values, which means that they are equivalent to 1 (which represents truthiness) in C.

Hence, no. JavaScript is not buggy.

Answer 2

I quote here from official doc :- Logical AND in JS

The logical AND (&&) operator (logical conjunction) for a set of operands is true if and only if all of its operands are true. It is typically used with Boolean (logical) values. When it is, it returns a Boolean value. However, the && operator actually returns the value of one of the specified operands, so if this operator is used with non-Boolean values, it will return a non-Boolean value.

Let's take some examples,

let a = [1,2,3];
console.log( 0 && a.b ); // return 0
console.log( 1 && a.b ); // return a type error.

In first console.log when JavaScript see 0 at first, JS interpreter stop and return first value.

This is happening because when JS interpreter translate first value to boolean, it evaluated to false . We know the fact that " on any && operator if a single value is false , it will return false .

So JS interpreter here try to save some computation power by returning before, without full statement evaluation. Which is great.

The same is truth for LOGICAL OR (||) operator.