Ignora el último elemento de un json: json, ecmascript-6, lodash

Mi resultado Json de la API es el siguiente

Resultado Json:

"Issues": [{
"Id": null,
"Key": null,
"Values": [{
"Key": "Display Name",
"Value": "Rya"
},
{
"Key": "UserName",
"Value": "RH"
},
{
"Key": "Count",
"Value": "350"
}
]
},
{
"Id": null,
"Key": null,
"Values": [{
"Key": "Display Name",
"Value": "Mike"
},
{
"Key": "UserName",
"Value": "ML"
},
{
"Key": "Count",
"Value": "90"
}
]
}
]

Hice un mapeo haciendo lo siguiente:

.Issues.map(o =>
o.Values.reduce((acc, {
Key,
Value
}) =>
(acc[Key] = Value, acc), {}));

El resultado del mapeo es el siguiente:

{ "Display Name": "Rya", "UserName" : "RH", value: 350 },
{ "Display Name": "Mike", "UserName" : "ML", value: 90 }

Resultado deseado:

{ "Display Name": "Rya", "UserName" : "RH" },
{ "Display Name": "Mike", "UserName" : "ML"}

En mi requisito, quiero ignorar el último elemento como se muestra en el resultado deseado.

Respuestas

Una solución es agregar un filtro antes de la reducción para filtrar objetos con los elementos no deseados Count propiedad.

.Issues.map(o =>
o.Values
.filter(({ Key }) => Key !== "Count")
.reduce((acc, {
Key,
Value
}) =>
(acc[Key] = Value, acc), {}));

También puede hacer este filtrado en línea durante la reducción al no agregar objetos cuando Key === "Count".

Nota: No existe la última propiedad en un objeto JS. Es una colección de propiedades cuyo orden real depende de la implementación y no es confiable. Por ejemplo, imprimir su objeto en diferentes navegadores y plataformas podría dar cualquier orden, nada garantiza esa consistencia.

La solución más fácil es una combinación de mapear, cortar y reducir:

json.Issues.map(b =>
b.Values.slice(0, -1).reduce((c,d) => {
c[d.Key] = d.Value;
return c;
}, {}));

Manifestación:

let j = {
"Issues": [{
"Id": null,
"Key": null,
"Values": [{
"Key": "Display Name",
"Value": "Rya"
},
{
"Key": "UserName",
"Value": "RH"
},
{
"Key": "Count",
"Value": "350"
}
]
},
{
"Id": null,
"Key": null,
"Values": [{
"Key": "Display Name",
"Value": "Mike"
},
{
"Key": "UserName",
"Value": "ML"
},
{
"Key": "Count",
"Value": "90"
}
]
}
]
};

let r = j.Issues.map(b =>
b.Values.slice(0, -1).reduce((c, d) => {
c[d.Key] = d.Value;
return c;
}, {}));
console.log(r);

.Issues.map(o => o.Values.reduce((acc, {Key, Value}) => (Key !== "Count") ? (acc[Key] = Value, acc) : acc, {}));

código completo:

const j = {"Issues": [
{
"Id": null,
"Key": null,
"Values": [
{
"Key": "Display Name",
"Value": "Rya"
},
{
"Key": "UserName",
"Value": "RH"
},
{
"Key": "Count",
"Value": "350"
}
]
},
{
"Id": null,
"Key": null,
"Values": [
{
"Key": "Display Name",
"Value": "Mike"
},
{
"Key": "UserName",
"Value": "ML"
},
{
"Key": "Count",
"Value": "90"
}
]
}
]
}

const r = j.Issues.map(o => o.Values.reduce((acc, {Key, Value}) => (Key !== "Count") ? (acc[Key] = Value, acc) : acc, {}));

console.log(JSON.stringify(r, null, 2))

Tenga en cuenta que en un método de reducción, la función estambién pasó en el índice actual y se llama a la reducción de matriz. Entonces, si desea ignorar el último elemento de la matriz, puede hacer algo como:

Issues.map(o =>
o.Values.reduce((acc, {Key, Value}, idx, arry) => {
if(idx < arry.length -1)
acc[Key] = Value;
return acc;
}, {}
);

Para eliminar el último elemento, independientemente de cuántos elementos en la matriz, preferiría algo como esto:

let result = data.Issues.map(issue => {
let temp = issue.Values;
temp.splice(-1);
return temp.reduce((acc, {Key, Value}) => (acc[Key] = Value, acc), {});
});

Aquí "s un violín