来个 js 算法大佬 写个优雅点的?

Question

请把以数据

{
    'month':['一月','二月','三月'],
    'drink':[100,200,300],
    'car':[10,15,25]
}

转换成

[
    { month: '一月', drink: 100, car: 10 },
    { month: '二月', drink: 200, car: 15 },
    { month: '三月', drink: 300, car: 25 },
]

有没有优雅点的写法?

Answer 1

Object.entries({
    'month':['一月','二月','三月'],
    'drink':[100,200,300],
    'car':[10,15,25]
}).reduce((res,[k,v]) => {
    v.forEach((e,i) => (res[i] ||= {})[k] = e)
    return res;
}, [])

Answer 2

先来两个 Lodash 的解决办法

const keys = _.keys(source);
const values = _.values(source);
const result = _.zipWith(...values, (...values) => {
    return _.zipObject(keys, values);
});

const result = _(source).entries()
    .map(([key, values]) => values.map(v => [key, v]))
    .unzip()
    .map(_.fromPairs)
    .value();

不过 Lodash 处理起来真的很慢。然后这里还有一个快不了多少的原生方法：

const entries = Object.entries(source);
const result = entries[0][1].map((_, i) => Object.fromEntries(
    entries.map(([key, values]) => [key, values[i]])
));

之所以快不了多少，是因为它实际的遍历过程太多了。最快的还是 @zangeci 的写法，进行了最少的遍历。我下面这个写法跟他一样，唯一的区别是把 ||= 换成了 ??=。不过比较下来效率是一样的。

const result = Object.entries(source).reduce(
    (r, [k, v]) => {
        v.forEach((it, i) => (r[i] ??= {})[k] = it);
        return r;
    },
    []
);

传送门：这是性能比较

Answer 3

function transform(obj) {
    var ret = [];
    for (var key in obj) {
        for (var i = 0; i < obj[key].length; ++i) {
            (ret[i] = ret[i] || {})[key] = obj[key][i];
        }
    }
    return ret;
}
console.dir(transform({
    'month': ['一月', '二月', '三月'],
    'drink': [100, 200, 300],
    'car': [10, 15, 25]
}));

Answer 4

let obj = {
  'month': ['一月', '二月', '三月'],
  'drink': [100, 200, 300],
  'car': [10, 15, 25]
}

function trans(obj, object = {}) {
  Object.entries(obj).forEach(([key, array], index) => {

    obj[key].reduce((acc, curr, idx) => {
      acc[idx] = { ...acc[idx], [key]: curr }

      return acc
    }, object)
  })

  return Object.entries(object).map(([key, val]) => val)
}

let res = trans(obj)

console.log(res);

简单的两层循环搞定