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
7 Antworten
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; }const sample = [
{
name: "name",
value1: 1,
mean: 2,
create: 10,
age: "age",
player1: 20,
player2: 40,
sample: "sample",
player1a: 30,
player2a: 100,
},
{
name: "name",
value1: 11,
mean: 22,
create: 130,
age: "age",
player1: 210,
player2: 430,
sample: "sample",
player1a: 340,
player2a: 1100,
},
{
name: "name",
value: 313,
mean: 421,
create: 23,
age: "age",
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);Beachten Sie, dass Sie nicht zwei gleiche Schlüssel (player1 und player2) haben können, da diese eindeutig sein sollten.
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);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; }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);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:
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);