js——数据操作——实现阶梯价格排序—

js——数据操作——实现阶梯价格排序——基础积累

news2024/11/19 1:18:30

最近在写网络报价的时候，遇到一个需求，就是要根据采购数量，找到符合数量的阶梯区间，并找到最便宜的采购价格。

比如下面：

let originViewList = [
	{
		id:1,
		incrementalQuantity:10,
		priceList:[
			{
				minQuantity:1,
				price:20
			},
			{
				minQuantity:1,
				price:18
			},
			{
				minQuantity:300,
				price:17
			}
		]
	}
]

上面数据中的incrementalQuantity是增长量，minQuantity是阶梯数，比如采购的数量是200，则可以选择minQuantity为1的，然后增长量是10的，这样，200 = 1+1020；则最后的采购量是201。如果选择minQuantity为300，则最低采购量只能是300了。两者价格比较：20120与300*17相比较，还是选择minQuantity为1的采购价格更低，而且minQuantity为1的价格为18的采购价更低，所以最后选择的是{minQuantity:1,price:18}的一组。

所以要实现的效果：

1.根据阶梯数+增长量：获取最终的采购量，阶梯数低于采购量的，需要配合增长量。阶梯数高于采购量的，直接使用阶梯数作为采购量
2.如果阶梯数有相同的，则需要找个价格最低的

下面是我的解决思路：

解决步骤1：根据采购量找到介于哪两个阶梯价之间

findNearestNumber(arr, target){
    return arr.reduce((pre, curr) => {
        return Math.abs(pre - target) > Math.abs(curr - target) ? curr : pre;
    })
},

使用方法：

let numArr = [1,1,20,30];
let num = 12;
let nearNum = this.findNearestNumber(numArr, num);
let nearIndex = numArr.indexOf(nearNum);
if (numArr[nearIndex] > num) {
    nearIndex = nearIndex - 1 > -1 ? nearIndex - 1 : 0;
}
console.log(nearIndex);

在这里插入图片描述
也就是说12最接近的索引是1，也就是介于索引1到索引2之间。

再看下数量是2的，最接近的索引是0，索引1也是最接近的，这种相同阶梯数的后面有处理。

解决步骤2：根据阶梯数+增长量获取最终的采购量

let arr = originViewList[0].priceList;
let resultNum = Math.ceil((num - arr[nearIndex].minQuantity) / this.originViewList[index].incrementalQuantity) * this.originViewList[index].incrementalQuantity + arr[nearIndex].minQuantity;
console.log('numArr', numArr, nearIndex, resultNum);

上面数据中的incrementalQuantity是增长量，minQuantity是阶梯数，比如采购的数量是200，则可以选择minQuantity为1的，然后增长量是10的，这样，200 = 1+10*20；则最后的采购量是201。如果选择minQuantity为300，则最低采购量只能是300了。

解决步骤3：如果阶梯数有相同，则需要根据价格排序，找最低价的

//如果有数量相同的情况
let eqIndexArr = [];
numArr.forEach((n, nIndex) => {
    if (n == numArr[nearIndex]) {
        eqIndexArr.push(nIndex);
    }
})

if (eqIndexArr.length > 1) {
    let eqPriceArr = [];
    eqIndexArr.forEach((eq) => {
        eqPriceArr.push({ index: eq, price: arr[eq].price });
    })
    const sortBy = (field) => {
        return function (a, b) {
            return a[field] - b[field];
        };
    }
    let maxArr = eqPriceArr.sort(sortBy('price'));//对象数组根据price价格字段升序排列
    this.OptimalIndex[index] = maxArr[0].index;
    res = resultNum * maxArr[0].price;//采购量*最低价格
}

解决步骤4：如果没有相同阶梯价的，则直接计算

//当前阶梯价*采购量与下一个的最小数量*价格相比较，谁的采购价低，选择谁
if (resultNum * arr[nearIndex].price < arr[nearIndex + 1].minQuantity * arr[nearIndex + 1].price) {
    this.OptimalIndex[index] = nearIndex;
    res = resultNum * arr[nearIndex].price;
} else {
    this.OptimalIndex[index] = nearIndex + 1;
    res = arr[nearIndex + 1].minQuantity * arr[nearIndex + 1].price;
}

上面的两种情况都能拿到最终的采购总价了。下面根据采购总价进行排序：

//sortLevel  是升序还是降序的判断
priceSort(num) {
    var _that = this;
    this.viewList.forEach((item, index) => item.Index = index);
    this.originViewList = JSON.parse(JSON.stringify(this.viewList));
    if (this.viewList.length == 1) {
        _that.findPriceListPrice(this.viewList[0].priceList, num, this.viewList[0].Index);
    } else {
        this.viewList.sort(function (a, b) {
            //找index  a.priceList   b.priceList
            var aPrice = _that.findPriceListPrice(a.priceList, num, a.Index);
            var bPrice = _that.findPriceListPrice(b.priceList, num, b.Index);
            return !_that.sortLevel ? (aPrice - bPrice) : (bPrice - aPrice);
        })
    }
},

合并代码记录：
最终代码记录：

priceSort(num) {
    var _that = this;
    this.viewList.forEach((item, index) => item.Index = index);
    this.originViewList = JSON.parse(JSON.stringify(this.viewList));
    if (this.viewList.length == 1) {
        _that.findPriceListPrice(this.viewList[0].priceList, num, this.viewList[0].Index);
    } else {
        this.viewList.sort(function (a, b) {
            //找index  a.priceList   b.priceList
            var aPrice = _that.findPriceListPrice(a.priceList, num, a.Index);
            var bPrice = _that.findPriceListPrice(b.priceList, num, b.Index);
            return !_that.sortLevel ? (aPrice - bPrice) : (bPrice - aPrice);
        })
    }
},
findPriceListPrice(arr, num, index) {
   var res = 99999999;
   let numArr = arr.map(a => a.minQuantity);
   if (!num) {
       res = 99999999;
   } else {
       let nearNum = this.findNearestNumber(numArr, num);
       let nearIndex = numArr.indexOf(nearNum);
       if (numArr[nearIndex] > num) {
           nearIndex = nearIndex - 1 > -1 ? nearIndex - 1 : 0;
       }
       let resultNum = Math.ceil((num - arr[nearIndex].minQuantity) / this.originViewList[index].incrementalQuantity) * this.originViewList[index].incrementalQuantity + arr[nearIndex].minQuantity;
       console.log('numArr', numArr, nearIndex, resultNum);
       if (nearIndex < arr.length - 1) {
           //如果有数量相同的情况
           let eqIndexArr = [];
           numArr.forEach((n, nIndex) => {
               if (n == numArr[nearIndex]) {
                   eqIndexArr.push(nIndex);
               }
           })
           if (eqIndexArr.length > 1) {
               let eqPriceArr = [];
               eqIndexArr.forEach((eq) => {
                   eqPriceArr.push({ index: eq, price: arr[eq].price });
               })
               const sortBy = (field) => {
                   return function (a, b) {
                       return a[field] - b[field];
                   };
               }
               let maxArr = eqPriceArr.sort(sortBy('price'));
               this.OptimalIndex[index] = maxArr[0].index;
               res = resultNum * maxArr[0].price;
           } else {
               if (resultNum * arr[nearIndex].price < arr[nearIndex + 1].minQuantity * arr[nearIndex + 1].price) {
                   this.OptimalIndex[index] = nearIndex;
                   res = resultNum * arr[nearIndex].price;
               } else {
                   this.OptimalIndex[index] = nearIndex + 1;
                   res = arr[nearIndex + 1].minQuantity * arr[nearIndex + 1].price;
               }
           }
       } else {
           this.OptimalIndex[index] = nearIndex;
           res = resultNum * arr[nearIndex].price;
       }
   }
   return res;
},
findNearestNumber(arr, target){
   return arr.reduce((pre, curr) => {
       return Math.abs(pre - target) > Math.abs(curr - target) ? curr : pre;
   })
},

上面的代码逻辑其实是有问题的，最正确的解决办法就是：根据每一个的阶梯数，获取最终的采购量，然后与各自的价格相乘，找最低的作为最终的采购价。

这样才是最正确的。

下面附上最正确的解决办法：

findPriceListPrice(list, num, index) {
  var res = 99999999;
  let arr = JSON.parse(JSON.stringify(list));
  arr && arr.forEach((a, aIndex) => {
      a.index = aIndex;
  })
  console.log('arr', arr);
  if (!num) {
      res = 99999999;
  } else {
      arr && arr.forEach(item => {
          if (item.minQuantity < num) {
              item.resultNum = Math.ceil((num - item.minQuantity) / this.originViewList[index].incrementalQuantity) * this.originViewList[index].incrementalQuantity + item.minQuantity;
          } else {
              item.resultNum = item.minQuantity;
          }
          item.totalPrice = item.resultNum * item.price;
      })
      const sortBy = (field) => {
          return function (a, b) {
              return a[field] - b[field];
          };
      }
      let maxArr = arr.sort(sortBy('totalPrice'));
      console.log('maxArr', maxArr);
      this.OptimalIndex[index] = maxArr[0].index;
      res = maxArr[0].totalPrice;
  }
  return res;
},