Array[object..] logical operators

Question

Array[object..] logical operators

I am currently working with Boolean and logical operators using code like this:

Just so you know, I want to convert object values and logic into an array to perform logical operations. For example: object1.logic object.operators object2.logic as either true or false.

const input: Array<any> = [
    {
        type: "basic",
        value: true,
        logic: "or"
    },
    {
        type: "basic",
        value: false,
        logic: "and"
    },
    {
        type: "basic",
        value: true,
        logic: "and"
    },

I expect the result to be equivalent to:

 true || false && true

Does anyone have a solution for this particular issue?

typescript logic logical-operators

Answer 1

Answer №1

To achieve the desired outcome, simply utilize the reduce operator to create a new operator object that combines the logic of previous operators with the values or computations of the current one.

let input = [{
    type: "basic",
    value: true,
    logic: "or"
  },
  {
    type: "basic",
    value: false,
    logic: "and"
  },
  {
    type: "basic",
    value: true,
    logic: "and"
  }
]

// In case type is not considered 

let result = input.reduce((op1, op2) => ({
  logic: op2.logic,
  value: op1.logic === 'or' ? op1.value || op2.value : op1.value && op2.value
}));
// For multiple || and && operations, you can create a function with switch cases and call it here.

console.log(result);

If you wish to control the sequence of operations:

let input = [{
    type: "basic",
    value: true,
    logic: "or"
  },
  {
    type: "basic",
    value: false,
    logic: "and"
  },
  {
    type: "basic",
    value: true,
    logic: "and"
  }
]

// Logic: and - or
// Operation: (boolean, boolean) => boolean; 
let processOperation = (logic, operation, arr, op) => {
  // If empty, return the first element
  if (!arr.length) return [op];

  let prevOp = arr[arr.length - 1];

  if (prevOp.logic === logic) {
    // Replace previous operation with the result
    arr.pop()
    arr.push({
      logic: op.logic,
      value: operation(prevOp.value, op.value)
    });
  } else {
    arr.push(op); // If operation logic does not match, push for future processing
  }
  return arr;
}

let result = input
  .reduce(processOperation.bind(this, 'and', (a, b) => a && b), [])
  .reduce(processOperation.bind(this, 'or', (a, b) => a || b), []);
// The order is determined by the chain sequence

// result[0].value will give the solution
console.log('answer', result);

Answer 2

To achieve the desired outcome, simply utilize the reduce operator to create a new operator object that combines the logic of previous operators with the values or computations of the current one.

let input = [{
    type: "basic",
    value: true,
    logic: "or"
  },
  {
    type: "basic",
    value: false,
    logic: "and"
  },
  {
    type: "basic",
    value: true,
    logic: "and"
  }
]

// In case type is not considered 

let result = input.reduce((op1, op2) => ({
  logic: op2.logic,
  value: op1.logic === 'or' ? op1.value || op2.value : op1.value && op2.value
}));
// For multiple || and && operations, you can create a function with switch cases and call it here.

console.log(result);

If you wish to control the sequence of operations:

let input = [{
    type: "basic",
    value: true,
    logic: "or"
  },
  {
    type: "basic",
    value: false,
    logic: "and"
  },
  {
    type: "basic",
    value: true,
    logic: "and"
  }
]

// Logic: and - or
// Operation: (boolean, boolean) => boolean; 
let processOperation = (logic, operation, arr, op) => {
  // If empty, return the first element
  if (!arr.length) return [op];

  let prevOp = arr[arr.length - 1];

  if (prevOp.logic === logic) {
    // Replace previous operation with the result
    arr.pop()
    arr.push({
      logic: op.logic,
      value: operation(prevOp.value, op.value)
    });
  } else {
    arr.push(op); // If operation logic does not match, push for future processing
  }
  return arr;
}

let result = input
  .reduce(processOperation.bind(this, 'and', (a, b) => a && b), [])
  .reduce(processOperation.bind(this, 'or', (a, b) => a || b), []);
// The order is determined by the chain sequence

// result[0].value will give the solution
console.log('answer', result);

Array[object..] logical operators

Answer №1

Similar questions

After integrating React Query into my project, all my content vanishes mysteriously

A beginner's guide to integrating ChartJS with React

Tips for accurately documenting the Props parameter in a React component with Destructuring assignment

Angular 6 allows for the use of radio buttons to dynamically enable or disable corresponding fields

Jest is throwing an error: Unable to access property from undefined while trying to import from a custom

Transforming Boolean data types into text within an Angular 2 client-side application

What is the way to declare a prop as optional in Svelte using TypeScript?

I'm looking to switch out the `~` to turn it into a URL for the backend, seeing as `<img alt="" src="~/media/Banner/plane.JPG">` is returning a 404 error

I am puzzled as to why I am still facing the error message: "'node' is not recognized as an internal or external command, operable program or batch file."

Check out the attributes of a class

transition from mapStateToProps to using hooks

Creating a definition for the use of sweet alerts within a service and incorporating them through

What is the most effective way to condense these if statements?

What is the best time to initialize .env variables in a NodeJS application?

When defining functions in Typescript, the new() syntax is used

Delete a particular item from a JSON object in real-time using TypeScript/JavaScript

What is the process for including an extra track in Twilio Video?

Input values that are true, or in other words, fulfill conditions for truthiness

Passing along the mouse event to the containing canvas element that utilizes chart.js

Having trouble retrieving a value from a reference object in React Typescript?