构建商品SKU规格表如果问询AI分分钟钟的事，但想自己构思挑战下代码逻辑，想到每列的规格都是向右递乘式的增加，就构思了第一个递乘方法，不过构思几分钟调整修改bug却是几个小时😓，随后又构思出倒序COPY法，也是中间出现失误耽误些时间，人脑想法是好，但还真容易出错。。。

最后一个方法是AI给出的，感觉类似嵌套数组并扁平化，规格多了执行效率确实是最快的。

// 商品 SKU 组合

var time_start = new Date().getTime();

var skuAttr = [
  {
    "propertyName": "尺寸",
    "values": [
      {"valId": 1,"val": "L"},
      {"valId": 2,"val": "XL"},
      {"valId": 2,"val": "XXL"}
    ]
  },
  {
    "propertyName": "币种",
    "values": [
      {"valId": 7,"val": "人民币"},
      {"valId": 8,"val": "美元"}
    ]
  },
  {
    "propertyName": "颜色",
    "values": [
      {"valId": 10,"val": "红"},
      {"valId": 11,"val": "黄"},
      {"valId": 11,"val": "蓝"}
    ]
  }
]
// for(var i = 0; i < 6; i++){
//     skuAttr.push(JSON.parse(JSON.stringify(...skuAttr)))
// }


// ===============================================递乘法：
var tableData = [], divisor = [], tableTotal = 0;

function newTableData() {
    var multiply = 1;
    divisor = []
    for (var k in skuAttr) {//计算总条数
        var num = skuAttr[k].values.length;
        multiply = Math.round(multiply * (num || 1));
        divisor.push([0, multiply]);//[递增数, 后列递乘数]
    }
    tableTotal = multiply;
    recurCategory(tableTotal)
}
function recurCategory(len) {
    tableData = [];
    for (var i = 0; i < len; i++) {
        var obj = {}
        //每条数据的规格值
        var properties = [];
        for (var j = 0; j < divisor.length; j++) {
            const _c = skuAttr[j];
            if (i != 0 && i % Math.round(len / divisor[j][1]) == 0) { //计算递增数 i%(总数/递乘数量)
                divisor[j][0] = divisor[j][0] < _c.values.length - 1 ? divisor[j][0] + 1 : 0;
            }
            var data = JSON.parse(JSON.stringify(_c));
            properties.push(data);
        }
        obj.attr = properties;
        tableData.push(obj)
    }
}

time_start = new Date().getTime();
newTableData();
console.log('递乘法：',tableData);
console.log('递乘法耗时：',new Date().getTime() - time_start);


// ===============================================倒序递归COPY法：

var skus2 = [], ii = skuAttr.length-1;

function skuForInit() {
    var rowsData = {attr:[]}
    for (let i = 0; i < skuAttr.length; i++) {
        rowsData.attr.push(skuAttr[i].values[0])
    }
    let datlen = skuAttr[ii].values;
    for (let i = 0; i < datlen.length; i++) {
        var obj = JSON.parse(JSON.stringify(rowsData))
        obj.attr[ii] = datlen[i];
        skus2.push(obj)
    }
    ii--;
}

function skuFor() {
    if(ii<0){
        return;
    }
    let arr = []
    let datlen = skuAttr[ii].values;// 要修改的列
    for (let i = 1; i < datlen.length; i++) { //从第二个开始
        var copy = JSON.parse(JSON.stringify(skus2))
        for (let j = 0; j < copy.length; j++) {
            copy[j].attr[ii] = datlen[i];
        }
        arr.push(...copy)
    }
    skus2.push(...arr)
    ii--;
    skuFor();
}

time_start = new Date().getTime();
skuForInit()
skuFor()

console.log('倒序递归COPY法：',skus2);
console.log('倒序递归COPY法耗时：',new Date().getTime() - time_start);


// ===============================================笛卡尔积数组扁平化：

function cartesianProduct(skuAttr) {
  return skuAttr.reduce((a, b) => {
    return a.map(x => {
      return b.values.map(y => {
        // return [...x, y]
        return {attr:[...x.attr, y]};
      });
    }).flat();
  }, /*[[]]*/ [{ attr: [] }]);
}

function formatSkus(skuAttr) {
  const skusFormatted = cartesianProduct(skuAttr);
  console.log("🚀 ~ formatSkus ~ skusFormatted:", skusFormatted)
  console.log('笛卡尔积耗时：',new Date().getTime() - time_start);
  console.log("所有规格组合：");
  // skusFormatted.forEach(sku => {
  //   let skuString = skuAttr.map((skuProperty, index) => {
  //     return `${skuProperty.propertyName}:${sku[index].val}`;
  //   }).join(", ");
  //   console.log(skuString);
  // });
}

time_start = new Date().getTime();
formatSkus(skuAttr);