I have an source object obj that looks like this and an array input

const obj = {
  name: "xyz",
  filter: {
    and: [
      {
        or: [
          {
            and: []
          }
        ]
      }
    ]
  }
};

const input = ["test1\name1", "test2\name2"]

I need to push objects that are formed after spiltting input by \. After splitting, using left side of the string i need to form an object like this

{ type: "type1", value: whatever the left hand value}

Same for right side value

{ type: "type2", value: whatever the right hand value}

And these objects should be pushed to innermost and in the source object.

Expected output

{
  name: "xyz",
  filter: {
    and: [
      {
        or: [
          {
            and: [
              { type: "type1", value: "test1" },
              { type: "type2", value: "name1" },
              { type: "type1", value: "test2" },
              { type: "type2", value: "name2" }
            ]
          }
        ]
      }
    ]
  }
}

Code that I tried

function processResult(input) {
  return {
    name: "xyz",
    filter: {
      and: [
        {
          or: [
            {
              and: getUpdatedValues(input)
            }
          ]
        }
      ]
    }
  };
}

// I need the getUpdateValues to be processing the each item from the input array and then sending the two objects back after splitting

function getUpdatedValues(input){
  const updated = input.map(item => {
    const spilt = item.split("\\");
  });
}

CodePudding user response：

Assuming that the input array would include an escape character and could be like so: ["test1\\name1", "test2\\name2"], presented below is one possible way to achieve the desired objective.

Code Snippet

const transformMyArr = (myArr) => (
  myArr.flatMap(
    s => {
      const [leftie, rightie] = s.split('\\');
      return ([{
        type: 'type1', value: leftie
      }, {
        type: 'type2', value: rightie
      }]);
    }
  )
);

/* code explanation
// method to transform the array to required format
const transformMyArr = (myArr) => (
  myArr.flatMap(  // iterate over the array and remove nested-array in result
    s => {        // manipulate each array element
      // "split" using "\\" and store the left-side as "type"
      // and the rest as "value"
      const [type, value] = s.split('\\');
      // explicit return of an array with two objects per array elt
      return ([{
        type: 'type1', value: leftie
      }, {
        type: 'type2', value: rightie
      }]);
    }
  )         // implicit return from the "transformMyArr" method
);

*/

let myInputArr = ["test1\\name1", "test2\\name2"];

const myObj = {
  name: "test",
  filter: {
    and: [{
      or: [{
        and: [...transformMyArr(myInputArr) ]
      }]
    }]
  }
};

console.log('updated obj:\n', myObj);

.as-console-wrapper { max-height: 100% !important; top: 0 }

Explanation

Inline comments added to the snippet above.

CodePudding user response：

One way to do it. It's tricky because the input structure is so different to the output, and there is no reference for "type1"/"type2" other than the array element position.

const input = ["test1\\name1", "test2\\name2"];

function processResult(input) {
  return {
    name: "xyz",
    filter: {
      and: [
        {
          or: [
            {
              and: getUpdatedValues(input)
            }
          ]
        }
      ]
    }
  };
}

function getUpdatedValues(input){
  return input.flatMap((item, i) => item.split("\\").map(val => ({[`type${i   1}`]: val })));
}

console.log(processResult(input));