🎯 比比网商品详情页前端性能优化实战

背景：比比网作为建材B2B平台，商品详情页承载了规格参数、技术图纸、认证证书、供应商信息、价格阶梯、库存分布、物流时效、客户案例等多个复杂模块。页面特点是信息维度多、技术性强、决策链长、比价需求强、采购量大、定制化需求多。核心挑战：如何在保证建材产品专业信息完整性的同时，实现快速加载、直观比价、高效决策，满足工程采购的严苛需求？

一、性能瓶颈分析

1. 建材B2B平台特殊性

2. 性能基线（典型商品详情页）

首次内容绘制（FCP）: 3.8s
最大内容绘制（LCP）: 7.2s（商品主图+价格）
参数表格加载完成: 4.5s
价格计算响应: 1.2s
移动端交互响应: 280ms
3D模型加载时间: 12.3s

二、分层优化实战

✅ 第一阶段：商品参数的"智能折叠与搜索"

💥 痛点：建材参数多达50-100项，用户通常只关注其中10-20个关键参数

<!-- 智能参数展示 -->
<div class="product-params">
  <!-- 关键参数概览 -->
  <div class="key-params-summary">
    <h3>核心参数</h3>
    <div class="key-params-grid">
      <div class="param-card important">
        <span class="param-label">材质</span>
        <span class="param-value">Q235B碳钢</span>
      </div>
      <div class="param-card important">
        <span class="param-label">规格</span>
        <span class="param-value">1000 * 2000mm</span>
      </div>
      <div class="param-card">
        <span class="param-label">厚度</span>
        <span class="param-value">2.5mm</span>
      </div>
      <!-- 更多关键参数 -->
    </div>
  </div>
  
  <!-- 智能参数导航 -->
  <div class="params-navigation">
    <div class="nav-search">
      <input type="text" 
             id="param-search" 
             placeholder="搜索参数..."
             oninput="searchParams(this.value)">
      <div class="search-suggestions"></div>
    </div>
    <div class="nav-tags">
      <span class="nav-tag active" data-category="all">全部</span>
      <span class="nav-tag" data-category="physical">物理性能</span>
      <span class="nav-tag" data-category="chemical">化学性能</span>
      <span class="nav-tag" data-category="construction">施工参数</span>
    </div>
  </div>
  
  <!-- 智能折叠参数表 -->
  <div class="params-table-container">
    <div class="params-table" id="params-table">
      <!-- 动态加载 -->
    </div>
    <div class="params-expand" onclick="toggleAllParams()">
      <span>展开全部参数（共86项）</span>
      <i class="expand-icon">▼</i>
    </div>
  </div>
</div>

// 智能参数展示系统
class SmartParamsManager {
  constructor(paramsData) {
    this.allParams = paramsData;
    this.userPreference = this.loadUserPreference();
    this.searchIndex = this.buildSearchIndex(paramsData);
    this.visibleParams = this.getInitialVisibleParams();
    
    this.init();
  }
  
  // 构建搜索索引
  buildSearchIndex(params) {
    const index = {
      byName: new Map(),      // 参数名索引
      byValue: new Map(),     // 参数值索引
      byCategory: new Map(),  // 分类索引
      byImportance: new Map() // 重要性索引
    };
    
    params.forEach((param, idx) => {
      // 参数名索引
      this.addToIndex(index.byName, param.name, idx);
      this.addToIndex(index.byName, param.enName, idx);
      
      // 参数值索引
      if (param.value) {
        this.addToIndex(index.byValue, param.value.toString(), idx);
      }
      
      // 分类索引
      if (param.category) {
        param.category.split(',').forEach(cat => {
          cat = cat.trim();
          if (!index.byCategory.has(cat)) {
            index.byCategory.set(cat, new Set());
          }
          index.byCategory.get(cat).add(idx);
        });
      }
      
      // 重要性索引
      if (param.importance) {
        if (!index.byImportance.has(param.importance)) {
          index.byImportance.set(param.importance, new Set());
        }
        index.byImportance.get(param.importance).add(idx);
      }
    });
    
    return index;
  }
  
  addToIndex(map, text, id) {
    if (!text) return;
    
    // 中文分词
    const chineseWords = this.chineseSegment(text);
    chineseWords.forEach(word => {
      if (!map.has(word)) {
        map.set(word, new Set());
      }
      map.get(word).add(id);
    });
    
    // 拼音索引
    const pinyin = this.convertToPinyin(text);
    if (pinyin) {
      if (!map.has(pinyin)) {
        map.set(pinyin, new Set());
      }
      map.get(pinyin).add(id);
    }
  }
  
  // 智能搜索
  searchParams(keyword) {
    if (!keyword.trim()) {
      this.renderParams(this.visibleParams);
      return;
    }
    
    const startTime = performance.now();
    const keywords = keyword.toLowerCase().split(/\s+/);
    let resultIds = null;
    
    // 多维度搜索
    keywords.forEach((word, idx) => {
      let wordIds = new Set();
      
      // 在名称索引中搜索
      if (this.searchIndex.byName.has(word)) {
        wordIds = new Set([
          ...wordIds,
          ...this.searchIndex.byName.get(word)
        ]);
      }
      
      // 在值索引中搜索
      if (this.searchIndex.byValue.has(word)) {
        wordIds = new Set([
          ...wordIds,
          ...this.searchIndex.byValue.get(word)
        ]);
      }
      
      if (wordIds.size === 0) {
        // 尝试模糊搜索
        wordIds = this.fuzzySearch(word);
      }
      
      if (idx === 0) {
        resultIds = wordIds;
      } else {
        resultIds = this.intersectSets(resultIds, wordIds);
      }
    });
    
    const results = Array.from(resultIds || [])
      .map(id => this.allParams[id])
      .sort((a, b) => {
        // 按重要性排序
        const importanceOrder = { high: 0, medium: 1, low: 3 };
        return importanceOrder[a.importance] - importanceOrder[b.importance];
      });
    
    this.renderParams(results);
    
    const endTime = performance.now();
    console.log(`搜索耗时: ${(endTime - startTime).toFixed(2)}ms`);
  }
  
  // 模糊搜索
  fuzzySearch(keyword) {
    const results = new Set();
    
    // 前缀匹配
    for (const [word, ids] of this.searchIndex.byName) {
      if (word.startsWith(keyword)) {
        ids.forEach(id => results.add(id));
      }
    }
    
    // 相似度匹配
    for (const [word, ids] of this.searchIndex.byName) {
      if (this.calculateSimilarity(word, keyword) > 0.7) {
        ids.forEach(id => results.add(id));
      }
    }
    
    return results;
  }
  
  // 个性化推荐参数
  getInitialVisibleParams() {
    const params = [...this.allParams];
    
    // 1. 用户偏好参数
    const preferenceParams = this.getUserPreferenceParams();
    
    // 2. 重要性高的参数
    const importantParams = params.filter(p => p.importance === 'high');
    
    // 3. 常用搜索参数
    const popularParams = this.getPopularParams();
    
    // 合并并去重
    const visibleSet = new Set([
      ...preferenceParams,
      ...importantParams,
      ...popularParams
    ].map(p => p.id));
    
    return params.filter(p => visibleSet.has(p.id));
  }
  
  // 智能折叠
  initSmartFold() {
    const params = this.visibleParams;
    const groups = this.groupByCategory(params);
    
    Object.keys(groups).forEach(category => {
      const groupParams = groups[category];
      
      if (groupParams.length <= 3) {
        // 少于3项直接显示
        this.renderGroup(category, groupParams, false);
      } else {
        // 大于3项折叠显示
        this.renderGroup(category, groupParams.slice(0, 3), true);
      }
    });
  }
  
  // 对比参数
  enableComparison(productIds) {
    const comparisonData = productIds.map(id => 
      this.getProductParams(id)
    );
    
    this.renderComparisonTable(comparisonData);
  }
}

✅ 第二阶段：价格与库存的"实时查询与智能推荐"

💥 痛点：建材价格受多重因素影响，库存分布全国，计算复杂

// 智能价格计算器
class SmartPriceCalculator {
  constructor(productId) {
    this.productId = productId;
    this.priceRules = null;
    this.inventory = null;
    this.userLocation = null;
    this.priceCache = new Map();
    
    this.init();
  }
  
  async init() {
    // 并行加载价格规则和库存
    await Promise.all([
      this.loadPriceRules(),
      this.loadInventory(),
      this.getUserLocation()
    ]);
    
    // 预计算常用价格
    this.precalculateCommonPrices();
  }
  
  // 加载价格规则
  async loadPriceRules() {
    const cacheKey = `price_rules_${this.productId}`;
    const cached = this.getCache(cacheKey);
    
    if (cached) {
      this.priceRules = cached;
      return;
    }
    
    const response = await fetch(`/api/products/${this.productId}/prices`);
    const rules = await response.json();
    
    this.priceRules = this.processPriceRules(rules);
    this.setCache(cacheKey, this.priceRules, 5 * 60 * 1000); // 缓存5分钟
  }
  
  processPriceRules(rules) {
    return rules.map(rule => ({
      minQty: rule.minQuantity,
      maxQty: rule.maxQuantity,
      basePrice: rule.price,
      discounts: rule.discounts || [],
      conditions: rule.conditions || [],
      effectiveDate: rule.effectiveDate,
      expirationDate: rule.expirationDate
    })).sort((a, b) => a.minQty - b.minQty);
  }
  
  // 智能计算价格
  calculatePrice(quantity, options = {}) {
    const cacheKey = this.getCacheKey(quantity, options);
    
    if (this.priceCache.has(cacheKey)) {
      return this.priceCache.get(cacheKey);
    }
    
    const startTime = performance.now();
    
    // 1. 找到适用的价格阶梯
    const priceRule = this.findPriceRule(quantity);
    if (!priceRule) {
      throw new Error('未找到适用价格');
    }
    
    // 2. 计算基础价格
    let finalPrice = priceRule.basePrice;
    
    // 3. 应用数量折扣
    if (priceRule.discounts && priceRule.discounts.length > 0) {
      const quantityDiscount = this.calculateQuantityDiscount(quantity, priceRule.discounts);
      finalPrice *= (1 - quantityDiscount);
    }
    
    // 4. 应用用户等级折扣
    if (options.userLevel) {
      const userDiscount = this.getUserDiscount(options.userLevel);
      finalPrice *= (1 - userDiscount);
    }
    
    // 5. 应用地区价格因子
    if (this.userLocation) {
      const regionFactor = this.getRegionPriceFactor(this.userLocation);
      finalPrice *= regionFactor;
    }
    
    // 6. 应用定制化加价
    if (options.customizations && options.customizations.length > 0) {
      const customizationSurcharge = this.calculateCustomizationSurcharge(options.customizations);
      finalPrice += customizationSurcharge;
    }
    
    // 7. 四舍五入
    finalPrice = Math.round(finalPrice * 100) / 100;
    
    const calculation = {
      price: finalPrice,
      breakdown: {
        basePrice: priceRule.basePrice,
        quantityDiscount: this.calculateQuantityDiscount(quantity, priceRule.discounts),
        userDiscount: options.userLevel ? this.getUserDiscount(options.userLevel) : 0,
        regionFactor: this.userLocation ? this.getRegionPriceFactor(this.userLocation) : 1,
        customizationSurcharge: options.customizations ? 
          this.calculateCustomizationSurcharge(options.customizations) : 0
      },
      sourceRule: priceRule
    };
    
    // 缓存结果
    this.priceCache.set(cacheKey, calculation);
    
    const endTime = performance.now();
    console.log(`价格计算耗时: ${(endTime - startTime).toFixed(2)}ms`);
    
    return calculation;
  }
  
  // 实时价格更新
  enableRealTimeUpdates() {
    // WebSocket连接价格更新
    this.priceSocket = new WebSocket(`wss://api.bibi.com/prices/${this.productId}`);
    
    this.priceSocket.onmessage = (event) => {
      const update = JSON.parse(event.data);
      
      switch(update.type) {
        case 'PRICE_UPDATE':
          this.handlePriceUpdate(update.data);
          break;
        case 'INVENTORY_UPDATE':
          this.handleInventoryUpdate(update.data);
          break;
        case 'PROMOTION_UPDATE':
          this.handlePromotionUpdate(update.data);
          break;
      }
    };
    
    // 定期刷新缓存
    setInterval(() => {
      this.refreshPriceCache();
    }, 5 * 60 * 1000); // 5分钟刷新一次
  }
  
  handlePriceUpdate(update) {
    // 更新价格规则
    const ruleIndex = this.priceRules.findIndex(r => r.id === update.ruleId);
    if (ruleIndex !== -1) {
      this.priceRules[ruleIndex] = {
        ...this.priceRules[ruleIndex],
        ...update.changes
      };
      
      // 清理相关缓存
      this.clearAffectedCache(update.ruleId);
      
      // 通知UI更新
      this.notifyPriceChange(update);
    }
  }
  
  // 库存智能推荐
  async getRecommendedInventory(quantity, deliveryAddress) {
    const warehouses = await this.getAvailableWarehouses(deliveryAddress);
    
    // 计算每个仓库的推荐度
    const recommendations = warehouses.map(warehouse => {
      const score = this.calculateWarehouseScore(warehouse, quantity, deliveryAddress);
      return { warehouse, score };
    });
    
    // 按推荐度排序
    recommendations.sort((a, b) => b.score - a.score);
    
    // 智能拆分
    if (quantity > 1000) { // 大单自动拆分
      return this.splitLargeOrder(quantity, recommendations);
    }
    
    return recommendations.slice(0, 3); // 返回前3个推荐
  }
  
  calculateWarehouseScore(warehouse, quantity, address) {
    let score = 100;
    
    // 库存充足度 (40%)
    const inventoryScore = Math.min(warehouse.available / quantity, 1) * 40;
    score = score * 0.6 + inventoryScore;
    
    // 距离分数 (30%)
    const distance = this.calculateDistance(warehouse.location, address);
    const distanceScore = (1 - Math.min(distance / 1000, 1)) * 30; // 1000km以内
    score = score * 0.7 + distanceScore;
    
    // 物流时效分数 (20%)
    const deliveryTime = this.estimateDeliveryTime(warehouse, address);
    const timeScore = (1 - Math.min(deliveryTime / 7, 1)) * 20; // 7天以内
    score = score * 0.8 + timeScore;
    
    // 仓库评分 (10%)
    const warehouseRating = warehouse.rating || 5;
    const ratingScore = (warehouseRating / 5) * 10;
    score = score * 0.9 + ratingScore;
    
    return Math.round(score);
  }
  
  // 价格趋势预测
  predictPriceTrend(quantity, timeframe = '7d') {
    const historicalData = this.getHistoricalPrices(timeframe);
    
    if (historicalData.length < 2) {
      return { trend: 'stable', confidence: 0 };
    }
    
    // 简单线性回归
    const regression = this.calculateLinearRegression(historicalData);
    
    let trend = 'stable';
    if (regression.slope > 0.05) {
      trend = 'up';
    } else if (regression.slope < -0.05) {
      trend = 'down';
    }
    
    return {
      trend: trend,
      confidence: regression.r2,
      predictedPrice: regression.slope * quantity + regression.intercept,
      message: this.getTrendMessage(trend, regression.r2)
    };
  }
}

✅ 第三阶段：3D模型与图纸的"渐进式加载"

💥 痛点：建材产品需要展示3D模型和CAD图纸，文件大，加载慢

<!-- 3D模型查看器 -->
<div class="model-viewer-container">
  <!-- 加载状态 -->
  <div class="model-loading" id="model-loading">
    <div class="loading-progress">
      <div class="progress-bar" id="model-progress"></div>
      <div class="loading-text">正在加载3D模型...</div>
    </div>
    <div class="loading-options">
      <button onclick="loadSimplifiedModel()">加载简化模型</button>
      <button onclick="loadWireframeOnly()">仅加载线框</button>
    </div>
  </div>
  
  <!-- 模型控制 -->
  <div class="model-controls">
    <button onclick="rotateModel('left')">↻</button>
    <button onclick="rotateModel('right')">↺</button>
    <button onclick="zoomModel('in')">+</button>
    <button onclick="zoomModel('out')">-</button>
    <button onclick="resetModel()">↺</button>
    
    <div class="view-options">
      <label><input type="radio" name="view" value="perspective" checked> 透视</label>
      <label><input type="radio" name="view" value="orthographic"> 正交</label>
      <label><input type="radio" name="view" value="wireframe"> 线框</label>
    </div>
  </div>
  
  <!-- 模型容器 -->
  <div class="model-canvas-container">
    <canvas id="model-canvas"></canvas>
    
    <!-- 标记点 -->
    <div class="model-markers">
      <div class="marker" style="top: 30%; left: 40%;" 
           data-part="connector" onclick="highlightPart('connector')">
        <div class="marker-dot"></div>
        <div class="marker-label">连接件</div>
      </div>
    </div>
    
    <!-- 测量工具 -->
    <div class="measure-tool" id="measure-tool">
      <button onclick="startMeasuring()">测量距离</button>
      <button onclick="startAreaMeasure()">测量面积</button>
      <div class="measure-result"></div>
    </div>
  </div>
  
  <!-- 模型信息 -->
  <div class="model-info">
    <div class="info-section">
      <h4>模型信息</h4>
      <div class="info-item">
        <span>多边形数:</span>
        <span id="poly-count">-</span>
      </div>
      <div class="info-item">
        <span>纹理:</span>
        <span id="texture-info">-</span>
      </div>
      <div class="info-item">
        <span>文件大小:</span>
        <span id="model-size">-</span>
      </div>
    </div>
    
    <div class="info-section">
      <h4>查看选项</h4>
      <label>
        <input type="checkbox" id="show-labels" checked> 显示标签
      </label>
      <label>
        <input type="checkbox" id="show-grid" checked> 显示网格
      </label>
      <label>
        <input type="checkbox" id="auto-rotate"> 自动旋转
      </label>
    </div>
  </div>
</div>

// 智能3D模型加载器
class SmartModelLoader {
  constructor(modelUrl, options = {}) {
    this.modelUrl = modelUrl;
    this.options = {
      quality: options.quality || 'auto',
      enableCache: options.enableCache !== false,
      progressive: options.progressive !== false,
      maxSize: options.maxSize || 50 * 1024 * 1024, // 50MB
      ...options
    };
    
    this.renderer = null;
    this.scene = null;
    this.camera = null;
    this.model = null;
    this.loadingManager = null;
    
    this.init();
  }
  
  async init() {
    // 检测设备能力
    this.capabilities = this.detectCapabilities();
    
    // 选择质量级别
    this.selectedQuality = this.selectQualityLevel();
    
    // 初始化Three.js
    await this.initThreeJS();
    
    // 加载模型
    await this.loadModel();
    
    // 性能监控
    this.setupPerformanceMonitor();
  }
  
  detectCapabilities() {
    return {
      isMobile: /iPhone|iPad|iPod|Android/i.test(navigator.userAgent),
      isLowEnd: this.isLowEndDevice(),
      hasGoodGPU: this.hasGoodGPU(),
      networkSpeed: this.estimateNetworkSpeed(),
      memory: performance.memory ? performance.memory.jsHeapSizeLimit : 0
    };
  }
  
  selectQualityLevel() {
    if (this.options.quality !== 'auto') {
      return this.options.quality;
    }
    
    if (this.capabilities.isMobile || this.capabilities.isLowEnd) {
      return 'low';
    } else if (this.capabilities.hasGoodGPU && this.capabilities.networkSpeed > 5) {
      return 'high';
    } else {
      return 'medium';
    }
  }
  
  async initThreeJS() {
    const canvas = document.getElementById('model-canvas');
    
    // 根据设备选择渲染器
    this.renderer = new THREE.WebGLRenderer({
      canvas,
      antialias: this.capabilities.hasGoodGPU,
      alpha: true,
      powerPreference: this.capabilities.hasGoodGPU ? 'high-performance' : 'default'
    });
    
    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
    this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);
    
    // 场景和相机
    this.scene = new THREE.Scene();
    this.camera = new THREE.PerspectiveCamera(
      45,
      canvas.clientWidth / canvas.clientHeight,
      0.1,
      1000
    );
    
    // 灯光
    this.setupLights();
    
    // 控制器
    this.setupControls();
  }
  
  async loadModel() {
    this.showLoading();
    
    const loader = new THREE.GLTFLoader();
    
    // 设置加载管理器
    this.loadingManager = new THREE.LoadingManager();
    
    this.loadingManager.onProgress = (url, loaded, total) => {
      this.updateProgress(loaded / total);
    };
    
    this.loadingManager.onLoad = () => {
      this.hideLoading();
      this.setupModelInteractions();
    };
    
    loader.manager = this.loadingManager;
    
    try {
      // 根据质量选择模型文件
      const modelFile = this.getModelFileByQuality();
      
      // 渐进式加载
      if (this.options.progressive) {
        await this.loadProgressive(modelFile, loader);
      } else {
        await this.loadFullModel(modelFile, loader);
      }
    } catch (error) {
      console.error('模型加载失败:', error);
      this.loadFallbackModel();
    }
  }
  
  // 渐进式加载
  async loadProgressive(modelFile, loader) {
    // 1. 首先加载低模
    const lowPolyModel = await this.loadLowPolyModel();
    this.scene.add(lowPolyModel);
    
    // 2. 后台加载完整模型
    setTimeout(async () => {
      const fullModel = await loader.loadAsync(modelFile);
      this.replaceModel(lowPolyModel, fullModel);
    }, 100);
    
    // 3. 逐步提高质量
    this.progressiveEnhancement();
  }
  
  async loadLowPolyModel() {
    // 创建简化模型
    const geometry = new THREE.BoxGeometry(1, 1, 1);
    const material = new THREE.MeshBasicMaterial({ color: 0xcccccc });
    return new THREE.Mesh(geometry, material);
  }
  
  progressiveEnhancement() {
    const steps = [
      { delay: 1000, action: 'addTextures' },
      { delay: 2000, action: 'increaseResolution' },
      { delay: 3000, action: 'addDetails' },
      { delay: 5000, action: 'addAnimations' }
    ];
    
    steps.forEach(step => {
      setTimeout(() => {
        this[step.action]();
      }, step.delay);
    });
  }
  
  addTextures() {
    if (!this.model) return;
    
    this.model.traverse(child => {
      if (child.isMesh) {
        if (!child.material.map && this.textures[child.name]) {
          const textureLoader = new THREE.TextureLoader();
          textureLoader.load(this.textures[child.name], texture => {
            child.material.map = texture;
            child.material.needsUpdate = true;
          });
        }
      }
    });
  }
  
  // 模型优化
  optimizeModel(gltf) {
    const optimized = gltf.clone();
    
    // 1. 合并网格
    optimized.scene.traverse(child => {
      if (child.isMesh) {
        this.optimizeMesh(child);
      }
    });
    
    // 2. 压缩纹理
    this.compressTextures(optimized);
    
    // 3. 简化几何
    this.simplifyGeometry(optimized);
    
    return optimized;
  }
  
  optimizeMesh(mesh) {
    if (mesh.geometry.index) {
      // 合并重复顶点
      mesh.geometry = THREE.BufferGeometryUtils.mergeVertices(mesh.geometry, 0.001);
    }
    
    // 减少精度
    this.reducePrecision(mesh.geometry.attributes.position, 3);
    this.reducePrecision(mesh.geometry.attributes.normal, 3);
    this.reducePrecision(mesh.geometry.attributes.uv, 2);
  }
  
  reducePrecision(attribute, decimalPlaces) {
    if (!attribute) return;
    
    const array = attribute.array;
    const multiplier = Math.pow(10, decimalPlaces);
    
    for (let i = 0; i < array.length; i++) {
      array[i] = Math.round(array[i] * multiplier) / multiplier;
    }
    
    attribute.needsUpdate = true;
  }
  
  // 离线缓存
  enableOfflineCache() {
    if (!('caches' in window)) return;
    
    const cacheName = '3d-models';
    const modelUrl = this.getModelCacheUrl();
    
    caches.open(cacheName).then(cache => {
      cache.match(modelUrl).then(response => {
        if (response) {
          // 从缓存加载
          this.loadFromCache(response);
        } else {
          // 网络加载并缓存
          this.loadFromNetworkAndCache(cache, modelUrl);
        }
      });
    });
  }
  
  async loadFromCache(response) {
    const blob = await response.blob();
    const url = URL.createObjectURL(blob);
    
    const loader = new THREE.GLTFLoader();
    loader.load(url, gltf => {
      this.model = gltf.scene;
      this.scene.add(this.model);
      URL.revokeObjectURL(url);
    });
  }
}

✅ 第四阶段：供应商信息的"信用体系与智能推荐"

💥 痛点：供应商数量多，资质参差不齐，决策困难

// 供应商智能推荐系统
class SupplierRecommender {
  constructor(productId, userContext) {
    this.productId = productId;
    this.userContext = userContext;
    this.suppliers = [];
    this.userHistory = this.loadUserHistory();
    this.similarUsers = this.findSimilarUsers();
    
    this.init();
  }
  
  async init() {
    // 加载供应商数据
    this.suppliers = await this.loadSuppliers();
    
    // 计算推荐分数
    this.calculateScores();
    
    // 生成推荐列表
    this.generateRecommendations();
  }
  
  // 多维度评分
  calculateScores() {
    this.suppliers.forEach(supplier => {
      // 基础信用分 (40%)
      const creditScore = this.calculateCreditScore(supplier) * 0.4;
      # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
      // 交易历史分 (30%)
      const transactionScore = this.calculateTransactionScore(supplier) * 0.3;
      
      // 匹配度分 (20%)
      const matchScore = this.calculateMatchScore(supplier) * 0.2;
      
      // 实时表现分 (10%)
      const realtimeScore = this.calculateRealtimeScore(supplier) * 0.1;
      
      // 总评分
      supplier.totalScore = creditScore + transactionScore + matchScore + realtimeScore;
      
      // 详细评分
      supplier.scoreBreakdown = {
        creditScore,
        transactionScore,
        matchScore,
        realtimeScore
      };
    });
  }
  
  calculateCreditScore(supplier) {
    let score = 60; // 基础分
    
    // 认证加分
    if (supplier.certifications) {
      const certScores = {
        'ISO9001': 5,
        'ISO14001': 5,
        'CE': 3,
        'UL': 4,
        'CCC': 3
      };
      
      supplier.certifications.forEach(cert => {
        score += certScores[cert] || 1;
      });
    }
    
    // 注册资本
    if (supplier.registeredCapital > 10000000) { // 1000万以上
      score += 10;
    } else if (supplier.registeredCapital > 1000000) { // 100万以上
      score += 5;
    }
    
    // 成立年限
    const years = new Date().getFullYear() - new Date(supplier.establishedDate).getFullYear();
    score += Math.min(years, 20); // 最多加20分
    
    // 处罚扣分
    if (supplier.penalties && supplier.penalties.length > 0) {
      score -= supplier.penalties.length * 5;
    }
    
    return Math.max(0, Math.min(score, 100));
  }
  
  calculateTransactionScore(supplier) {
    if (!supplier.transactionHistory || supplier.transactionHistory.length === 0) {
      return 50; // 无交易记录基础分
    }
    
    const history = supplier.transactionHistory;
    let score = 0;
    
    // 交易数量
    const totalTransactions = history.length;
    score += Math.min(totalTransactions / 10, 20); // 最多20分
    
    // 交易金额
    const totalAmount = history.reduce((sum, t) => sum + t.amount, 0);
    score += Math.min(totalAmount / 1000000, 20); // 每100万加1分，最多20分
    
    // 退货率
    const returnRate = supplier.returnRate || 0;
    if (returnRate < 0.01) { // 1%以下
      score += 20;
    } else if (returnRate < 0.05) { // 5%以下
      score += 10;
    } else {
      score -= (returnRate - 0.05) * 100; // 超过5%的部分扣分
    }
    
    // 投诉率
    const complaintRate = supplier.complaintRate || 0;
    if (complaintRate < 0.01) { // 1%以下
      score += 20;
    } else {
      score -= complaintRate * 50;
    }
    
    // 复购率
    const repurchaseRate = supplier.repurchaseRate || 0;
    score += repurchaseRate * 20; // 每1%加0.2分
    
    return Math.max(0, Math.min(score, 100));
  }
  
  calculateMatchScore(supplier) {
    let score = 0;
    
    // 地理位置匹配
    if (this.userContext.location && supplier.location) {
      const distance = this.calculateDistance(
        this.userContext.location,
        supplier.location
      );
      
      if (distance < 100) { // 100km以内
        score += 30;
      } else if (distance < 500) { // 500km以内
        score += 20;
      } else if (distance < 1000) { // 1000km以内
        score += 10;
      }
    }
    
    // 产品匹配度
    if (supplier.products && this.userContext.productRequirements) {
      const matchRatio = this.calculateProductMatch(
        supplier.products,
        this.userContext.productRequirements
      );
      score += matchRatio * 40;
    }
    
    // 服务匹配度
    if (supplier.services && this.userContext.serviceRequirements) {
      const serviceMatch = this.calculateServiceMatch(
        supplier.services,
        this.userContext.serviceRequirements
      );
      score += serviceMatch * 30;
    }
    
    return Math.max(0, Math.min(score, 100));
  }
  
  calculateRealtimeScore(supplier) {
    let score = 50; // 基础分
    
    // 在线状态
    if (supplier.isOnline) {
      score += 10;
    }
    
    // 响应时间
    const responseTime = supplier.avgResponseTime || 24; // 小时
    if (responseTime < 1) { // 1小时内响应
      score += 20;
    } else if (responseTime < 4) { // 4小时内响应
      score += 10;
    } else if (responseTime > 24) { // 超过24小时
      score -= 10;
    }
    
    // 库存状态
    if (supplier.inventoryStatus === 'in_stock') {
      score += 20;
    } else if (supplier.inventoryStatus === 'low_stock') {
      score += 5;
    } else {
      score -= 10;
    }
    
    return Math.max(0, Math.min(score, 100));
  }
  
  // 生成智能推荐
  generateRecommendations() {
    // 按总分排序
    this.suppliers.sort((a, b) => b.totalScore - a.totalScore);
    
    // 个性化调整
    this.applyPersonalization();
    
    // 风险评估
    this.assessRisks();
    
    // 生成推荐理由
    this.generateRecommendationReasons();
    
    return this.suppliers.slice(0, 10); // 返回前10个
  }
  
  applyPersonalization() {
    this.suppliers.forEach(supplier => {
      // 1. 历史合作加分
      if (this.hasHistoryWithSupplier(supplier.id)) {
        supplier.totalScore += 5;
      }
      
      // 2. 相似用户选择加分
      if (this.similarUsersChooseSupplier(supplier.id)) {
        supplier.totalScore += 3;
      }
      
      // 3. 需求匹配度调整
      if (this.userContext.requirements) {
        const requirementMatch = this.calculateRequirementMatch(
          supplier,
          this.userContext.requirements
        );
        supplier.totalScore *= requirementMatch;
      }
    });
  }
  
  assessRisks() {
    this.suppliers.forEach(supplier => {
      const risks = [];
      
      // 信用风险
      if (supplier.scoreBreakdown.creditScore < 60) {
        risks.push({
          type: 'credit',
          level: 'high',
          message: '信用评分较低，建议谨慎合作'
        });
      }
      
      // 交货风险
      if (supplier.onTimeDeliveryRate < 0.9) {
        risks.push({
          type: 'delivery',
          level: supplier.onTimeDeliveryRate < 0.8 ? 'high' : 'medium',
          message: `准时交货率${(supplier.onTimeDeliveryRate * 100).toFixed(1)}%`
        });
      }
      
      // 质量风险
      if (supplier.defectRate > 0.05) {
        risks.push({
          type: 'quality',
          level: supplier.defectRate > 0.1 ? 'high' : 'medium',
          message: `缺陷率${(supplier.defectRate * 100).toFixed(1)}%`
        });
      }
      
      // 服务风险
      if (supplier.complaintRate > 0.1) {
        risks.push({
          type: 'service',
          level: 'medium',
          message: '投诉率较高'
        });
      }
      
      supplier.risks = risks;
      supplier.riskLevel = this.calculateRiskLevel(risks);
    });
  }
  
  calculateRiskLevel(risks) {
    if (risks.some(r => r.level === 'high')) {
      return 'high';
    } else if (risks.some(r => r.level === 'medium')) {
      return 'medium';
    } else if (risks.length > 0) {
      return 'low';
    } else {
      return 'none';
    }
  }
  
  generateRecommendationReasons() {
    this.suppliers.forEach(supplier => {
      const reasons = [];
      
      if (supplier.scoreBreakdown.creditScore >= 80) {
        reasons.push('信用评级优秀');
      }
      
      if (supplier.scoreBreakdown.transactionScore >= 80) {
        reasons.push('历史交易表现良好');
      }
      
      if (supplier.scoreBreakdown.matchScore >= 80) {
        reasons.push('匹配度高');
      }
      
      if (supplier.scoreBreakdown.realtimeScore >= 80) {
        reasons.push('实时表现优异');
      }
      
      if (supplier.establishedYears >= 10) {
        reasons.push('老牌供应商，经营稳定');
      }
      
      if (supplier.certifications && supplier.certifications.length >= 3) {
        reasons.push('资质认证齐全');
      }
      
      if (supplier.onTimeDeliveryRate >= 0.95) {
        reasons.push('准时交货率高');
      }
      
      supplier.recommendationReasons = reasons.slice(0, 3); // 最多显示3个理由
    });
  }
  
  // 智能排序策略
  getSortStrategies() {
    return {
      score: (a, b) => b.totalScore - a.totalScore,
      price: (a, b) => a.price - b.price,
      delivery: (a, b) => b.onTimeDeliveryRate - a.onTimeDeliveryRate,
      distance: (a, b) => a.distance - b.distance,
      transaction: (a, b) => b.transactionCount - a.transactionCount
    };
  }
  
  sortSuppliers(strategy = 'score', customWeights = null) {
    const strategies = this.getSortStrategies();
    
    if (customWeights) {
      // 加权排序
      this.suppliers.sort((a, b) => {
        let scoreA = 0;
        let scoreB = 0;
        
        Object.keys(customWeights).forEach(key => {
          if (strategies[key]) {
            const sorted = strategies[key](a, b);
            if (sorted > 0) {
              scoreA += customWeights[key];
            } else if (sorted < 0) {
              scoreB += customWeights[key];
            }
          }
        });
        
        return scoreB - scoreA;
      });
    } else {
      // 单一策略排序
      this.suppliers.sort(strategies[strategy] || strategies.score);
    }
    
    return this.suppliers;
  }
}

三、比比网特有优化

1. 价格智能提示

// 价格趋势与智能提示
class PriceIntelligence {
  constructor(productId, marketData) {
    this.productId = productId;
    this.marketData = marketData;
    this.priceHistory = [];
    this.competitorPrices = [];
    
    this.init();
  }
  
  async init() {
    await this.loadPriceHistory();
    await this.loadCompetitorPrices();
    this.setupPriceAlerts();
  }
  
  // 价格趋势分析
  analyzePriceTrend() {
    if (this.priceHistory.length < 2) {
      return null;
    }
    
    const recentPrices = this.priceHistory.slice(-30); // 最近30天
    const analysis = {
      trend: 'stable',
      confidence: 0,
      suggestion: '',
      prediction: null
    };
    
    // 计算移动平均
    const ma7 = this.calculateMovingAverage(recentPrices, 7);
    const ma30 = this.calculateMovingAverage(recentPrices, 30);
    
    // 判断趋势
    if (ma7 > ma30 * 1.05) {
      analysis.trend = 'up';
      analysis.confidence = (ma7 - ma30) / ma30;
    } else if (ma7 < ma30 * 0.95) {
      analysis.trend = 'down';
      analysis.confidence = (ma30 - ma7) / ma30;
    }
    
    // 生成建议
    analysis.suggestion = this.generateSuggestion(analysis.trend, analysis.confidence);
    # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
    // 价格预测
    if (recentPrices.length >= 10) {
      analysis.prediction = this.predictPrice(7); // 预测未来7天
    }
    
    return analysis;
  }
  
  // 价格智能提示
  getPriceAdvice(currentPrice, quantity) {
    const advice = {
      level: 'normal', // normal, good, best, warning
      message: '',
      actions: []
    };
    
    // 1. 与历史价格比较
    const historicalComparison = this.compareWithHistorical(currentPrice);
    if (historicalComparison.level !== 'normal') {
      advice.level = historicalComparison.level;
      advice.message += historicalComparison.message + ' ';
    }
    
    // 2. 与竞争对手比较
    const competitorComparison = this.compareWithCompetitors(currentPrice);
    if (competitorComparison.level !== 'normal') {
      if (competitorComparison.level === 'best') {
        advice.level = 'best';
      } else if (competitorComparison.level === 'warning' && advice.level !== 'best') {
        advice.level = 'warning';
      }
      advice.message += competitorComparison.message + ' ';
    }
    
    // 3. 采购量建议
    const quantityAdvice = this.getQuantityAdvice(quantity, currentPrice);
    if (quantityAdvice) {
      advice.actions.push(quantityAdvice);
    }
    
    // 4. 采购时机建议
    const timingAdvice = this.getTimingAdvice();
    if (timingAdvice) {
      advice.actions.push(timingAdvice);
    }
    
    return advice;
  }
  
  // 智能比价
  smartPriceComparison(price, quantity) {
    const comparisons = this.competitorPrices.map(competitor => {
      const totalPrice = price * quantity;
      const competitorTotal = competitor.price * quantity;
      const difference = totalPrice - competitorTotal;
      const percentage = (difference / competitorTotal) * 100;
      
      return {
        name: competitor.name,
        price: competitor.price,
        total: competitorTotal,
        difference: difference,
        percentage: percentage,
        advantage: competitor.advantages || [],
        disadvantage: competitor.disadvantages || []
      };
    });
    
    // 排序
    comparisons.sort((a, b) => a.total - b.total);
    
    // 计算优势
    comparisons.forEach((comp, index) => {
      comp.rank = index + 1;
      comp.isBest = index === 0;
      comp.valueForMoney = this.calculateValueForMoney(comp);
    });
    
    return comparisons;
  }
}

2. 库存智能调度

// 多仓库库存智能调度
class InventoryScheduler {
  constructor(productId, warehouses) {
    this.productId = productId;
    this.warehouses = warehouses;
    this.orders = [];
    
    this.init();
  }
  
  async init() {
    await this.loadWarehouseData();
    this.setupRealTimeUpdates();
  }
  
  // 智能调度
  scheduleOrder(order) {
    const { quantity, deliveryAddress, deliveryDate } = order;
    # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
    // 1. 查找满足条件的仓库
    const availableWarehouses = this.warehouses.filter(wh => 
      wh.availableStock >= quantity && 
      this.canDeliverOnTime(wh, deliveryAddress, deliveryDate)
    );
    
    if (availableWarehouses.length === 0) {
      // 无单一仓库满足，尝试拆分
      return this.splitOrder(order);
    }
    
    // 2. 计算最优仓库
    const bestWarehouse = this.findBestWarehouse(availableWarehouses, order);
    
    return {
      warehouse: bestWarehouse,
      deliveryPlan: this.createDeliveryPlan(bestWarehouse, order),
      cost: this.calculateTotalCost(bestWarehouse, order)
    };
  }
  
  // 订单拆分
  splitOrder(order) {
    const { quantity, deliveryAddress, deliveryDate } = order;
    const warehouses = [...this.warehouses]
      .filter(wh => wh.availableStock > 0)
      .sort((a, b) => b.availableStock - a.availableStock);
    
    const allocations = [];
    let remaining = quantity;
    
    for (const warehouse of warehouses) {
      if (remaining <= 0) break;
      
      const allocate = Math.min(warehouse.availableStock, remaining);
      if (allocate > 0 && this.canDeliverOnTime(warehouse, deliveryAddress, deliveryDate)) {
        allocations.push({
          warehouse: warehouse,
          quantity: allocate,
          cost: this.calculateCost(warehouse, allocate, deliveryAddress)
        });
        remaining -= allocate;
      }
    }
    
    if (remaining > 0) {
      // 无法完全满足
      return {
        success: false,
        allocated: allocations,
        shortage: remaining,
        suggestion: this.getShortageSuggestion(remaining, deliveryDate)
      };
    }
    
    return {
      success: true,
      allocations: allocations,
      totalCost: allocations.reduce((sum, a) => sum + a.cost, 0),
      deliveryDate: this.calculateDeliveryDate(allocations, deliveryAddress)
    };
  }
  
  // 实时库存更新
  setupRealTimeUpdates() {
    const socket = new WebSocket(`wss://inventory.bibi.com/${this.productId}`);
    
    socket.onmessage = (event) => {
      const update = JSON.parse(event.data);
      this.handleInventoryUpdate(update);
    };
    
    // 定期同步
    setInterval(async () => {
      await this.syncInventory();
    }, 30000); // 30秒同步一次
  }
  
  handleInventoryUpdate(update) {
    const warehouse = this.warehouses.find(w => w.id === update.warehouseId);
    if (warehouse) {
      warehouse.availableStock = update.newStock;
      warehouse.lastUpdated = update.timestamp;
      
      // 更新相关订单
      this.updateAffectedOrders(warehouse);
      
      // 发送通知
      if (update.type === 'stock_low' && update.newStock < update.threshold) {
        this.sendStockAlert(warehouse, update.newStock);
      }
    }
  }
}

四、性能优化结果

五、面试高频追问

Q：建材B2B和消费品电商在性能优化上有何不同？

1. 参数复杂度：建材有大量技术参数，需要智能搜索和折叠

2. 专业图纸：需要处理CAD/3D模型，对WebGL要求高

3. 价格计算复杂：阶梯报价、运费计算、定制化价格

4. 决策链条长：需要供应商信用体系、历史交易数据

5. 采购量大：库存调度、物流计算更复杂

6. 定制化需求：支持产品定制，价格实时计算

Q：如何处理建材参数的智能搜索？

1. 构建多维索引：参数名、值、单位、分类分别建索引

2. 中文分词优化：建材专有名词词典

3. 拼音搜索：支持拼音、首字母搜索

4. 智能推荐：根据用户历史推荐相关参数

5. 搜索缓存：缓存热门搜索

6. 渐进式搜索：边输入边搜索，实时显示结果

Q：3D模型加载如何优化？

1. 分级加载：先加载低模，再加载高模

2. 格式优化：转换压缩格式，如.glb替代.gltf

3. 纹理压缩：使用KTX2、Basis Universal压缩纹理

4. 实例化渲染：重复部件使用实例化渲染

5. 视锥裁剪：只渲染可见部分

6. 离线缓存：缓存已加载的模型

Q：价格实时计算如何实现？

1. 本地计算：价格规则在前端计算，减少请求

2. 预计算：常用价格组合预计算缓存

3. WebSocket：实时价格更新推送

4. 智能缓存：根据数量、地区、用户等级缓存结果

5. 降级方案：网络异常时使用最后有效价格

6. 批量计算：支持批量计算不同数量价格

Q：供应商推荐算法如何设计？

1. 多维度评分：信用、交易、匹配度、实时表现

2. 个性化权重：根据用户偏好调整权重

3. 协同过滤：相似用户的选择影响推荐

4. 风险预警：识别高风险供应商

5. 实时更新：供应商表现实时更新分数

6. A/B测试：不断优化推荐算法

六、总结

比比网性能优化的核心是：用"智能参数搜索"解决"专业复杂度"，用"实时价格计算"解决"决策效率"，用"渐进式3D加载"解决"视觉体验"，用"信用体系推荐"解决"供应商选择"。