Javascript 如何从嵌套的每个数组中删除公共属性

我有一个如下所示的数组：我想删除origin:0属性，并使用Javascript es6特性直接添加它的值。如何从嵌套数组中删除相同的重复属性

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'
        }
      }
    ]
  }
}

---

如果您使用的是NodeJs，那么您可以使用它删除您想要的任何属性，而不管它在对象中的什么位置

例如，这：

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');

产生以下结果：

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

---

如果您使用的是NodeJs，那么您可以使用它删除您想要的任何属性，而不管它在对象中的什么位置

例如，这：

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');

产生以下结果：

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

---

首先，如果您想编辑数据，它不能是常量，所以请通过let或var更改常量。 第二 您可以使用for循环来实现这一点，只需编写一个函数或向JSON对象添加一个函数即可

// 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'},...}

---

首先，如果您想编辑数据，它不能是常量，所以请通过let或var更改常量。 第二 您可以使用for循环来实现这一点，只需编写一个函数或向JSON对象添加一个函数即可

// 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'},...}

---

您可以像这样创建泛型函数。用于删除嵌套级别并使用嵌套的

值更新的对象。如果
value
作为数组，则使用递归调用每个对象上的函数，并获得一个重构对象数组。这将适用于任何级别的嵌套


const-originaldata={name:{origin:0，value:'christi}，位置：{origin:0，value:'Blr}，地址：{origin:0，value:[{streetAddress1:{origin:0，value:'12th street}，city1:{origin origin 0，value:'Maxwell}，{streetAddress2:{origin 0，value:'10=\\\\\\\\\\\\]]th street}，city2:{origin origin 0，value:'Coxwell:}；
功能重组（obj）{
返回Object.entries（obj.reduce）（（acc[k，{value}]）=>{
acc[k]=Array.isArray（值）？value.map（重构）：值；
返回acc；
}, {})
}
const finalData=重组（原始数据）
log（finalData）
您可以创建这样的通用函数。用于删除嵌套级别并使用嵌套的
值更新的对象。如果
value
作为数组，则使用递归调用每个对象上的函数，并获得一个重构对象数组。这将适用于任何级别的嵌套


const-originaldata={name:{origin:0，value:'christi}，位置：{origin:0，value:'Blr}，地址：{origin:0，value:[{streetAddress1:{origin:0，value:'12th street}，city1:{origin origin 0，value:'Maxwell}，{streetAddress2:{origin 0，value:'10=\\\\\\\\\\\\]]th street}，city2:{origin origin 0，value:'Coxwell:}；
功能重组（obj）{
返回Object.entries（obj.reduce）（（acc[k，{value}]）=>{
acc[k]=Array.isArray（值）？value.map（重构）：值；
返回acc；
}, {})
}
const finalData=重组（原始数据）
log（finalData）
这只是adiga逻辑的一个副本，通过额外的标识符和注释更加明确

它旨在帮助理解
reduce
方法（以及其他JavaScript特性）和递归


const originalData={
名称：{origin:0，值：'christi'}，
位置：{原点：0，值：'Blr'}，
地址:{
来源：0，
价值：[
{
“streetAddress1”：{“原点”：0，“值”：“第12街”}，
“城市1”：{“原点”：0，“值”：“麦克斯韦”}
},
{
“streetAddress2:{“origin”：0，“value:'10=\\\\\\\\\\\\\]]th street'}，
“city2”：{“原点”：0，“值”：“Coxwell”}
}
]
}
};
功能重组（obj）{
//无论是直接调用还是递归调用'restructure'，它都会生成并返回
//一个新的物体。
返回Object.entries（obj）.reduce（（acc、curr、ind、arr）=>{
//这里，“entries”是一个二维数组，其中每个“row”是一个属性，两个
//“columns”是属性名称和属性值。
//我们在下面明确地识别它们，并假设属性值
//是一个具有称为“value”的子属性的对象，我们也会识别它。
常量propKey=curr[0]，propVal=curr[1]，subpropVal=propVal[“值”]；
//记录当前属性的索引（即“行”编号）及其属性名称
//console.log（ind，propKey）；
//在这里，`acc`是我们将返回的对象。我们给`acc`一个新的属性
//与当前属性同名。
//如果当前属性的“值”子属性包含数组，则新属性
//属性将包含一个对象数组，每个对象都是一个“restructure”d
//源数组中对象的版本。（这种情况可能发生多次，
//从多个嵌套数组重新构造嵌套对象。）
//否则，新属性将具有与“值”子属性相同的值
acc[propKey]=Array.isArray（subpropVal）？subpropVal.map（重构）：subpropVal；
//如果对“restructure”的调用是递归的，我们将继续循环执行
//我们当前正在处理的数组。
//如果这是最初的调用，我们就完成了，并将“finalData”记录到控制台。
返回acc；
}, {})
}
const finalData=重组（原始数据）；
console.log（finalData）这只是adiga逻辑的一个副本，使用无关的标识符和注释使其更加明确

它旨在帮助理解
reduce
方法（以及其他JavaScript特性）和递归


const originalData={
名称：{origin:0，值：'christi'}，
位置：{原点：0，值：'Blr'}，
地址:{
来源：0，
价值：[
{
“streetAddress1”：{“原点”：0，“值”：“第12街”}，
“城市1”：{“原点”：0，“值”：“麦克斯韦”}
},
{
“streetAddress2:{“origin”：0，“value:'10=\\\\\\\\\\\\\]]th street'}，
“city2”：{“原点”：0，“值”：“Coxwell”}
}
]
}
};
功能重组（obj）{
//无论是直接调用还是递归调用'restructure'，它都会生成并返回
//一个新的物体。
返回Object.entries（obj）.reduce（（acc、curr、ind、arr）=>{
//这里，`entries`是一个二维数组