使用lodash映射复杂的JSON

Question

我正在尝试将数据从一种格式映射到另一种格式，而我却遇到了一些困难。

第一个

从：

  types: {
      one: [0.0954835843,6.054385,84.40238],
      two: [0.0954835843,6.054385,84.40238],
      three: [0.0954835843,6.054385,84.40238]
    },

到

    types: [
      [0.0954835843,6.054385,84.40238 , 'one'],
      [0.0954835843,6.054385,84.40238, 'two'],
      [0.0954835843,6.054385,84.40238, 'three']
    ],

第二个 通过从两个对象获取数据来匹配ID

          types:[{
            id:1, 
            data:[
                    [
                        'temp',
                        '46%',
                        '14.00',
                        '1388.68561604',
                        '1388.68561604',
                        '2018-02-12 18:21'

                    ],
                    [
                        'nottemp',
                        '46%',
                        '14.00',
                        '1388.68561604',
                        '1388.68561604',
                        '2018-02-12 18:21'

                    ],
               ] 
            },
            {
            id:2, 
            data:[
                    [
                        'temp',
                        '46%',
                        '14.00',
                        '1388.68561604',
                        '1388.68561604',
                        '2018-02-12 18:21'

                    ],
                    [
                        'nottemp',
                        '46%',
                        '14.00',
                        '1388.68561604',
                        '1388.68561604',
                        '2018-02-12 18:21'

                    ],
               ] 
            }]






data: [
        {
          id: 1,
          name: 'sibling',
        },
        {
          id: 2,
          name: 'parent',
        },
     ]

并最终得到types.data中的所有项目，格式如下：

        [
                'temp',
                '46%',
                '14.00',
                '1388.68561604',
                '1388.68561604',
                '2018-02-12 18:21'
                'parent' //or sibling, depends on id

            ]

我实际上不知道如何通过一些映射或过滤来实现这一点。 如果没有大量的修改器并且在这个过程中没有创建很少的额外数组，那么我很难实现它。有没有办法优化它？

修改 对于我的第二个问题：

   mapElement: function(){
        let that=this;
        return _.map(this.getTypesData,function(element){
          let data=[];
          let pairName = that.getFamily(element.id); //todo: matching id of Type with id of object with names
          element.data.forEach(function(element){
            data.push([
              pairName,
              element[0],
              element[1],
              element[2],
            ]);
          });
          return data;
        });
      }

Answer 1

试试这个，

const input = {types: {
      one: [0.0954835843,6.054385,84.40238],
      two: [0.0954835843,6.054385,84.40238],
      three: [0.0954835843,6.054385,84.40238]
    },
}
const output = Object.keys(input.types).map((key,val) => {
  return [...input.types[key],key];
})
console.log(output);

1.使用Object.keys获取对象的键（lodash，_. keys（））。

2

return [...input.types[key],key]

以上这一行可以分为（为了更好地理解），

const returnVal = _.clone(input.type[key]).push(key);
return returnVal

如果你明白了，那么你可以自己尝试第二个。

Answer 2

对于第一个，只需使用Object.entries并将密钥附加到结尾：

const obj = {
  types: {
    one: [0.0954835843, 6.054385, 84.40238],
    two: [0.0954835843, 6.054385, 84.40238],
    three: [0.0954835843, 6.054385, 84.40238]
  },
};
obj.types = Object.entries(obj.types)
  .map(([key, val]) => [...val, key]);
console.log(obj);

对于第二个，你只需要map一次，找到数据对象中的键+字符串，然后返回内部数组的地图，附加找到的字符串：

const types = [{
    id: 1,
    data: [
      [
        'temp',
        '46%',
        '14.00',
        '1388.68561604',
        '1388.68561604',
        '2018-02-12 18:21'

      ],
      [
        'nottemp',
        '46%',
        '14.00',
        '1388.68561604',
        '1388.68561604',
        '2018-02-12 18:21'

      ],
    ]
  },
  {
    id: 2,
    data: [
      [
        'temp',
        '46%',
        '14.00',
        '1388.68561604',
        '1388.68561604',
        '2018-02-12 18:21'

      ],
      [
        'nottemp',
        '46%',
        '14.00',
        '1388.68561604',
        '1388.68561604',
        '2018-02-12 18:21'

      ],
    ]
  }
];

const data = [
  {
    id: 1,
    name: 'sibling',
  },
  {
    id: 2,
    name: 'parent',
  },
];

types.data = types.map(({ id, data: typesData }) => {
  const str = data.find(({ id: dataId }) => dataId === id).name;
  return typesData.map(arr => [...arr, str]);
});
console.log(types.data);

Answer 3

首先：

const newTypes1 = Object.keys(obj.types).map(t => {
  return [...obj.types[t], t];
});

第二

types.forEach(t => {
  const name = data.find(function(x) { return x.id == t.id }).name;
  t.data.forEach(d => { d.push(name) });
});

编辑：对于第一个，创建一个新数组，对于第二个，将在数组中推送名称，以便保留相同的对象。

Answer 4

第一个问题：

使用_.map非常轻松：

// Also handle case value is not array
types = _.map(types, (val, key) => _.isArray(val) ? v.concat(key) : [val].concat(key)); 

第二个问题：

我针对性能进行了优化：

//clone to new object to avoid modifying original data
const cloneData = _.cloneDeep(data);

types = _.map(types, (val, key) => {
    const index = _.findIndex(cloneData, { id: val.id});
    val.data = _.map(val.data, (v)=> _.isArray(v) ?v.concat(cloneData[index].name) : [v].concat(cloneData[index].name));
    //remove when found id to shorten the array
    // if the types[].id is not unique, remove this
    cloneData.splice(index,1);

    return val;
})