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

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

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

比如下面：

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.priceListvar 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.priceListvar 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;
},