JavaScript Interview Question #18: What's the sum of two booleans in JavaScript?

Can you add booleans in JS? Is something false here? What will be logged to the screen?

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

Just as in the previous test, we’re dealing here with type conversion and loose equality using the == operator.

When JavaScript evaluates the expression true + true it first converts booleans to numbers, which is 1 for true and 0 for false.

When we try to do calculate the value of 2 == true, the typecast happens again and we arrive at the final condition 2 == 1.

The result is obviously false, so we go into the else branch.

To understand how type conversion works with the + operator and different data types, you can read this article.

---

ANSWER: the string everyone is different after all will be logged to the console.

Learn Full Stack JavaScript

Comments

[lionel-rowe]

You can use this property of booleans to implement an exclusive or:

const xor = (...bools) =>
    bools.reduce(
        (total, bool) => total + bool,
        0,
    ) === 1

xor(true, false) // true
xor(true, true, false) // false
xor(false, false) // false
xor(true) // true

[willsmart]

Or count things cleanly...

isEven = v => !(v & 1)

 // count the even numbers in an array
[1,2,3,4,5,6,7].reduce((acc, v)=> acc + isEven(v), 0) // <- 3

[lionel-rowe]

Now I think about it, filter with length would be simpler in both cases

const xor = (...bools) =>
    bools.filter(x => x).length === 1

const countEven = arr =>
    arr.filter(isEven).length

[willsmart]

A hell of a lot cleaner, in theory a bit slower too.
filter allocates, fills and returns an array, which we're then instantly throwing away after getting its length. reduce functions more like a for loop, iterating over each element and accumulating a sum.

That's in theory though. JS performance is fickle thing, and on perf.link it seems your filter method is both cleaner looking, and faster for arrays with fewer than 10000 items.
Perf.link link
Go figure! Good to know

What we really want is something like ruby's count, which only returns the filtered size...

isEven = -> (v) { (v&1)==0 }
[1,2,3,4,5,6,7].count(&isEven) # <- 3

😎

[Coderslang: Become a Software Engineer]

That's clever. Thank you!

[Justin Mitchell]

Has anyone ever actually come across an instance where they have to sum two booleans?

To pre-empt, xor is not the result of summing booleans.

[Andrew Bridge]

Not two booleans, but a standard for a sort handler I use is:

.sort((a, b) => {
   if (a === b) return 0;
   return ((a < b) * 2) - 1;
});

(albeit a and b are often objects I'm pulling comparable values out of)

The sort result either needs to be below 0 or above 0 depending on whether a is before or after b. The nested boolean becomes a 0 or a 1, multiplied by 2 it's either 0 or 2, so subtracting 1 will given a final -1 or +1 result, which is exactly to the .sort spec.

There are also various code golf type tricks that boolean can use boolean maths in some way, but it's otherwise not that useful.

[Justin Mitchell]

Smart way of sorting, that's really taking advantage of how JS works. Can't do that in strongly typed languages.