如何将对象数组重新映射为Javascript中的对象对象

如何解决如何将对象数组重新映射为Javascript中的对象对象

我有这个值：

const sample = [{

  name: "name",value1: 1,mean: 2,create: 10,age: "age",player1: 20,player2: 40,sample: "sample",player3: 30,player4: 100,}];

要映射到：

{
  name: {
    value: 1,create: 10
  },age: {
    player1: 20,player2: 40
  },sample: {
    player3: 30,player4: 100
  }
}

我知道我可以做的是手动将其映射，但是我的列表大约有50个，因此不可能。

编辑：

key属性是字符串，数字是该值的顺序

解决方法

您的描述不清楚，但是，我认为您只想在键和值相同的情况下将一组属性重新映射为新属性。

此外，我放置了一个新的key = value =“ other”，之后的属性被分组在“ other”下，因此您不必指定所有键...

const sample = [{
  name: "name",value1: 1,mean: 2,create: 10,age: "age",player1: 20,player2: 40,},{
  name: "name",other: "other",p2: "ldkdskd",p1: 10
}];
    
function remapdata(data) {
  const obj = {};
  const keys = Object.keys(data);
  let lastGroup = undefined;
  let i = 0;`enter code here`
  while(i < keys.length) {
    if(keys[i] === data[keys[i]]) {
      obj[keys[i]]= {};
      lastGroup=keys[i];  
    } else if (lastGroup) {
      obj[lastGroup][keys[i]] = data[keys[i]];
    }
    i++;
  } 
  return obj;
}
const mapped = sample.map(remapdata);

console.log(mapped);

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

,

使用Array#map将其映射到内部的新对象结构。

const sample = [
 {
  name: "name",}
];

let result = sample.map(elem => ({
    any : {
        name: {
           value: elem.value1,mean: elem.mean,create: elem.create
        },age: {
           player1: elem.player1,player2: elem.player2
        }
   }
}))

console.log(result);

,

要正确执行此操作，您需要指定最终对象中name和age之下的属性，如下例所示：

const sample = [
  {
    name: "name",player2: 40
  },{
    name: "fred",value1: 3,mean: 5,create: 101,player1: 202,player2: 401
  }
];


const keyValuesMap = {
  // `name` property will have `value1`,`mean`,and `create` properties
  name: ["value1","mean","create"],// `age` property will have `player1` and `player2` properties
  age: ["player1","player2"]
};

const result = sample.map((item) => {
  // map over the `sample` data and get the key/value pairs of each
  // item,then use `reduce` to create a new object based on the
  // `keyValuesMap` specified above
  return Object.entries(item).reduce((accumulator,[key,value]) => {
    const name = accumulator.name || {};
    const age = accumulator.age || {};

    // if value belongs to the `name` property,add to it
    if (keyValuesMap.name.includes(key)) {
      name[key] = value;
    }
    // if value belongs to the `age` property,add to it
    if (keyValuesMap.age.includes(key)) {
      age[key] = value;
    }

    accumulator.name = name;
    accumulator.age = age;

    return accumulator;
  },{});
});

console.log("result",result);

参考：

• Object.entries - MDN
• Array.reduce - MDN
• Destructing assignment - MDN
• Array.includes - MDN

,

您可能想要这样的东西

const sample = [ { name: "name",];

res = sample.reduce((r,c) => {
  let key;
  Object.entries(c).forEach((o) => {
(k = o[0]),(v = o[1]);
typeof v == "string" ? ((key = v),(r[v] = {})) : (r[key][k] = v);
  });
  return r;
},{});
console.log(res);

,

每个人都应该意识到，要重组任何对象的键-值对的任何方法实际上都依赖于必须始终确保的结构，例如Object.keys，这是一个完全代表任何键的创建顺序的键顺序。同样，创建此类对象的环境也必须确保这样一种可行且可复制的订单。

如果可以将其概括为“ ... ...，只要键值对key中的值等于value，就可以创建一个通过{{ 1}}。” ，应按原样使用下面提供的方法。否则，必须将负责创建新子结构的条件限制为任何 string 类型key，这也确实限制了允许原始结构使用的类型。 ...

value

const sampleList = [{
  name: "name",sample: "sample",player3: 30,player4: 100
},{
  sample: "sample",player1: 130,player2: 1100,name: "name",value1: 11,mean: 12,create: 110,player3: 120,player4: 140
}];


function restructureSample(sample) {
  const newSample = {};
  return Object.entries(sample).reduce((reference,tuple,idx,arr) => {

    const [key,value] = tuple;
  //if (typeof value === 'string') {  // - more generic,but limiting the use cases.
    if (key === value) {              // - maybe even more precise.

      reference = newSample[key] = {};
    } else {
      reference[key] = value;
    }
    return (((idx === (arr.length - 1)) && newSample) || reference);

  },newSample);
}


console.log(sampleList.map(restructureSample));

,

您可以使用.map函数遍历对象，并跟踪最后一个key向其添加整数属性：

const sample = [
 {
  name: "name",player1a: 30,player2a: 100,mean: 22,create: 130,player1: 210,player2: 430,player1a: 340,player2a: 1100,value: 313,mean: 421,create: 23,player1a: 440,player2a: 40,}
];
let lastKey = null;
let mapped = sample.map(elem => {
     let obj = { any: {} };
     let any = obj.any;
     for(var p in elem){
          let key = p,value = elem[p];
          if(typeof(value)=="string"){
               any[key] = {};
               lastKey = key;
          }else if(typeof(value)=="number"){
               if(lastKey)
                    any[lastKey][key] = value;
               else
                    any[key] = value;
          }
     }
     return obj;
});
console.log(mapped);

请注意，您不能使用两个相同的键（player1和player2），因为它们应该是唯一的。

,

使用Array.prototype.reduce缩小数组并将remap的现有属性缩小为所需的格式。

const sample = [
 {
  name: "name",}
];

const result = sample.reduce((acc,{ value1,mean,create,player1,player2 }) => {
    acc.push({
        name: {
            value1,create
        },age: {
            player1,player2
        }
    });
    return acc;
},[]);

console.log(result);

对于动态键，您可以执行以下操作-

const sample = [
 {
  name: "name",}
];

const keyMapping = {
    name: ['value1','mean','create'],age: ['player1','player2']
};

const result = sample.reduce((acc,curr) => {
    const obj = Object.entries(keyMapping).reduce((accumulator,val]) => {
        accumulator[key] = val.reduce((r,c) => {
            r[c] = curr[c];
            return r;
        },Object.create(null));
        return accumulator;
    },Object.create(null));
    
    acc.push(obj);
    return acc;
},[]);

console.log(result);