JavaScript validation of multiple Booleans

Question

I want to validate an object that has three Boolean properties, of which one, and only one, must be true. What is the best way to check this?

I came up with this:

var t1 = obj.isFirst  ? 1 : 0,
    t2 = obj.isSecond ? 1 : 0,
    t3 = obj.isThird  ? 1 : 0;

var valid = (t1 + t2 + t3) === 1;

This works fine, but it feels a bit like a hobbyists solution :-)

Is there a better way of doing this? Using XOR (^) for example?

Answer 1

You could filter the Object.values and check if the length is 1

let obj = {
    a: true,
    b: false,
    c: false
};
let oneTrue = Object.values(obj).filter(e => e === true).length === 1;
console.log(oneTrue);

As @deceze commented

Should there be more properties in the object: [obj.a, obj.b, obj.c].filter(Boolean)...

---

Note that in your case, it might make sense to add a method to your object that does the check for you

let obj = {
    a: false,
    b: false,
    c: false,
    isValid() {
        return this.a + this.b + this.c === 1;
    }
};

console.log(obj.isValid());

Answer 2

You can use array.reduce:

var obj = {
    a: true,
    b: false,
    c: false
};
var res = Object.values(obj).reduce((m, o) => m + o) === 1;
console.log(res);

Answer 3

Use:

obj.isFirst + obj.isSecond + obj.isThird === 1

Assuming it is certain that the values are Booleans and not something different. You can add explicit conversion if you like, like this:

Number(obj.isFirst) + Number(obj.isSecond) + Number(obj.isThird) === 1

But JavaScript also implicitly does this conversion for you.

_{(This is based on ASDFGerte’s comment.)}

Answer 4

Going at the problem from the other way around, it looks like you're trying to model something that can have 3 possible states. Don't represent it as 3 booleans, represent it as a variable with 3 possible values:

const STATES = ['STATE_A', 'STATE_B', 'STATE_C'];
let value = 'STATE_A';

If you want to use one of the booleans:

doSomethingDependingOnBooleanC(value === `STATE_C`);

If you want to validate that value holds what you expect (one of your 3 possible states):

const isValid = STATES.includes(value);
const isValidInOlderBrowsers = STATES.indexOf(value) !== -1;

Answer 5

You can do this in one line, but it's not easy to read. But if obfuscation is your goal, read on.

Since obj.isFirst, obj.isSecond, and obj.isThird are all either 0 or 1, you can use the bitwise XOR operator ^ between them:

(obj.isFirst ^ obj.isSecond ^ obj.isThird) ^ (obj.isFirst && obj.isSecond && obj.isThird)

We need to XOR against obj.isFirst && obj.isSecond && obj.isThird because obj.isFirst ^ obj.isSecond ^ obj.isThird evaluates to true.

Answer 6

How about:

var valid =  (obj.isFirst + obj.isSecond + obj.isThird) === 1;

Note: The return of a sum is an integer and it translates true to 1 and false to 0. So you do not actually need to to boolValue ? 1 : 0

See this result set for reference:

console.log(true + false + false)  // 1
console.log(false + false + false) // 0
console.log(false + false + true)  // 1
console.log(1 + false + 0)         // 1
console.log(false + 1 + 1)         // 2

Also let me point out, if you want explicit conversion and your data is string, you may fall into this issue. So, I would rather use Boolean than Number.

var a = "true",
    b = false,
    c = false;

var valid = Number(a) + Number(b) + Number(c);
console.log(valid); // NaN

var a = "true",
    b = false,
    c = false;

var valid = Boolean(a) + Boolean(b) + Boolean(c);
console.log(valid); // 1

Answer 7

Wrap it in a function named 'ensureOnlyOnePropertyIsTruthy'. Have it take a list of property names along with the object and stuff whatever ugly, performant code you want inside. Nobody will have to read the internals because your function gives them the only context necessary.