NodeJS+Mongoose价格矩阵查询下一个最高价格值异常求助

你的问题出在两个核心点：

• 第一个聚合查询中，wideDiff和heightDiff的计算额外添加了固定偏移量（inputWidth + 65、inputHeight + 45），这会干扰实际差值计算，导致匹配逻辑偏离预期。比如查询宽度1160时，偏移后变成1225，可能错误引导排序选中更大的规格。
• 第二个聚合的totalDiff采用宽度和高度差值直接求和的加权方式，忽略了宽度在你的场景中的优先级，导致排序结果不符合“选下一个最小的更大规格”的需求。

我们调整聚合逻辑，优先匹配大于等于查询值的最小规格，同时保证排序逻辑贴合你的业务场景：

方案1：优化现有聚合查询 #

修正第一个聚合（移除偏移量，调整排序优先级） #

去掉不必要的偏移计算，同时让排序优先考虑宽度差值，确保宽度为主的规格匹配逻辑：

const symbol = findProfil.symbol;
const typsymbol = product.symbol;

const findPrice = await profilSubPriceModel.aggregate([
    {
        $match: {
            symbol: symbol,
            typSymbol: typsymbol
        }
    },
    {
        $addFields: {
            wide: { $toInt: "$wide" },
            height: { $toInt: "$height" }
        }
    },
    {
        $addFields: {
            // 保留差值正负，方便后续筛选逻辑
            wideDiff: { $subtract: ["$wide", inputWidth] },
            heightDiff: { $subtract: ["$height", inputHeight] }
        }
    },
    {
        // 筛选出与查询值方向一致的规格（要么都大于等于，要么都小于等于）
        $match: {
            $or: [
                { wideDiff: { $gte: 0 }, heightDiff: { $gte: 0 } },
                { wideDiff: { $lte: 0 }, heightDiff: { $lte: 0 } }
            ]
        }
    },
    {
        $addFields: {
            // 计算绝对差值用于排序
            absWideDiff: { $abs: "$wideDiff" },
            absHeightDiff: { $abs: "$heightDiff" }
        }
    },
    {
        // 优先按宽度绝对差值排序，再按高度，保证宽度优先级
        $sort: { absWideDiff: 1, absHeightDiff: 1 }
    },
    {
        $limit: 3
    }
]);

优化第二个聚合（精准筛选更大规格） #

如果第一个聚合无结果，专门筛选大于等于查询值的规格，按宽度差值从小到大排序，确保最小的更大规格排在最前面：

if (findPrice.length === 0) {
    const findLargerPrice = await profilSubPriceModel.aggregate([
        {
            $match: {
                symbol: symbol,
                typSymbol: typsymbol
            }
        },
        {
            $addFields: {
                wide: { $toInt: "$wide" },
                height: { $toInt: "$height" }
            }
        },
        {
            $addFields: {
                wideDiff: { $subtract: ["$wide", inputWidth] },
                heightDiff: { $subtract: ["$height", inputHeight] }
            }
        },
        {
            $match: {
                wideDiff: { $gte: 0 },
                heightDiff: { $gte: 0 }
            }
        },
        {
            // 先按宽度差值排序，再按高度，确保最小的更大规格优先
            $sort: { wideDiff: 1, heightDiff: 1 }
        },
        {
            $limit: 3
        }
    ]);

    if (findLargerPrice.length > 0) {
        findPrice.push(...findLargerPrice);
    }
}

方案2：直接针对“下一个更大规格”需求简化逻辑 #

如果你只需要获取大于等于查询值的最小规格，可以简化为以下逻辑：

const findPrice = await profilSubPriceModel.aggregate([
    {
        $match: {
            symbol: symbol,
            typSymbol: typsymbol
        }
    },
    {
        $addFields: {
            wide: { $toInt: "$wide" },
            height: { $toInt: "$height" }
        }
    },
    {
        $addFields: {
            wideDiff: { $subtract: ["$wide", inputWidth] },
            heightDiff: { $subtract: ["$height", inputHeight] }
        }
    },
    {
        $match: {
            wideDiff: { $gte: 0 },
            heightDiff: { $gte: 0 }
        }
    },
    {
        $sort: { wideDiff: 1, heightDiff: 1 }
    },
    {
        $limit: 1 // 直接获取第一个符合要求的最小规格
    }
]);

// 可选：如果没有找到更大规格，补充查询最接近的较小规格
if (findPrice.length === 0) {
    const findSmallerPrice = await profilSubPriceModel.aggregate([
        {
            $match: {
                symbol: symbol,
                typSymbol: typsymbol
            }
        },
        {
            $addFields: {
                wide: { $toInt: "$wide" },
                height: { $toInt: "$height" }
            }
        },
        {
            $addFields: {
                wideDiff: { $subtract: [inputWidth, "$wide"] },
                heightDiff: { $subtract: [inputHeight, "$height"] }
            }
        },
        {
            $match: {
                wideDiff: { $gte: 0 },
                heightDiff: { $gte: 0 }
            }
        },
        {
            $sort: { wideDiff: 1, heightDiff: 1 }
        },
        {
            $limit: 1
        }
    ]);
    findPrice.push(...findSmallerPrice);
}

• 移除固定偏移量：inputWidth + 65这类偏移会导致差值计算偏离实际查询需求，必须去掉才能准确匹配规格。
• 调整排序优先级：优先按宽度差值排序，再按高度，符合你场景中宽度为主的规格变化逻辑。
• 明确筛选条件：针对“下一个更大规格”的需求，直接筛选wideDiff >= 0和heightDiff >= 0的文档，确保只考虑符合要求的规格。

内容的提问来源于stack exchange，提问作者Savas