Ich habe diesen Wert:

const sample = [{

  name: "name",
  value1: 1,
  mean: 2,
  create: 10,

  age: "age",
  player1: 20,
  player2: 40,

  sample: "sample",
  player3: 30,
  player4: 100,
}];

Abgebildet werden in:

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

Ich weiß, was ich tun kann, ist es manuell zuzuordnen, aber meine Liste ist ungefähr 50, also ist es nicht möglich.

Bearbeiten:

Die Schlüsseleigenschaft ist, wenn es sich um eine Zeichenfolge handelt, und die Zahl entspricht den Werten in dieser Reihenfolge

0
ajbee 19 Aug. 2020 im 15:30

7 Antworten

Beste Antwort

Jeder sollte sich darüber im Klaren sein, dass jeder Ansatz, der die Schlüssel-Wert-Paare eines Objekts umstrukturiert, tatsächlich auf einer Struktur beruht, die immer sicherstellen muss, z. Object.keys, eine Schlüsselreihenfolge, die genau die Reihenfolge der Schlüsselerstellung darstellt. Auch die Umgebung, die solche Objekte erstellt, muss genau eine solche tragfähige und reproduzierbare Reihenfolge sicherstellen.

Wenn man das verallgemeinern könnte, "... wann immer in einem Schlüssel-Wert-Paar key gleich value ist, möchte man über key ein neues Objekt erstellen, das der neu abgetasteten Struktur zugewiesen ist . " sollte man mit dem unten angegebenen Ansatz so gehen, wie er ist. Andernfalls muss die Bedingung, die für das Erstellen neuer Unterstrukturen verantwortlich ist, auf einen string -Typ value beschränkt werden, der dann auch die Typen einschränkt, die die ursprüngliche Struktur enthalten darf. ...

const sampleList = [{
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,

  age: "age",
  player1: 20,
  player2: 40,

  sample: "sample",
  player3: 30,
  player4: 100
}, {
  sample: "sample",
  player1: 130,
  player2: 1100,

  name: "name",
  value1: 11,
  mean: 12,
  create: 110,

  age: "age",
  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));
.as-console-wrapper { min-height: 100%!important; top: 0; }
1
Peter Seliger 19 Aug. 2020 im 13:59

Verwenden Sie Array.prototype.reduce um das Array zu reduzieren und remap die vorhandenen Eigenschaften in das gewünschte Format.

const sample = [
 {
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,
  age: "age",
  player1: 20,
  player2: 40,
 }
];

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

console.log(result);

Für dynamische Tasten können Sie Folgendes tun:

const sample = [
 {
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,
  age: "age",
  player1: 20,
  player2: 40,
 }
];

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

const result = sample.reduce((acc, curr) => {
    const obj = Object.entries(keyMapping).reduce((accumulator, [key, 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);
0
Kunal Mukherjee 19 Aug. 2020 im 13:07

Ihre Beschreibung ist jedoch nicht klar. Ich denke, Sie möchten eine Gruppe von Eigenschaften nur dann einer neuen Eigenschaft zuordnen, wenn Schlüssel und Wert identisch sind.

Außerdem habe ich einen neuen Schlüssel = value = "other" eingefügt und die Eigenschaften danach werden unter "other" gruppiert, sodass Sie nicht alle Schlüssel angeben müssen ...

const sample = [{
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,

  age: "age",
  player1: 20,
  player2: 40,
}, {
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,

  age: "age",
  player1: 20,
  player2: 40,

  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; }
2
Peter Seliger 19 Aug. 2020 im 15:27

Sie wollen wahrscheinlich so etwas

const sample = [ { name: "name", value1: 1, mean: 2, create: 10, age: "age", player1: 20, player2: 40, }, ];

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);
1
Sven.hig 19 Aug. 2020 im 13:05

Um dies richtig zu machen, müssen Sie Eigenschaften angeben, die im endgültigen Objekt unter name und age fallen, wie im folgenden Beispiel:

const sample = [
  {
    name: "name",
    value1: 1,
    mean: 2,
    create: 10,
    age: "age",
    player1: 20,
    player2: 40
  },
  {
    name: "fred",
    value1: 3,
    mean: 5,
    create: 101,
    age: "age",
    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);

Verweise:

1
goto1 19 Aug. 2020 im 12:51

Verwenden Sie Array # map für die Zuordnung es auf die neue Objektstruktur im Inneren.

const sample = [
 {
  name: "name",
  value1: 1,
  mean: 2,
  create: 10,
  age: "age",
  player1: 20,
  player2: 40,
 }
];

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);
1
Sascha 19 Aug. 2020 im 12:40