How to remove a common property from each array which is nested

Question

I have an array like below: I want to remove origin: 0 property and add it value directly using Javascript es6 feature. How to remove same repeated property from a nested array.

const orginalData = {
  name: {
    origin: 0,
    value: 'christi'
  },
  location: {
    origin: 0,
    value: 'Blr'
  },
  address: {
    origin: 0,
    value: [{
        "streetAddress1": {
          "origin": 0,
          "value": '12th street'
        },
        "city1": {
          "origin": 0,
          "value": 'Maxwell'
        }
      },
      {
        "streetAddress2": {
          "origin": 0,
          "value": '10=]]]]]]]th street'
        },
        "city2": {
          "origin": 0,
          "value": 'Coxwell'
        }
      }
    ]
  }
}

const finalData = {
  name: 'christi',
  location: 'Blr',
  address: [{
      streetAddress1: '10th street',
      city1: 'Maxwell'
    },
    {
      streetAddress2: '12th street',
      city2: 'Coxwell'
    }
  ]
}

Answer 1

This is just a copy of adiga's logic, made more explicit with extraneous identifiers and comments.

It's intended to help with understanding of the reduce method (and other JavaScript features) and of recursion.

const originalData = {
  name: { origin: 0, value: 'christi' },
  location: { origin: 0, value: 'Blr' },
  address: {
    origin: 0,
    value: [
      {
        "streetAddress1": { "origin": 0, "value": '12th street' },
        "city1": { "origin": 0, "value": 'Maxwell' }
      },
      {
        "streetAddress2": { "origin": 0, "value": '10=]]]]]]]th street' },
        "city2": { "origin": 0, "value": 'Coxwell' }
      }
    ]
  }
};

function restructure(obj) {

  // Whether `restructure` is called directly or recursively, it builds and returns 
  //   a new object.
  return Object.entries(obj).reduce( (acc, curr, ind, arr ) => {

    // Here, `entries` is a 2D array where each 'row' is a property and the two 
    //   'columns' are the property name and property value.
    // We identify them explicitly below and assume that that the property value 
    //   is an object with a subproperty called "value", which we also identify.
    const propKey = curr[0], propVal = curr[1], subpropVal = propVal["value"];

    // Logs the index (ie 'row' number) of the current property and its property name
    //console.log(ind, propKey);

    // Here, `acc` is the object we will return. We give `acc` a new property with 
    //   the same name as the current property. 
    // If the "value" subproperty of the current property holds an array, the new 
    //   property will hold an array of objects, each of which is a `restructure`d 
    //   version of an object from the source array. (This can happen many times,
    //   restructuring nested objects from many nested arrays.)
    // If not, the new property will have the same value as the "value" subproperty does
    acc[propKey] = Array.isArray(subpropVal) ? subpropVal.map(restructure) : subpropVal;

    // If this call to `restructure` was recursive, we will continue looping through 
    //   the array we are currently processing. 
    // If this was the original call, we're done and log our `finalData` to the console.
    return acc;
  }, {})
}

const finalData = restructure(originalData);

console.log(finalData);

Answer 2

You could create generic function like this. reduce the entries of an object to remove a level of nesting and update with nested value. If value as an array, recursively call the function on each object using map and get an array of restructured objects. This will work for any level of nesting

const orginalData={name:{origin:0,value:"christi"},location:{origin:0,value:"Blr"},address:{origin:0,value:[{streetAddress1:{origin:0,value:"12th street"},city1:{origin:0,value:"Maxwell"}},{streetAddress2:{origin:0,value:"10=]]]]]]]th street"},city2:{origin:0,value:"Coxwell"}}]}};

function restructure(obj) {
  return Object.entries(obj).reduce((acc, [k, { value }]) => {
    acc[k] = Array.isArray(value) ? value.map(restructure) : value;
    return acc;
  }, {})
}

const finalData = restructure(orginalData)

console.log(finalData)

Answer 3

first if you want to edit your data, it can't be a const, so change const by let or var. second you can use for loop to do that, you can juste write a function or add a function to JSON object

// first logique as global function
function keepKey(data, keep) {
    for(let key in data) data[key] = data[key][keep];
}

// second logique as global function
function removeKey(data, remove, assignRest) {
    for(let key in data){
        //get the item
        let item = data[key];

        if(typeof item === 'object'){
            //if you put 'use strict' at the top you have to use a loop
                let temp = {}, lastKey = '';
                for(let itemKey in item){
                    if(itemKey !== remove){
                        if(assignRest === true) temp = item[itemKey];
                        else temp[itemKey] = item[itemKey];
                    }
                }
                data[key] = temp;

            //else you can use directly delete
                //delete item[remove];
        }
    }
}


// add the function to JSON object
JSON.keepKey = {...function...}
// or
JSON.removeKey = {...function...}


JSON.keepKey(orginalData, 'value');
// will give you 
{name: 'christi',location: 'Blr',...}


JSON.removeKey(orginalData, 'value', true);
// will give you 
{name: 'christi',location: 'Blr',...}


JSON.removeKey(orginalData, 'value', false);
// will give you 
{name: {value : 'christi'},location: {value: 'Blr'},...}

Answer 4

const finalData = {
  // ...originalData, uncommnent this if you have more originalData has props that you do not want to chnage.
  name: originalData.name.value,
  location: originalData.location.value,
  address: originalData.address.value.map(item => {
    const { origin, ...rest } = item;

    return rest;
  }),
};

Answer 5

If you're using NodeJs you could use omit-deep to remove any property you want, regardless of where it is within the object.

For example, this:

const omitDeep = require('omit-deep');

const data = {
  name: { origin: 0, value: 'christi' },
  location: { origin: 0, value: 'Blr' },
  address: {
    origin: 0,
    value: [
      { streetAddress1: { origin: 0, value: '12th street' }, city1: { origin: 0, value: 'Maxwell' } },
      { streetAddress2: { origin: 0, value: '10=]]]]]]]th street' }, city2: { origin: 0, value: 'Coxwell' } }
    ]
  }
};

const finalData = omitDeep(data, 'origin');

Produces this result:

{
  name: { value: 'christi' },
  location: { value: 'Blr' },
  address: {
    value: [
      { streetAddress1: { value: '12th street' }, city1: { value: 'Maxwell' } },
      { streetAddress2: { value: '10=]]]]]]]th street' }, city2: { value: 'Coxwell' } }
    ]
  }
};