请问怎么将这个数组转换我想要的结构？

Question

let a = [{
      label: "英国2号处理中心",
      prop: "center",
    },
    {
      label: "美国1号处理中心",
      prop: "center",
    }, {
      label: "法国处理中心",
      prop: "center",
    },
    {
      label: "CNY",
      prop: "currency",
    },
    {
      label: "USD",
      prop: "currency",
    },
    {
      label: "JPY",
      prop: "currency",
    }
  ];
  
  let b = [{
      center: "英国2号处理中心",
      currency: "CNY"
    },
    {
      center: "英国2号处理中心",
      currency: "USD"
    }, {
      center: "英国2号处理中心",
      currency: "JPY"
    },
    {
      center: "美国1号处理中心",
      currency: "CNY"
    },
    {
      center: "美国1号处理中心",
      currency: "USD"
    },
    {
      center: "美国1号处理中心",
      currency: "JPY"
    }, {
      center: "法国处理中心",
      currency: "CNY"
    }, {
      center: "法国处理中心",
      currency: "USD"
    }, {
      center: "法国处理中心",
      currency: "JPY"
    }
  ];

如何动态把a数组结构转换成b数组结构？像如果在a数组再添加一个新的prop属性b数组也对应生成。

let arr = [["英国2号处理中心", "英国3号处理中心"],["CNY", "USD"],["a公司", "b公司"]];
    let narr = []

    arr[0].forEach((item, i) => {
      arr[1].forEach(item2 => {
        arr[2].forEach(item3 => {
          narr.push({
            center: item,
            currency: item2,
            company: item3
          });
        });
      });
    });

或者像这条数据，arr数组是动态不确定有几层的，如何动态的循环生成同样的narr数组呢？

Answer 1

function transform(items = []) {
  const record = {};
  for (const { label, prop } of items) {
    (record[prop] || (record[prop] = [])).push({ [prop]: label });
  }

  let result = [];
  for (const pairs of Object.values(record)) {
    if (0 === result.length) {
      result.push({});
    }

    result = result.flatMap((item) =>
      pairs.map((pair) => ({...item, ...pair}))
    );
  }

  return result;
}

transform(a);

第二种没给key

Answer 2

 function arrange(list) {
    return Object.values(list.reduce((pre, cur) => {
        let item = {[cur.prop]: cur.label};
        if (pre[cur.prop]) {
            pre[cur.prop].push(item);
        } else {
            pre[cur.prop] = [item];
        }
        return pre;
    },{}))
  }

  function combination(data, result = [], temp = {}, index = 0) {
    for (const item of data[index]) {
        let cur = {...temp, ...item};
        if (index < data.length-1) {
            combination(data, result, cur, index + 1);
        } else {
            result.push(cur);
        }
    }
    return result;
  }

  console.log(combination(arrange(a)))

Answer 3

function handler(arr) {
  if (!arr.length) return [];

  const propArr = Object.values(
    arr.reduce((iter, { prop, label }) => {
      const item = { [prop]: label };
      if (iter[prop]) {
        iter[prop].push(item);
      } else {
        iter[prop] = [item];
      }
      return iter;
    }, {})
  );
  // [
  //  [{ center: '英国' }, { center: '美国' }, { center: '法国' }],
  //  [{ currency: 'CNY' }, { currency: 'USD' }, { currency: 'JPY' }],
  //  [{ company: 'baidu' }, { company: 'google' }]
  // ]
  // 处理得到此类数据结构之后遍历数组，每两组合并之后的结果再和第三组合并
  const rst = propArr.reduce((iter, _, idx) => {
    const nextArr = propArr[idx + 1];
    if (!nextArr) return iter;
    let tmp = [];
    iter.forEach((v1) => {
      nextArr.forEach((v2) => {
        tmp.push(Object.assign({}, v1, v2));
      });
    });
    return tmp;
  }, propArr[0]);
  return rst;
}
console.log(handler(a));

Answer 4

先根据 prop 把数组分成两拨，一拨是中心，另一拨是币种，然后两个数组做两两组合。不管代码怎么写，逻辑都是这个。

一种思路，分组用 filter 搞定，组合用两层循环就可以。

第二个类型的数组，你需要一个规则来区分什么是币种，有这个规则后，逻辑同理。