diff --git a/pages/compare_price/index.js b/pages/compare_price/index.js
index e41e51a..4485c49 100644
--- a/pages/compare_price/index.js
+++ b/pages/compare_price/index.js
@@ -130,7 +130,9 @@ Page({
     currentGoods: null,
     currentSwiperIndex: 0,
     currentPage: 1,
-    hasMore: true
+    pageSize: 10, // 每页展示10条数据
+    hasMore: true,
+    allGoods: [] // 存储所有符合条件的商品
   },
 
   onLoad: function (options) {
@@ -490,350 +492,283 @@ Page({
       loadingMore: page > 1 ? true : false
     });
     
-    API.getProducts(page, 20, 'all', '')
-      .then(res => {
-        console.log('获取商品列表成功:', res);
-        console.log('选择的种类:', selectedCategory);
-        console.log('选择的规格:', specWeight);
-        
-        let filteredGoods = [];
-        if (res && res.products) {
-          console.log('原始商品数量:', res.products.length);
-          // 获取当前商品的唯一标识符
-          const currentGoodsId = goodsData.productId || goodsData.id || goodsData._id;
-          console.log('当前商品ID:', currentGoodsId);
+    // 如果是第一页，获取所有符合条件的商品
+    if (page === 1) {
+      // 使用新的API接口获取相同规格的商品数据
+      API.getProductsBySpecification(specWeight)
+        .then(comparisonProducts => {
+          console.log('获取到的对比商品数据:', comparisonProducts);
+          console.log('选择的种类:', selectedCategory);
+          console.log('选择的规格:', specWeight);
           
-          // 过滤商品
-          filteredGoods = res.products.filter(item => {
-            // 1. 排除当前商品
-            const itemId = item.productId || item.id || item._id;
-            if (currentGoodsId && itemId && currentGoodsId === itemId) {
-              console.log('排除当前商品:', itemId);
-              return false;
-            }
+          let filteredGoods = [];
+          if (comparisonProducts && Array.isArray(comparisonProducts)) {
+            console.log('原始商品数量:', comparisonProducts.length);
+            // 获取当前商品的唯一标识符
+            const currentGoodsId = goodsData.productId || goodsData.id || goodsData._id;
+            console.log('当前商品ID:', currentGoodsId);
             
-            // 2. 检查商品状态和价格
-            if ((item.status !== 'published' && item.status !== 'sold_out') || item.price === null || item.price === undefined) {
-              return false;
+            // 过滤商品
+            filteredGoods = comparisonProducts.filter(item => {
+              // 1. 排除当前商品
+              const itemId = item.productId || item.id || item._id;
+              if (currentGoodsId && itemId && currentGoodsId === itemId) {
+                console.log('排除当前商品:', itemId);
+                return false;
+              }
+              
+              // 2. 检查商品状态和价格
+              if ((item.status !== 'published' && item.status !== 'sold_out') || item.price === null || item.price === undefined) {
+                return false;
+              }
+              
+              // 3. 过滤种类
+              if (selectedCategory && selectedCategory !== '全部' && item.category !== selectedCategory) {
+                return false;
+              }
+              
+              return true;
+            });
+            console.log('过滤后的商品数量:', filteredGoods.length);
+            console.log('过滤后的商品:', filteredGoods);
+          }
+          
+          // 处理商品数据
+          const processedGoods = filteredGoods.map(item => {
+            // 首先清理 imageUrls 字段（如果存在）
+            if (item.imageUrls && Array.isArray(item.imageUrls)) {
+              item.imageUrls = item.imageUrls.map(url => {
+                return url.trim().replace(/[`]/g, '');
+              });
+              
+              // 使用processMediaUrls函数处理媒体数据
+              item.mediaItems = processMediaUrls(item.imageUrls);
+              
+              // 确保图片优先显示：将图片类型的媒体项移到数组前面
+              if (item.mediaItems && item.mediaItems.length > 1) {
+                const imageItems = item.mediaItems.filter(media => media.type === 'image');
+                const videoItems = item.mediaItems.filter(media => media.type === 'video');
+                item.mediaItems = [...imageItems, ...videoItems];
+              }
             }
             
-            // 3. 过滤种类
-            if (selectedCategory && selectedCategory !== '全部' && item.category !== selectedCategory) {
-              return false;
+            // 清理 mediaItems 中的 URL
+            if (item.mediaItems && Array.isArray(item.mediaItems)) {
+              item.mediaItems = item.mediaItems.map(media => {
+                if (media.url) {
+                  // 去除 URL 中的反引号和空格
+                  media.url = media.url.trim().replace(/[`]/g, '');
+                  // 确保媒体类型正确
+                  if (!media.type) {
+                    media.type = isVideoUrl(media.url) ? 'video' : 'image';
+                  }
+                }
+                return media;
+              });
             }
             
-            // 4. 过滤规格
+            // 处理商品价格和库存，使用选中规格的价格和库存
             if (specWeight) {
-              // 检查多个可能存储重量信息的字段
-              const fieldsToCheck = [
-                item.specification,
-                item.grossWeight,
-                item.weightQuantityData,
-                item.spec // 检查spec字段
-              ];
-              
-              let hasMatchingSpec = false;
-              for (const field of fieldsToCheck) {
-                if (!field) continue;
-                
-                if (typeof field === 'string') {
-                  // 处理字符串格式的规格数据
-                  console.log('检查字符串规格:', field, '是否包含', specWeight);
-                  // 处理逗号分隔的规格字符串
-                  const specs = field.split(/[,，、]/).map(s => s.trim());
-                  if (specs.some(spec => spec.includes(specWeight))) {
-                    hasMatchingSpec = true;
-                    break;
+              if (item.weightQuantityData && Array.isArray(item.weightQuantityData)) {
+                // 尝试从weightQuantityData中找到对应规格的价格和库存
+                const matchingSpec = item.weightQuantityData.find(spec => {
+                  if (spec.weightSpec) {
+                    return spec.weightSpec.trim() === specWeight;
                   }
-                } else if (Array.isArray(field)) {
-                  // 处理数组格式的规格数据
-                  console.log('检查数组规格:', field);
-                  if (field.some(spec => {
-                    if (typeof spec === 'string') {
-                      console.log('检查数组元素(字符串):', spec, '是否包含', specWeight);
-                      return spec.includes(specWeight);
-                    } else if (typeof spec === 'object') {
-                      // 检查对象格式的规格数据
-                      const specStr = spec.weightSpec || spec.display || spec.spec || '';
-                      console.log('检查数组元素(对象):', specStr, '是否包含', specWeight);
-                      return specStr.includes(specWeight);
-                    }
-                    return false;
-                  })) {
-                    hasMatchingSpec = true;
-                    break;
+                  return false;
+                });
+                if (matchingSpec) {
+                  // 确保价格是一个单一的值，而不是多个价格的组合
+                  if (matchingSpec.price) {
+                    item.price = matchingSpec.price;
                   }
-                } else if (typeof field === 'object') {
-                  // 处理对象格式的规格数据
-                  console.log('检查对象规格:', field);
-                  const specStr = field.weightSpec || field.display || field.spec || '';
-                  console.log('检查对象规格值:', specStr, '是否包含', specWeight);
-                  if (specStr.includes(specWeight)) {
-                    hasMatchingSpec = true;
-                    break;
+                  // 确保库存是对应规格的库存
+                  if (matchingSpec.quantity) {
+                    item.specStock = matchingSpec.quantity;
                   }
                 }
               }
-              
-              // 如果没有找到匹配的规格，尝试进行更宽松的匹配
-              if (!hasMatchingSpec) {
-                console.log('尝试更宽松的匹配...');
-                // 提取规格中的数字部分进行匹配
-                const weightNum = specWeight.replace(/[^0-9-]/g, '');
-                console.log('提取的重量数字:', weightNum);
-                
-                for (const field of fieldsToCheck) {
-                  if (!field) continue;
-                  
-                  if (typeof field === 'string') {
-                    console.log('检查字符串字段:', field, '是否包含', weightNum);
-                    if (field.includes(weightNum)) {
-                      hasMatchingSpec = true;
-                      break;
-                    }
-                  } else if (Array.isArray(field)) {
-                    console.log('检查数组字段:', field);
-                    if (field.some(spec => {
-                      const specStr = typeof spec === 'string' ? spec : (spec.weightSpec || spec.display || spec.spec || '');
-                      console.log('检查数组元素:', specStr, '是否包含', weightNum);
-                      return specStr.includes(weightNum);
-                    })) {
-                      hasMatchingSpec = true;
-                      break;
-                    }
-                  } else if (typeof field === 'object') {
-                    console.log('检查对象字段:', field);
-                    const specStr = field.weightSpec || field.display || field.spec || '';
-                    console.log('检查对象字段值:', specStr, '是否包含', weightNum);
-                    if (specStr.includes(weightNum)) {
-                      hasMatchingSpec = true;
-                      break;
-                    }
-                  }
-                }
+            }
+            
+            // 清理价格字段，确保只显示单一价格
+            if (item.price) {
+              // 如果价格是字符串且包含逗号，只取第一个价格
+              if (typeof item.price === 'string' && item.price.includes(',')) {
+                item.price = item.price.split(',')[0].trim();
               }
-              
-              if (!hasMatchingSpec) {
-                return false;
+              // 如果价格是数组，只取第一个价格
+              if (Array.isArray(item.price)) {
+                item.price = item.price[0];
               }
             }
             
-            return true;
-          });
-          console.log('过滤后的商品数量:', filteredGoods.length);
-          console.log('过滤后的商品:', filteredGoods);
-        }
-        
-        // 处理商品数据
-        const processedGoods = filteredGoods.map(item => {
-          // 首先清理 imageUrls 字段（如果存在）
-          if (item.imageUrls && Array.isArray(item.imageUrls)) {
-            item.imageUrls = item.imageUrls.map(url => {
-              return url.trim().replace(/[`]/g, '');
-            });
+            // 处理规格信息，将多个净重信息分割成数组
+            item.processedSpecs = [];
+            if (item.specification) {
+              item.processedSpecs = processSpecifications(item.specification);
+            } else if (item.weightSpec) {
+              item.processedSpecs = processSpecifications(item.weightSpec);
+            } else if (item.grossWeight) {
+              item.processedSpecs = processSpecifications(item.grossWeight);
+            } else if (selectedSpec) {
+              item.processedSpecs = processSpecifications(selectedSpec);
+            }
             
-            // 使用processMediaUrls函数处理媒体数据
-            item.mediaItems = processMediaUrls(item.imageUrls);
+            // 处理库存显示逻辑
+            // 优先使用对应规格的库存，如果没有则使用默认库存
+            let quantity = item.specStock || item.quantity || item.minOrder || item.stock || item.inventory || item.availableStock || item.totalAvailable;
             
-            // 确保图片优先显示：将图片类型的媒体项移到数组前面
-            if (item.mediaItems && item.mediaItems.length > 1) {
-              const imageItems = item.mediaItems.filter(media => media.type === 'image');
-              const videoItems = item.mediaItems.filter(media => media.type === 'video');
-              item.mediaItems = [...imageItems, ...videoItems];
-            }
-          }
-          
-          // 清理 mediaItems 中的 URL
-          if (item.mediaItems && Array.isArray(item.mediaItems)) {
-            item.mediaItems = item.mediaItems.map(media => {
-              if (media.url) {
-                // 去除 URL 中的反引号和空格
-                media.url = media.url.trim().replace(/[`]/g, '');
-                // 确保媒体类型正确
-                if (!media.type) {
-                  media.type = isVideoUrl(media.url) ? 'video' : 'image';
-                }
+            // 清理库存字段，确保只显示单一值
+            if (quantity) {
+              // 如果库存是字符串且包含逗号，只取第一个库存
+              if (typeof quantity === 'string' && quantity.includes(',')) {
+                quantity = quantity.split(',')[0].trim();
               }
-              return media;
-            });
-          }
-          
-          // 处理商品价格和库存，使用选中规格的价格和库存
-          if (specWeight) {
-            if (item.weightQuantityData && Array.isArray(item.weightQuantityData)) {
-              // 尝试从weightQuantityData中找到对应规格的价格和库存
-              const matchingSpec = item.weightQuantityData.find(spec => {
-                if (spec.weightSpec) {
-                  return spec.weightSpec.trim() === specWeight;
-                }
-                return false;
-              });
-              if (matchingSpec) {
-                // 确保价格是一个单一的值，而不是多个价格的组合
-                if (matchingSpec.price) {
-                  item.price = matchingSpec.price;
-                }
-                // 确保库存是对应规格的库存
-                if (matchingSpec.quantity) {
-                  item.specStock = matchingSpec.quantity;
-                }
+              // 如果库存是数组，只取第一个库存
+              if (Array.isArray(quantity)) {
+                quantity = quantity[0];
               }
+              // 转换为数字
+              quantity = Number(quantity);
             }
-          }
-          
-          // 清理价格字段，确保只显示单一价格
-          if (item.price) {
-            // 如果价格是字符串且包含逗号，只取第一个价格
-            if (typeof item.price === 'string' && item.price.includes(',')) {
-              item.price = item.price.split(',')[0].trim();
+            
+            const totalStock = quantity;
+            
+            let displayStock;
+            if (totalStock >= 10000) {
+              // 库存>=10000时显示"库存充足"
+              displayStock = '充足';
+            } else if (totalStock === 0) {
+              // 库存=0时显示"暂无"
+              displayStock = '暂无';
+            } else {
+              // 其他情况显示具体数字
+              displayStock = totalStock;
             }
-            // 如果价格是数组，只取第一个价格
-            if (Array.isArray(item.price)) {
-              item.price = item.price[0];
+            
+            // 更新商品的库存显示
+            item.totalStock = displayStock;
+            item.originalTotalStock = totalStock;
+            
+            // 添加当前对比的规格信息
+            if (specWeight) {
+              item.currentSpec = specWeight;
             }
-          }
-          
-          // 处理规格信息，将多个净重信息分割成数组
-          item.processedSpecs = [];
-          if (item.specification) {
-            item.processedSpecs = processSpecifications(item.specification);
-          } else if (item.weightSpec) {
-            item.processedSpecs = processSpecifications(item.weightSpec);
-          } else if (item.grossWeight) {
-            item.processedSpecs = processSpecifications(item.grossWeight);
-          } else if (selectedSpec) {
-            item.processedSpecs = processSpecifications(selectedSpec);
-          }
-          
-          // 处理库存显示逻辑
-          // 优先使用对应规格的库存，如果没有则使用默认库存
-          let quantity = item.specStock || item.quantity || item.minOrder || item.stock || item.inventory || item.availableStock || item.totalAvailable;
-          
-          // 清理库存字段，确保只显示单一值
-          if (quantity) {
-            // 如果库存是字符串且包含逗号，只取第一个库存
-            if (typeof quantity === 'string' && quantity.includes(',')) {
-              quantity = quantity.split(',')[0].trim();
+            
+            // 处理地区信息，只显示省份
+            if (item.region) {
+              // 提取省份信息
+              const provinceRegex = /^([^省]+省|[^自治区]+自治区|[^直辖市]+直辖市|[^特别行政区]+特别行政区)/;
+              const match = item.region.match(provinceRegex);
+              if (match) {
+                item.region = match[1];
+              }
             }
-            // 如果库存是数组，只取第一个库存
-            if (Array.isArray(quantity)) {
-              quantity = quantity[0];
+            
+            // 计算单位价格
+            item.unitPrice = calculateUnitPrice(item.price, item.currentSpec || item.specification || (item.processedSpecs && item.processedSpecs.length > 0 ? item.processedSpecs.join(' | ') : ''));
+            
+            // 计算价格涨幅
+            if (goodsData.price) {
+              // 获取当前商品的价格（使用单位价格如果低于10元）
+              let currentPrice = parseFloat(goodsData.price);
+              if (goodsData.unitPrice) {
+                currentPrice = parseFloat(goodsData.unitPrice);
+              }
+              
+              // 获取对比商品的价格（根据规则使用合适的价格）
+              let itemPrice = parseFloat(item.price);
+              if (currentPrice >= 10 && item.unitPrice) {
+                // 如果当前商品价格高于10元，对比商品使用单位价格
+                itemPrice = parseFloat(item.unitPrice);
+              } else if (currentPrice < 10 && itemPrice < 10) {
+                // 如果两者都低于10元，使用原始价格
+                itemPrice = parseFloat(item.price);
+              } else if (currentPrice < 10 && itemPrice >= 10) {
+                // 如果当前商品低于10元，对比商品高于10元，当前商品使用单位价格
+                currentPrice = parseFloat(goodsData.unitPrice || goodsData.price);
+              }
+              
+              if (!isNaN(currentPrice) && !isNaN(itemPrice)) {
+                const priceDiff = itemPrice - currentPrice;
+                const pricePercent = ((priceDiff / currentPrice) * 100).toFixed(1);
+                item.priceDiff = priceDiff;
+                item.pricePercent = pricePercent;
+              }
             }
-            // 转换为数字
-            quantity = Number(quantity);
-          }
-          
-          const totalStock = quantity;
-          
-          let displayStock;
-          if (totalStock >= 10000) {
-            // 库存>=10000时显示"库存充足"
-            displayStock = '充足';
-          } else if (totalStock === 0) {
-            // 库存=0时显示"暂无"
-            displayStock = '暂无';
-          } else {
-            // 其他情况显示具体数字
-            displayStock = totalStock;
-          }
+            
+            return item;
+          });
           
-          // 更新商品的库存显示
-          item.totalStock = displayStock;
-          item.originalTotalStock = totalStock;
+          // 存储所有符合条件的商品
+          this.setData({
+            allGoods: processedGoods
+          });
           
-          // 添加当前对比的规格信息
-          if (specWeight) {
-            item.currentSpec = specWeight;
-          }
+          // 计算当前页应该显示的商品
+          const { pageSize } = this.data;
+          const startIndex = (page - 1) * pageSize;
+          const endIndex = startIndex + pageSize;
+          const currentPageGoods = processedGoods.slice(startIndex, endIndex);
           
-          // 处理地区信息，只显示省份
-          if (item.region) {
-            // 提取省份信息
-            const provinceRegex = /^([^省]+省|[^自治区]+自治区|[^直辖市]+直辖市|[^特别行政区]+特别行政区)/;
-            const match = item.region.match(provinceRegex);
-            if (match) {
-              item.region = match[1];
-            }
-          }
+          // 检查是否还有更多数据
+          const hasMore = endIndex < processedGoods.length;
           
-          // 计算单位价格
-          item.unitPrice = calculateUnitPrice(item.price, item.currentSpec || item.specification || (item.processedSpecs && item.processedSpecs.length > 0 ? item.processedSpecs.join(' | ') : ''));
+          // 设置商品数据
+          this.setData({
+            goods: currentPageGoods,
+            loading: false,
+            loadingMore: false,
+            currentPage: page,
+            hasMore: hasMore,
+            selectedOption: selectedCategory || '对比价格',
+            showTips: false
+          });
           
-          // 计算价格涨幅
-          if (goodsData.price) {
-            // 获取当前商品的价格（使用单位价格如果低于10元）
-            let currentPrice = parseFloat(goodsData.price);
-            if (goodsData.unitPrice) {
-              currentPrice = parseFloat(goodsData.unitPrice);
-            }
-            
-            // 获取对比商品的价格（根据规则使用合适的价格）
-            let itemPrice = parseFloat(item.price);
-            if (currentPrice >= 10 && item.unitPrice) {
-              // 如果当前商品价格高于10元，对比商品使用单位价格
-              itemPrice = parseFloat(item.unitPrice);
-            } else if (currentPrice < 10 && itemPrice < 10) {
-              // 如果两者都低于10元，使用原始价格
-              itemPrice = parseFloat(item.price);
-            } else if (currentPrice < 10 && itemPrice >= 10) {
-              // 如果当前商品低于10元，对比商品高于10元，当前商品使用单位价格
-              currentPrice = parseFloat(goodsData.unitPrice || goodsData.price);
-            }
-            
-            if (!isNaN(currentPrice) && !isNaN(itemPrice)) {
-              const priceDiff = itemPrice - currentPrice;
-              const pricePercent = ((priceDiff / currentPrice) * 100).toFixed(1);
-              item.priceDiff = priceDiff;
-              item.pricePercent = pricePercent;
-            }
-          }
+          console.log('对比价格数据加载完成:', currentPageGoods);
           
-          return item;
-        });
-        
-        // 合并商品数据
-        const newGoods = page === 1 ? processedGoods : [...this.data.goods, ...processedGoods];
-        
-        // 检查是否还有更多数据
-        const hasMore = res && res.products && res.products.length >= 20;
-        
-        // 设置商品数据
-        this.setData({
-          goods: newGoods,
-          loading: false,
-          loadingMore: false,
-          currentPage: page,
-          hasMore: hasMore,
-          selectedOption: selectedCategory || '对比价格',
-          showTips: false
-        });
-        
-        console.log('对比价格数据加载完成:', newGoods);
-        
-        // 如果符合条件的数据少于5条，自动加载更多数据
-        if (newGoods.length < 5 && hasMore) {
-          console.log('符合条件的数据少于5条，自动加载更多数据');
-          this.loadGoodsData(page + 1, selectedCategory, specWeight, goodsData);
-        } else if (page === 1) {
           // 显示提示信息
           wx.showToast({
-            title: `找到${newGoods.length}个符合条件的商品`,
+            title: `找到${processedGoods.length}个符合条件的商品`,
             icon: 'success',
             duration: 2000
           });
-        }
-      })
-      .catch(err => {
-        console.error('获取商品列表失败:', err);
-        this.setData({
-          loading: false,
-          loadingMore: false
-        });
-        wx.showToast({
-          title: '获取商品失败，请稍后重试',
-          icon: 'none'
+        })
+        .catch(err => {
+          console.error('获取商品列表失败:', err);
+          this.setData({
+            loading: false,
+            loadingMore: false
+          });
+          wx.showToast({
+            title: '获取商品失败，请稍后重试',
+            icon: 'none'
+          });
         });
+    } else {
+      // 如果不是第一页，从allGoods中获取数据
+      const { allGoods, pageSize } = this.data;
+      const startIndex = (page - 1) * pageSize;
+      const endIndex = startIndex + pageSize;
+      const currentPageGoods = allGoods.slice(startIndex, endIndex);
+      
+      // 检查是否还有更多数据
+      const hasMore = endIndex < allGoods.length;
+      
+      // 合并商品数据
+      const newGoods = [...this.data.goods, ...currentPageGoods];
+      
+      // 设置商品数据
+      this.setData({
+        goods: newGoods,
+        loading: false,
+        loadingMore: false,
+        currentPage: page,
+        hasMore: hasMore
       });
+      
+      console.log('加载更多数据完成:', currentPageGoods);
+    }
   },
   
   // 加载更多数据
diff --git a/pages/goods-detail/goods-detail.js b/pages/goods-detail/goods-detail.js
index fa5f9b2..f731524 100644
--- a/pages/goods-detail/goods-detail.js
+++ b/pages/goods-detail/goods-detail.js
@@ -3861,41 +3861,100 @@ Page({
         // 只有一个规格，直接跳转
         const selectedSpec = currentSpecifications[0];
         
-        // 构建要传递的数据
-        const goodsData = {
-          id: currentGoods.id || currentGoods.productId,
-          name: currentGoods.name || '',
-          price: currentGoods.price || '',
-          imageUrls: currentGoods.imageUrls || [],
-          region: currentGoods.region || '',
-          weightQuantityData: currentGoods.weightQuantityData || [],
-          category: selectedCategory,
-          yolk: currentGoods.yolk || '',
-          sourceType: currentGoods.sourceType || '',
-          supplyStatus: currentGoods.supplyStatus || '',
-          mediaItems: currentGoods.mediaItems || [],
-          frequency: currentGoods.frequency || 0,
-          status: currentGoods.status || 'published',
-          totalStock: currentGoods.totalStock || '充足',
-          selectedSpec: selectedSpec
-        };
+        // 显示加载提示
+        wx.showLoading({
+          title: '正在获取对比数据...',
+          mask: true
+        });
         
-        console.log('准备跳转到对比价格页面，传递的数据:', goodsData);
+        // 提取规格信息用于查询
+        const specification = selectedSpec.weightSpec || selectedSpec.display || '';
+        console.log('准备通过规格查询商品，规格:', specification);
         
-        // 跳转到对比价格页面
-        wx.navigateTo({
-          url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
-          success: function () {
-            console.log('成功跳转到对比价格页面');
-          },
-          fail: function (error) {
-            console.error('跳转到对比价格页面失败:', error);
-            wx.showToast({
-              title: '跳转失败，请稍后重试',
-              icon: 'none'
+        // 调用API获取相同规格的商品数据
+        API.getProductsBySpecification(specification)
+          .then(comparisonProducts => {
+            wx.hideLoading();
+            console.log('获取到的对比商品数据:', comparisonProducts);
+            
+            // 构建要传递的数据
+            const goodsData = {
+              id: currentGoods.id || currentGoods.productId,
+              name: currentGoods.name || '',
+              price: currentGoods.price || '',
+              imageUrls: currentGoods.imageUrls || [],
+              region: currentGoods.region || '',
+              weightQuantityData: currentGoods.weightQuantityData || [],
+              category: selectedCategory,
+              yolk: currentGoods.yolk || '',
+              sourceType: currentGoods.sourceType || '',
+              supplyStatus: currentGoods.supplyStatus || '',
+              mediaItems: currentGoods.mediaItems || [],
+              frequency: currentGoods.frequency || 0,
+              status: currentGoods.status || 'published',
+              totalStock: currentGoods.totalStock || '充足',
+              selectedSpec: selectedSpec,
+              comparisonProducts: comparisonProducts // 添加对比商品数据
+            };
+            
+            console.log('准备跳转到对比价格页面，传递的数据:', goodsData);
+            
+            // 跳转到对比价格页面
+            wx.navigateTo({
+              url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
+              success: function () {
+                console.log('成功跳转到对比价格页面');
+              },
+              fail: function (error) {
+                console.error('跳转到对比价格页面失败:', error);
+                wx.showToast({
+                  title: '跳转失败，请稍后重试',
+                  icon: 'none'
+                });
+              }
             });
-          }
-        });
+          })
+          .catch(error => {
+            wx.hideLoading();
+            console.error('获取对比商品数据失败:', error);
+            
+            // 即使获取对比数据失败，也继续跳转到对比价格页面
+            const goodsData = {
+              id: currentGoods.id || currentGoods.productId,
+              name: currentGoods.name || '',
+              price: currentGoods.price || '',
+              imageUrls: currentGoods.imageUrls || [],
+              region: currentGoods.region || '',
+              weightQuantityData: currentGoods.weightQuantityData || [],
+              category: selectedCategory,
+              yolk: currentGoods.yolk || '',
+              sourceType: currentGoods.sourceType || '',
+              supplyStatus: currentGoods.supplyStatus || '',
+              mediaItems: currentGoods.mediaItems || [],
+              frequency: currentGoods.frequency || 0,
+              status: currentGoods.status || 'published',
+              totalStock: currentGoods.totalStock || '充足',
+              selectedSpec: selectedSpec,
+              comparisonProducts: [] // 空数组，表示获取失败
+            };
+            
+            console.log('获取对比数据失败，准备跳转到对比价格页面，传递的数据:', goodsData);
+            
+            // 跳转到对比价格页面
+            wx.navigateTo({
+              url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
+              success: function () {
+                console.log('成功跳转到对比价格页面');
+              },
+              fail: function (error) {
+                console.error('跳转到对比价格页面失败:', error);
+                wx.showToast({
+                  title: '跳转失败，请稍后重试',
+                  icon: 'none'
+                });
+              }
+            });
+          });
       } else if (currentSpecifications.length > 1) {
         // 存在多个规格，弹出弹窗让用户选择
         this.setData({
@@ -3924,7 +3983,8 @@ Page({
           frequency: currentGoods.frequency || 0,
           status: currentGoods.status || 'published',
           totalStock: currentGoods.totalStock || '充足',
-          selectedSpec: null
+          selectedSpec: null,
+          comparisonProducts: [] // 空数组，因为没有规格
         };
         
         console.log('准备跳转到对比价格页面，传递的数据:', goodsData);
@@ -4000,56 +4060,130 @@ Page({
     const selectedCategory = this.data.selectedCategory || currentGoods.category || '全部';
     const selectedSpec = this.data.selectedSpec;
     
-    // 显示提示信息
-    wx.showToast({
-      title: `已选择${selectedCategory} ${selectedSpec.display}`,
-      icon: 'info',
-      duration: 1500,
-      success: () => {
-        setTimeout(() => {
-          // 关闭弹窗
-          this.setData({
-            showCompareModal: false
-          });
-          
-          // 构建要传递的数据
-          const goodsData = {
-            id: currentGoods.id || currentGoods.productId,
-            name: currentGoods.name || '',
-            price: currentGoods.price || '',
-            imageUrls: currentGoods.imageUrls || [],
-            region: currentGoods.region || '',
-            weightQuantityData: currentGoods.weightQuantityData || [],
-            category: selectedCategory,
-            yolk: currentGoods.yolk || '',
-            sourceType: currentGoods.sourceType || '',
-            supplyStatus: currentGoods.supplyStatus || '',
-            mediaItems: currentGoods.mediaItems || [],
-            frequency: currentGoods.frequency || 0,
-            status: currentGoods.status || 'published',
-            totalStock: currentGoods.totalStock || '充足',
-            selectedSpec: selectedSpec
-          };
-          
-          console.log('准备跳转到对比价格页面，传递的数据:', goodsData);
-          
-          // 跳转到对比价格页面
-          wx.navigateTo({
-            url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
-            success: function () {
-              console.log('成功跳转到对比价格页面');
-            },
-            fail: function (error) {
-              console.error('跳转到对比价格页面失败:', error);
-              wx.showToast({
-                title: '跳转失败，请稍后重试',
-                icon: 'none'
-              });
-            }
-          });
-        }, 1500);
-      }
+    // 显示加载提示
+    wx.showLoading({
+      title: '正在获取对比数据...',
+      mask: true
     });
+    
+    // 提取规格信息用于查询
+    const specification = selectedSpec.weightSpec || selectedSpec.display || '';
+    console.log('准备通过规格查询商品，规格:', specification);
+    
+    // 调用API获取相同规格的商品数据
+    API.getProductsBySpecification(specification)
+      .then(comparisonProducts => {
+        wx.hideLoading();
+        console.log('获取到的对比商品数据:', comparisonProducts);
+        
+        // 显示提示信息
+        wx.showToast({
+          title: `已选择${selectedCategory} ${selectedSpec.display}`,
+          icon: 'info',
+          duration: 1500,
+          success: () => {
+            setTimeout(() => {
+              // 关闭弹窗
+              this.setData({
+                showCompareModal: false
+              });
+              
+              // 构建要传递的数据
+              const goodsData = {
+                id: currentGoods.id || currentGoods.productId,
+                name: currentGoods.name || '',
+                price: currentGoods.price || '',
+                imageUrls: currentGoods.imageUrls || [],
+                region: currentGoods.region || '',
+                weightQuantityData: currentGoods.weightQuantityData || [],
+                category: selectedCategory,
+                yolk: currentGoods.yolk || '',
+                sourceType: currentGoods.sourceType || '',
+                supplyStatus: currentGoods.supplyStatus || '',
+                mediaItems: currentGoods.mediaItems || [],
+                frequency: currentGoods.frequency || 0,
+                status: currentGoods.status || 'published',
+                totalStock: currentGoods.totalStock || '充足',
+                selectedSpec: selectedSpec,
+                comparisonProducts: comparisonProducts // 添加对比商品数据
+              };
+              
+              console.log('准备跳转到对比价格页面，传递的数据:', goodsData);
+              
+              // 跳转到对比价格页面
+              wx.navigateTo({
+                url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
+                success: function () {
+                  console.log('成功跳转到对比价格页面');
+                },
+                fail: function (error) {
+                  console.error('跳转到对比价格页面失败:', error);
+                  wx.showToast({
+                    title: '跳转失败，请稍后重试',
+                    icon: 'none'
+                  });
+                }
+              });
+            }, 1500);
+          }
+        });
+      })
+      .catch(error => {
+        wx.hideLoading();
+        console.error('获取对比商品数据失败:', error);
+        
+        // 即使获取对比数据失败，也继续跳转到对比价格页面
+        wx.showToast({
+          title: `已选择${selectedCategory} ${selectedSpec.display}`,
+          icon: 'info',
+          duration: 1500,
+          success: () => {
+            setTimeout(() => {
+              // 关闭弹窗
+              this.setData({
+                showCompareModal: false
+              });
+              
+              // 构建要传递的数据
+              const goodsData = {
+                id: currentGoods.id || currentGoods.productId,
+                name: currentGoods.name || '',
+                price: currentGoods.price || '',
+                imageUrls: currentGoods.imageUrls || [],
+                region: currentGoods.region || '',
+                weightQuantityData: currentGoods.weightQuantityData || [],
+                category: selectedCategory,
+                yolk: currentGoods.yolk || '',
+                sourceType: currentGoods.sourceType || '',
+                supplyStatus: currentGoods.supplyStatus || '',
+                mediaItems: currentGoods.mediaItems || [],
+                frequency: currentGoods.frequency || 0,
+                status: currentGoods.status || 'published',
+                totalStock: currentGoods.totalStock || '充足',
+                selectedSpec: selectedSpec,
+                comparisonProducts: [] // 空数组，表示获取失败
+              };
+              
+              console.log('获取对比数据失败，准备跳转到对比价格页面，传递的数据:', goodsData);
+              
+              // 跳转到对比价格页面
+              wx.navigateTo({
+                url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
+                success: function () {
+                  console.log('成功跳转到对比价格页面');
+                },
+                fail: function (error) {
+                  console.error('跳转到对比价格页面失败:', error);
+                  wx.showToast({
+                    title: '跳转失败，请稍后重试',
+                    icon: 'none'
+                  });
+                }
+              });
+            }, 1500);
+          }
+        });
+      });
   },
   
   // 关闭对比价格弹窗
diff --git a/utils/api.js b/utils/api.js
index e2754d7..2fddf4b 100644
--- a/utils/api.js
+++ b/utils/api.js
@@ -5056,5 +5056,119 @@ module.exports = {
           reject(error);
         });
     });
+  },
+
+  // 通过规格查找不同规格的数据
+  getProductsBySpecification: function (specification) {
+    console.log('API.getProductsBySpecification - specification:', specification);
+    return new Promise((resolve, reject) => {
+      // 使用getProducts接口获取所有商品，然后在客户端过滤
+      this.getProducts(1, 100, 'all', '').then(res => {
+        console.log('获取商品列表成功:', res);
+        if (res && res.products) {
+          // 过滤出具有相同规格的商品
+          const filteredProducts = res.products.filter(item => {
+            // 检查多个可能存储重量信息的字段
+            const fieldsToCheck = [
+              item.specification,
+              item.grossWeight,
+              item.weightQuantityData,
+              item.spec // 检查spec字段
+            ];
+            
+            let hasMatchingSpec = false;
+            for (const field of fieldsToCheck) {
+              if (!field) continue;
+              
+              if (typeof field === 'string') {
+                // 处理字符串格式的规格数据
+                console.log('检查字符串规格:', field, '是否包含', specification);
+                // 处理逗号分隔的规格字符串
+                const specs = field.split(/[,，、]/).map(s => s.trim());
+                if (specs.some(spec => spec.includes(specification))) {
+                  hasMatchingSpec = true;
+                  break;
+                }
+              } else if (Array.isArray(field)) {
+                // 处理数组格式的规格数据
+                console.log('检查数组规格:', field);
+                if (field.some(spec => {
+                  if (typeof spec === 'string') {
+                    console.log('检查数组元素(字符串):', spec, '是否包含', specification);
+                    return spec.includes(specification);
+                  } else if (typeof spec === 'object') {
+                    // 检查对象格式的规格数据
+                    const specStr = spec.weightSpec || spec.display || spec.spec || '';
+                    console.log('检查数组元素(对象):', specStr, '是否包含', specification);
+                    return specStr.includes(specification);
+                  }
+                  return false;
+                })) {
+                  hasMatchingSpec = true;
+                  break;
+                }
+              } else if (typeof field === 'object') {
+                // 处理对象格式的规格数据
+                console.log('检查对象规格:', field);
+                const specStr = field.weightSpec || field.display || field.spec || '';
+                console.log('检查对象规格值:', specStr, '是否包含', specification);
+                if (specStr.includes(specification)) {
+                  hasMatchingSpec = true;
+                  break;
+                }
+              }
+            }
+            
+            // 如果没有找到匹配的规格，尝试进行更宽松的匹配
+            if (!hasMatchingSpec) {
+              console.log('尝试更宽松的匹配...');
+              // 提取规格中的数字部分进行匹配
+              const weightNum = specification.replace(/[^0-9-]/g, '');
+              console.log('提取的重量数字:', weightNum);
+              
+              for (const field of fieldsToCheck) {
+                if (!field) continue;
+                
+                if (typeof field === 'string') {
+                  console.log('检查字符串字段:', field, '是否包含', weightNum);
+                  if (field.includes(weightNum)) {
+                    hasMatchingSpec = true;
+                    break;
+                  }
+                } else if (Array.isArray(field)) {
+                  console.log('检查数组字段:', field);
+                  if (field.some(spec => {
+                    const specStr = typeof spec === 'string' ? spec : (spec.weightSpec || spec.display || spec.spec || '');
+                    console.log('检查数组元素:', specStr, '是否包含', weightNum);
+                    return specStr.includes(weightNum);
+                  })) {
+                    hasMatchingSpec = true;
+                    break;
+                  }
+                } else if (typeof field === 'object') {
+                  console.log('检查对象字段:', field);
+                  const specStr = field.weightSpec || field.display || field.spec || '';
+                  console.log('检查对象字段值:', specStr, '是否包含', weightNum);
+                  if (specStr.includes(weightNum)) {
+                    hasMatchingSpec = true;
+                    break;
+                  }
+                }
+              }
+            }
+            
+            return hasMatchingSpec;
+          });
+          console.log('过滤后的商品数量:', filteredProducts.length);
+          console.log('过滤后的商品:', filteredProducts);
+          resolve(filteredProducts);
+        } else {
+          reject(new Error('通过规格查找商品失败'));
+        }
+      }).catch(error => {
+        console.error('通过规格查找商品失败:', error);
+        reject(new Error('通过规格查找商品失败，请稍后重试'));
+      });
+    });
   }
 };
\ No newline at end of file