Javascript lodash将对象数组转换为单个键数组和多个值数组

我需要传输一些数据，这有太多的键值对。 由于键是相似的，我不想将它们与每个对象一起传输

假设我有以下数据：

[
    {
        x:11,
        y:12
    },{
        x:21,
        y:22
    },{
        x:31,
        y:32
    },{
        x:41,
        y:42
    }
];

我需要最终输出为

[[x，y]，[11,12]，[21,22]，[31,32]，[41,42]]]

或

[[x，y]，[11,12]，[21,22]，[31,32]，[41,42]。

另一方面，我应该能够转换回其原始形式。 如果它能处理某些对象中的附加键，那就太好了

我想我已经看到了lodash或下划线函数的类似之处，但我现在找不到它

注意：我不知道使用

var-arr=[{
x:11,，
y:12
}, {
x:21，
y:22
}, {
x:31，
y:32
}, {
x:41，
y:42
}];
var keys=Object.keys（arr[0]）；
var op=arr.reduce（函数（a，b）{
var arr=键。减少（函数（x，y）{
返回x.concat（[b[y]]）；
}, [])
返回a.concat（[arr]）；
}，[键]//如果所有对象都具有相同的关键点！
log（JSON.stringify（op））使用


var-arr=[{
x:11,，
y:12
}, {
x:21，
y:22
}, {
x:31，
y:32
}, {
x:41，
y:42
}];
var keys=Object.keys（arr[0]）；
var op=arr.reduce（函数（a，b）{
var arr=键。减少（函数（x，y）{
返回x.concat（[b[y]]）；
}, [])
返回a.concat（[arr]）；
}，[键]//如果所有对象都具有相同的关键点！
log（JSON.stringify（op））更详细一点的方法：
[编辑：添加了将其转换回的功能]


函数转换（arr）{
变量retArr=[[/*键（retArr[0]）*/]，[/*值（retArr[1]）*/]
arr.forEach（功能（obj）{
//为新的值集创建新数组
retArr[1]。推送（[]）
//将所有键放入正确的数组中
for（obj中的var键）{
if（对象hasOwnProperty（键））{
//该密钥是否存在于数组中？
if（retArr[0].indexOf（键）=-1）{
重新安装[0]。按（键）
}
//获取retArr[1]的最后一个索引，并推送这些值
retArr[1][retArr[1]。长度-1]。推送（obj[键]）
}
}
})
回程复飞
}
功能再转换（arr）{
var retArr=[]
var keys=arr[0]
arr[1]。forEach（函数（itemArr）{
var obj={}
itemArr.forEach（功能（项目i）{
obj[键[i]]=项
})
再推力（obj）
})
回程复飞
}
变量objArr=[
{
x:11,，
y:12
},{
x:21，
y:22
},{
x:31，
y:32
},{
x:41，
y:42
}
]
var arrFromObj=转换（objArr）
var objFromArr=再转换（ARRFOMOBJ）
console.log（arrFromObj）
console.log（objFromArr）
更详细一点的方法：
[编辑：添加了将其转换回的功能]


函数转换（arr）{
变量retArr=[[/*键（retArr[0]）*/]，[/*值（retArr[1]）*/]
arr.forEach（功能（obj）{
//为新的值集创建新数组
retArr[1]。推送（[]）
//将所有键放入正确的数组中
for（obj中的var键）{
if（对象hasOwnProperty（键））{
//该密钥是否存在于数组中？
if（retArr[0].indexOf（键）=-1）{
重新安装[0]。按（键）
}
//获取retArr[1]的最后一个索引，并推送这些值
retArr[1][retArr[1]。长度-1]。推送（obj[键]）
}
}
})
回程复飞
}
功能再转换（arr）{
var retArr=[]
var keys=arr[0]
arr[1]。forEach（函数（itemArr）{
var obj={}
itemArr.forEach（功能（项目i）{
obj[键[i]]=项
})
再推力（obj）
})
回程复飞
}
变量objArr=[
{
x:11,，
y:12
},{
x:21，
y:22
},{
x:31，
y:32
},{
x:41，
y:42
}
]
var arrFromObj=转换（objArr）
var objFromArr=再转换（ARRFOMOBJ）
console.log（arrFromObj）
console.log（objFromArr）
Lodash v4.17.1

修改原件

var modifiedOriginal = _.chain(original)
    .map(_.keys)
    .flatten()
    .uniq()
    .thru(function(header){
        return _.concat(
            [header],
            _.map(original, function(item) {
                return _.chain(item)
                    .defaults(_.zipObject(
                        header, 
                        _.times(_.size(header), _.constant(undefined))
                     ))
                     .pick(header)
                     .values()
                     .value()
            })
         );  
     })
     .value();

修改回原始状态（钥匙顺序不正确
（保证书）

JSFIDLE代码
Lodash v4.17.1

修改原件

var modifiedOriginal = _.chain(original)
    .map(_.keys)
    .flatten()
    .uniq()
    .thru(function(header){
        return _.concat(
            [header],
            _.map(original, function(item) {
                return _.chain(item)
                    .defaults(_.zipObject(
                        header, 
                        _.times(_.size(header), _.constant(undefined))
                     ))
                     .pick(header)
                     .values()
                     .value()
            })
         );  
     })
     .value();

修改回原始状态（钥匙顺序不正确
（保证书）

JSFIDLE代码在ES6中，您可以通过使用和来减少代码。您可以组合使用
Array.prototype.map（）
和
Array.prototype.reduce（）
来还原它：


const convertStructure=（数据）=>data.reduce（（s，项）=>{
s[1].push（Object.values（item））；
返回s；
}，[Object.keys（数据[0]），[]]；//所有对象都应该相同，因此我们可以从第一个对象获取关键点
const restoreStructure=（[keys，data]）=>data.map（（项）=>item.reduce（（o，v，i）=>{
o[键[i]]=v；
返回o；
}, {}));
常数数据=[{
x:11,，
y:12
}, {
x:21，
y:22
}, {
x:31，
y:32
}, {
x:41，
y:42
}];
const convertedStructure=convertedStructure（数据）；
log（'convertedStructure:\n'，convertedStructure）；
const restoredStructure=restoredStructure（convertedStructure）；
log（'restoredStructure:\n'，restoredStructure）在ES6中，您可以通过使用和来减少它。您可以组合使用
Array.prototype.map（）
和
Array.prototype.reduce（）
来还原它：


const convertStructure=（数据）=>data.reduce（（s，项）=>{
s[1].push（Object.values（item））；
返回s；
}，[Object.keys（数据[0]），[]]；//所有对象都应该相同，因此我们可以从第一个对象获取关键点
const restoreStructure=（[keys，data]）=>data.map（（项）=>item.reduce（（o，v，i）=>{
o[键[i]]=v；
返回o；
}, {}));
常数数据=[{
x:11,，
y:12
}, {
x:21，
y:22
}, {
x:31，
y:32
}, {
x:41，
y:42
}];
const convertedStructure=convertedStructure（数据）；
log（'convertedStructure:\n'，convertedStructure）；
const restoredStructure=restoredStructure（convertedStructure）；
欺骗
var keys = _.chain(data)
    .map(_.keys)
    .flatten()
    .uniq()
    .value();

var result = [
    keys, 
    _.map(data, item => _.map(keys, key => item[key]))
];

var thereAndBackAgain = _.map(result[1], item => _.omit(_.object(result[0], item), _.isUndefined));

var thereAndBackAgain = _.map(result[1], item => _.omitBy(_.zipObject(result[0], item), _.isUndefined));