What is the best way to compile and assess logical operators and operands that are defined within an object?

Question

What is the best way to compile and assess logical operators and operands that are defined within an object?

How can I create a compiler that can evaluate logical operators and operands specified on an object, similar to MongoDB's $or and $and operators? For example:

return {
  $or: [
    foo: [...],
    bar: [...]
  ]
}

The compiler would call corresponding functions for each operand like foo and bar, then apply logical OR to the results. It should be able to handle nested logical operators as well. An example of a complex operation:

return {
  $or: [
    { 
      $and: [
        { foo: [...] }, 
        { bar: [...] }
      ] 
    }, 
    { baz: [...] }, 
    () => m < n
  ]
}

A simplified definition of the functions for foo, bar, and baz:

export const evalFoo = items => {
  return items.indexOf("foo") >= 0;
};

export const evalBar = items => {
  return items.indexOf("bar") >= 0;
};

export const evalBaz = items => {
  return items.indexOf("baz") >= 0;
};

Sample data:

Set 1

m = 4; n = 1; foo: ['foo', 'x']; bar: ['bar', 'y']; baz: ['baz', 'z']

RESULT = true; // because $and results to true.

Set 2

m = 4; n = 1; foo: ['x']; bar: ['y']; baz: ['x']

RESULT = false; // because m > n and $and results to false.

Set 3

m = 1; n = 3; foo: ['x']; bar: ['y']; baz: ['x']

RESULT = true; // because m < n.

Set 4

m = 3; n = 1; foo: ['x']; bar: ['bar']; baz: ['z']

RESULT = true; // because m > n, baz() is false and x and $and is false.

javascript parsing ecmascript-6 boolean-logic

Answer 1

Answer №1

Consider implementing a solution similar to this, where you distinguish between $and, $or, and the respective functions.

This approach involves utilizing an object with keys representing array methods such as Array#every. This method acts like a logical 'and' by testing values in an object and returning true if all items, along with their callbacks, return a truthy value. Similarly, Array#some works analogously but requires only one truthy value from its callback.

Another object contains functions that can be accessed using the provided key.

The initial verification checks whether the parameter is a function. If it is, the result of the call is returned.

Following this, the parameter undergoes a check for being falsy (e.g., null) or not being an object. In such cases, the function terminates by returning false.

A destructuring assignment occurs to obtain a key/value pair from the object.

If the specified key is found in the operator object, its corresponding method, indicated by value, is then used to iterate over the value and return the result.

If the key corresponds to a function in the designated object, that function is invoked with value as its parameter before returning the result.

Lastly, if none of the previous conditions are met, the function returns false since the condition cannot be resolved.

function evaluate(object) {
    var operators = { $or: 'some', $and: 'every' },
        fns = {
            foo: items => items.indexOf("foo") >= 0,
            bar: items => items.indexOf("bar") >= 0,
            baz: items => items.indexOf("baz") >= 0
        },
        key,
        value;

    if (typeof object === 'function') return object();
    if (!object || typeof object !== 'object') return false;

    [key, value] = Object.entries(object)[0];

    if (key in operators) return value[operators[key]](evaluate);
    if (key in fns) return fns[key](value);
    return false;
}

var m = 4,
    n = 1,
    object = {
        $or: [
            {
                $and: [
                    { foo: ['foo', 'x'] },
                    { bar: ['bar', 'y'] }
                ]
            },
            { baz: ['baz', 'z'] },
            () => m < n
        ]
    },
    result = evaluate(object);

console.log(result);

Answer 2