📄 《采购与招标商品详情页前端性能优化实战》

背景：政府采购与招标平台的商品详情页实际上是招标公告详情页，包含公告信息、采购需求、资格要求、评分标准、投标文件、澄清公告、开标记录等多个复杂模块。页面特点是信息权威性强、格式标准化、附件多、时间敏感、安全要求高。核心挑战：如何在保证官方文件权威性和完整性的同时，处理大量结构化数据和附件，满足投标人高效获取信息的需求？

一、性能瓶颈分析

1. 采购招标网站的特殊性

2. 性能基线（典型招标公告页）

首次内容绘制（FCP）: 4.2s
最大内容绘制（LCP）: 9.8s（公告标题+关键时间）
附件列表加载完成: 14.3s
资格要求表格渲染: 6.5s
移动端交互响应: 320ms

二、分层优化实战

✅ 第一阶段：招标公告的“智能结构化解析与渲染”

💥 痛点：招标公告文本长（5-10万字），但80%内容用户只关注20%关键信息

<!-- 智能公告结构 -->
<div class="tender-detail">
  <!-- 关键信息速览 -->
  <div class="key-info-summary">
    <div class="info-card">
      <span class="label">项目编号</span>
      <span class="value" id="project-no">ZB2023001</span>
    </div>
    <div class="info-card important">
      <span class="label">投标截止</span>
      <span class="value" id="bid-deadline">2023-12-31 14:00:00</span>
    </div>
    <div class="info-card">
      <span class="label">预算金额</span>
      <span class="value" id="budget">¥5,280,000.00</span>
    </div>
  </div>
  
  <!-- 公告导航 -->
  <nav class="tender-nav">
    <a href="#basic-info" class="nav-item active">基本信息</a>
    <a href="#qualification" class="nav-item">资格要求</a>
    <a href="#technical" class="nav-item">技术需求</a>
    <a href="#commercial" class="nav-item">商务条款</a>
    <a href="#evaluation" class="nav-item">评分标准</a>
    <a href="#attachments" class="nav-item">相关附件</a>
  </nav>
  
  <!-- 结构化内容区域 -->
  <div class="structured-content">
    <!-- 基本信息（默认展开） -->
    <section id="basic-info" class="content-section expanded">
      <h3>基本信息</h3>
      <div class="structured-grid">
        <div class="info-item">
          <span class="label">采购人</span>
          <span class="value">某市政府采购中心</span>
        </div>
        <div class="info-item">
          <span class="label">项目名称</span>
          <span class="value">智慧政务平台建设项目</span>
        </div>
        <!-- 更多结构化信息 -->
      </div>
    </section>
    
    <!-- 资格要求（可折叠） -->
    <section id="qualification" class="content-section collapsible">
      <h3>资格要求 <span class="toggle-icon">▼</span></h3>
      <div class="content-wrapper">
        <!-- 资格要求表格 -->
      </div>
    </section>
  </div>
</div>

// 招标公告智能解析器
class TenderContentParser {
  constructor() {
    this.sections = {
      'basic': '基本信息',
      'qualification': '资格要求',
      'technical': '技术需求',
      'commercial': '商务条款',
      'evaluation': '评分标准',
      'schedule': '时间安排',
      'contact': '联系方式'
    };
  }
  
  // 解析公告内容
  parseContent(fullText) {
    const result = {
      keyInfo: {},
      sections: {},
      attachments: [],
      deadlines: []
    };
    
    // 1. 提取关键信息
    result.keyInfo = this.extractKeyInfo(fullText);
    
    // 2. 按章节分段
    result.sections = this.splitIntoSections(fullText);
    
    // 3. 结构化处理
    Object.keys(result.sections).forEach(section => {
      result.sections[section] = this.structureSection(
        section, 
        result.sections[section]
      );
    });
    
    // 4. 提取时间节点
    result.deadlines = this.extractDeadlines(fullText);
    
    return result;
  }
  
  // 提取关键信息
  extractKeyInfo(text) {
    const patterns = {
      projectNo: /项目编号[：:]\s*([\w\-]+)/,
      projectName: /项目名称[：:]\s*(.+?)(?=\n|$)/,
      budget: /预算[金额]*[：:]\s*([¥$\d,\.]+)/,
      deadline: /投标截止[时间]*[：:]\s*(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/,
      tenderer: /采购人[：:]\s*(.+?)(?=\n|$)/
    };
    
    const keyInfo = {};
    Object.keys(patterns).forEach(key => {
      const match = text.match(patterns[key]);
      if (match) {
        keyInfo[key] = match[1].trim();
      }
    });
    
    return keyInfo;
  }
  
  // 智能分段
  splitIntoSections(text) {
    const sections = {};
    let currentSection = 'basic';
    let buffer = [];
    
    const lines = text.split('\n');
    lines.forEach(line => {
      // 检测章节标题
      const sectionMatch = this.detectSection(line);
      if (sectionMatch) {
        // 保存上一章节
        if (buffer.length > 0) {
          sections[currentSection] = buffer.join('\n');
          buffer = [];
        }
        currentSection = sectionMatch;
      } else {
        buffer.push(line);
      }
    });
    
    // 保存最后一节
    if (buffer.length > 0) {
      sections[currentSection] = buffer.join('\n');
    }
    
    return sections;
  }
  
  detectSection(line) {
    const sectionPatterns = {
      qualification: /资格要求|投标人资格|资格条件/i,
      technical: /技术需求|技术要求|技术参数|技术规格/i,
      commercial: /商务条款|商务要求|付款方式|交货期/i,
      evaluation: /评分标准|评审标准|评标办法/i,
      schedule: /时间安排|项目进度|开标时间/i,
      contact: /联系方式|联系人|联系地址/i
    };
    
    for (const [key, pattern] of Object.entries(sectionPatterns)) {
      if (pattern.test(line)) {
        return key;
      }
    }
    
    return null;
  }
  
  // 结构化处理章节
  structureSection(section, content) {
    switch(section) {
      case 'qualification':
        return this.structureQualification(content);
      case 'technical':
        return this.structureTechnical(content);
      case 'evaluation':
        return this.structureEvaluation(content);
      default:
        return content;
    }
  }
  
  // 结构化资格要求
  structureQualification(content) {
    const qualifications = [];
    const lines = content.split('\n');
    
    lines.forEach(line => {
      if (line.includes('★') || line.includes('※') || line.includes('*')) {
        // 关键要求
        qualifications.push({
          text: line,
          isRequired: true,
          importance: 'high'
        });
      } else if (line.match(/^\d+[\.、]/)) {
        // 编号项
        qualifications.push({
          text: line,
          isRequired: false,
          importance: 'normal'
        });
      }
    });
    
    return qualifications;
  }
}

✅ 第二阶段：招标文件的“批量智能下载与对比”

💥 痛点：一个招标项目包含20+个文件，用户需要逐个下载，无法快速对比

// 招标文件管理器
class TenderFileManager {
  constructor() {
    this.files = [];
    this.selectedFiles = new Set();
    this.comparisons = new Map();
  }
  
  // 初始化文件列表
  async initializeFiles(projectId) {
    const fileList = await this.fetchFileList(projectId);
    
    // 按类型分类
    this.files = this.categorizeFiles(fileList);
    
    // 渲染文件列表
    this.renderFileList();
    
    // 预加载文件元数据
    this.prefetchFileMetadata();
  }
  
  // 文件分类
  categorizeFiles(files) {
    const categories = {
      tender: [],      // 招标文件
      specification: [], // 技术规范
      drawing: [],     // 图纸
      clarification: [], // 澄清文件
      other: []        // 其他
    };
    
    files.forEach(file => {
      const category = this.detectFileCategory(file);
      file.category = category;
      categories[category].push(file);
      
      // 添加预览支持标记
      file.canPreview = this.canPreview(file);
      file.previewUrl = file.canPreview ? this.generatePreviewUrl(file) : null;
    });
    
    return categories;
  }
  
  detectFileCategory(file) {
    const { name, type } = file;
    
    if (name.includes('招标文件') || name.includes('投标邀请')) {
      return 'tender';
    } else if (name.includes('技术规范') || name.includes('规格书')) {
      return 'specification';
    } else if (name.includes('图纸') || name.includes('CAD')) {
      return 'drawing';
    } else if (name.includes('澄清') || name.includes('补遗')) {
      return 'clarification';
    } else {
      return 'other';
    }
  }
  
  // 批量下载
  async downloadSelectedFiles() {
    if (this.selectedFiles.size === 0) {
      this.showToast('请先选择文件');
      return;
    }
    
    if (this.selectedFiles.size === 1) {
      // 单个文件直接下载
      const file = this.getFileById([...this.selectedFiles][0]);
      this.downloadSingleFile(file);
      return;
    }
    
    // 多个文件打包下载
    this.showDownloadProgress(0);
    
    const zip = new JSZip();
    let downloadedCount = 0;
    
    for (const fileId of this.selectedFiles) {
      const file = this.getFileById(fileId);
      
      try {
        const blob = await this.fetchFileBlob(file.url);
        zip.file(file.name, blob);
        
        downloadedCount++;
        this.updateDownloadProgress(
          downloadedCount, 
          this.selectedFiles.size
        );
      } catch (error) {
        console.error(`下载失败: ${file.name}`, error);
      }
    }
    
    // 生成ZIP文件
    const content = await zip.generateAsync({ 
      type: 'blob',
      compression: 'DEFLATE',
      compressionOptions: { level: 6 }
    });
    
    // 下载ZIP
    const url = URL.createObjectURL(content);
    const a = document.createElement('a');
    a.href = url;
    a.download = `招标文件_${new Date().getTime()}.zip`;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    
    URL.revokeObjectURL(url);
    this.hideDownloadProgress();
  }
  
  // 文件对比
  async compareFiles(fileId1, fileId2) {
    const file1 = this.getFileById(fileId1);
    const file2 = this.getFileById(fileId2);
    
    if (!this.canCompare(file1, file2)) {
      this.showToast('不支持对比该类型文件');
      return;
    }
    
    const comparisonId = `${fileId1}_${fileId2}`;
    
    if (this.comparisons.has(comparisonId)) {
      // 使用缓存
      return this.comparisons.get(comparisonId);
    }
    
    this.showComparisonLoading();
    
    try {
      // 提取文本内容
      const [text1, text2] = await Promise.all([
        this.extractFileText(file1),
        this.extractFileText(file2)
      ]);
      
      // 计算差异
      const diff = this.computeTextDiff(text1, text2);
      
      // 生成对比视图
      const comparison = this.generateComparisonView(diff, file1, file2);
      
      // 缓存结果
      this.comparisons.set(comparisonId, comparison);
      
      return comparison;
    } catch (error) {
      console.error('文件对比失败:', error);
      throw error;
    } finally {
      this.hideComparisonLoading();
    }
  }
  
  // 提取文本内容
  async extractFileText(file) {
    if (file.type === 'application/pdf') {
      return await this.extractPDFText(file);
    } else if (file.type.includes('word') || file.type.includes('document')) {
      return await this.extractWordText(file);
    } else {
      throw new Error('不支持的格式');
    }
  }
  
  // 使用diff-match-patch计算差异
  computeTextDiff(text1, text2) {
    const dmp = new diff_match_patch();
    
    // 分段处理，提高性能
    const maxLength = 10000; // 每段最大长度
    const chunks1 = this.splitText(text1, maxLength);
    const chunks2 = this.splitText(text2, maxLength);
    
    const allDiffs = [];
    const maxChunks = Math.max(chunks1.length, chunks2.length);
    
    for (let i = 0; i < maxChunks; i++) {
      const chunk1 = chunks1[i] || '';
      const chunk2 = chunks2[i] || '';
      const diffs = dmp.diff_main(chunk1, chunk2);
      
      // 优化差异结果
      dmp.diff_cleanupSemantic(diffs);
      dmp.diff_cleanupEfficiency(diffs);
      
      allDiffs.push(...diffs);
    }
    
    return allDiffs;
  }
  
  // 生成对比视图
  generateComparisonView(diffs, file1, file2) {
    const container = document.createElement('div');
    container.className = 'comparison-view';
    # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
    const leftPane = document.createElement('div');
    leftPane.className = 'comparison-pane left-pane';
    leftPane.innerHTML = `<h4>${file1.name}</h4>`;
    
    const rightPane = document.createElement('div');
    rightPane.className = 'comparison-pane right-pane';
    rightPane.innerHTML = `<h4>${file2.name}</h4>`;
    
    diffs.forEach(diff => {
      const [type, text] = diff;
      
      if (type === 0) {
        // 相同内容
        const span = document.createElement('span');
        span.className = 'same';
        span.textContent = text;
        
        leftPane.appendChild(span.cloneNode(true));
        rightPane.appendChild(span.cloneNode(true));
      } else if (type === -1) {
        // 只在左边
        const span = document.createElement('span');
        span.className = 'deleted';
        span.textContent = text;
        span.title = '已删除';
        
        leftPane.appendChild(span);
      } else if (type === 1) {
        // 只在右边
        const span = document.createElement('span');
        span.className = 'added';
        span.textContent = text;
        span.title = '新增';
        
        rightPane.appendChild(span);
      }
    });
    
    container.appendChild(leftPane);
    container.appendChild(rightPane);
    
    return container;
  }
}

✅ 第三阶段：评分标准的“交互式计算器”

💥 痛点：投标人需要手动计算得分，容易出错

<!-- 评分计算器 -->
<div class="scoring-calculator">
  <div class="scoring-summary">
    <div class="score-card">
      <div class="score-label">技术得分</div>
      <div class="score-value" id="tech-score">0</div>
      <div class="score-max">满分: 60</div>
    </div>
    <div class="score-card">
      <div class="score-label">商务得分</div>
      <div class="score-value" id="business-score">0</div>
      <div class="score-max">满分: 30</div>
    </div>
    <div class="score-card total">
      <div class="score-label">总分</div>
      <div class="score-value" id="total-score">0</div>
      <div class="score-max">满分: 100</div>
    </div>
  </div>
  
  <!-- 评分细则 -->
  <div class="scoring-details">
    <div class="scoring-section">
      <h4>技术评分 (60分)</h4>
      <div class="scoring-items">
        <div class="scoring-item" data-category="tech" data-max="20">
          <div class="item-header">
            <span class="item-name">技术方案先进性 (20分)</span>
            <span class="item-score">得分: <input type="number" min="0" max="20" value="0" class="score-input"></span>
          </div>
          <div class="item-description">
            评分标准：技术架构先进合理，得15-20分；技术架构较为合理，得10-14分；技术架构基本合理，得5-9分；技术架构不合理，得0-4分。
          </div>
        </div>
        <!-- 更多评分项 -->
      </div>
    </div>
  </div>
  
  <!-- 模拟对比 -->
  <div class="simulation-tools">
    <h4>得分模拟</h4>
    <div class="simulation-controls">
      <button onclick="simulateOptimal()">模拟最优方案</button>
      <button onclick="simulateCompetitor()">模拟竞争对手</button>
      <button onclick="exportScoring()">导出评分表</button>
    </div>
  </div>
</div>

// 智能评分计算器
class ScoringCalculator {
  constructor(scoringRules) {
    this.rules = scoringRules;
    this.scores = {};
    this.competitors = [];
    this.init();
  }
  
  init() {
    // 初始化评分数据
    this.rules.categories.forEach(category => {
      this.scores[category.id] = {
        items: {},
        total: 0,
        max: category.maxScore
      };
      
      category.items.forEach(item => {
        this.scores[category.id].items[item.id] = {
          score: 0,
          max: item.maxScore,
          weight: item.weight || 1
        };
      });
    });
    
    // 绑定事件
    this.bindEvents();
    
    // 加载历史数据
    this.loadHistoricalData();
  }
  
  // 实时计算总分
  calculateTotal() {
    let total = 0;
    
    Object.keys(this.scores).forEach(categoryId => {
      const category = this.scores[categoryId];
      let categoryTotal = 0;
      
      Object.keys(category.items).forEach(itemId => {
        const item = category.items[itemId];
        categoryTotal += item.score * item.weight;
      });
      
      // 确保不超过上限
      category.total = Math.min(categoryTotal, category.max);
      total += category.total;
    });
    
    return total;
  }
  
  // 更新UI
  updateScoreDisplay() {
    const total = this.calculateTotal();
    
    // 更新总分
    document.getElementById('total-score').textContent = total;
    
    // 更新分类分数
    Object.keys(this.scores).forEach(categoryId => {
      const element = document.getElementById(`${categoryId}-score`);
      if (element) {
        element.textContent = this.scores[categoryId].total;
      }
    });
    
    // 更新可视化
    this.updateVisualization();
  }
  
  // 模拟最优方案
  simulateOptimal() {
    Object.keys(this.scores).forEach(categoryId => {
      const category = this.scores[categoryId];
      
      Object.keys(category.items).forEach(itemId => {
        const item = category.items[itemId];
        item.score = item.max; // 设为满分
      });
    });
    
    this.updateAllInputs();
    this.updateScoreDisplay();
  }
  
  // 模拟竞争对手
  simulateCompetitor(competitorId) {
    if (!competitorId && this.competitors.length > 0) {
      // 使用历史竞争对手数据
      const latestCompetitor = this.competitors[this.competitors.length - 1];
      competitorId = latestCompetitor.id;
    }
    
    if (competitorId) {
      this.loadCompetitorScores(competitorId).then(scores => {
        this.applyCompetitorScores(scores);
        this.updateAllInputs();
        this.updateScoreDisplay();
      });
    }
  }
  
  // 得分分析
  analyzeScores() {
    const analysis = {
      strengths: [],
      weaknesses: [],
      suggestions: [],
      benchmarks: []
    };
    
    // 分析优劣势
    Object.keys(this.scores).forEach(categoryId => {
      const category = this.scores[categoryId];
      const percentage = (category.total / category.max) * 100;
      
      if (percentage >= 80) {
        analysis.strengths.push({
          category: categoryId,
          score: category.total,
          max: category.max,
          percentage: percentage
        });
      } else if (percentage <= 50) {
        analysis.weaknesses.push({
          category: categoryId,
          score: category.total,
          max: category.max,
          percentage: percentage
        });
        
        // 提供改进建议
        analysis.suggestions.push(
          this.generateSuggestion(categoryId, percentage)
        );
      }
    });
    
    // 与竞争对手对比
    if (this.competitors.length > 0) {
      const myScore = this.calculateTotal();
      const competitorScores = this.competitors.map(c => c.total);
      
      analysis.benchmarks.push({
        average: this.calculateAverage(competitorScores),
        highest: Math.max(...competitorScores),
        lowest: Math.min(...competitorScores),
        myScore: myScore,
        rank: this.calculateRank(myScore, competitorScores)
      });
    }
    
    return analysis;
  }
  
  // 导出评分表
  exportScoring(format = 'excel') {
    const data = {
      project: this.rules.project,
      timestamp: new Date().toISOString(),
      scores: this.scores,
      total: this.calculateTotal(),
      analysis: this.analyzeScores()
    };
    
    switch(format) {
      case 'excel':
        return this.exportToExcel(data);
      case 'pdf':
        return this.exportToPDF(data);
      case 'json':
        return this.exportToJSON(data);
      default:
        return this.exportToExcel(data);
    }
  }
  
  exportToExcel(data) {
    const wb = XLSX.utils.book_new();
    
    // 评分明细
    const detailRows = [];
    Object.keys(data.scores).forEach(categoryId => {
      const category = data.scores[categoryId];
      
      Object.keys(category.items).forEach(itemId => {
        const item = category.items[itemId];
        detailRows.push([
          categoryId,
          itemId,
          item.score,
          item.max,
          item.weight,
          item.score * item.weight
        ]);
      });
    });
    
    const detailWs = XLSX.utils.aoa_to_sheet([
      ['分类', '评分项', '得分', '满分', '权重', '加权得分'],
      ...detailRows
    ]);
    
    // 汇总
    const summaryRows = [];
    Object.keys(data.scores).forEach(categoryId => {
      const category = data.scores[categoryId];
      summaryRows.push([categoryId, category.total, category.max]);
    });
    summaryRows.push(['总计', data.total, 100]);
    # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
    const summaryWs = XLSX.utils.aoa_to_sheet([
      ['分类', '得分', '满分'],
      ...summaryRows
    ]);
    
    // 分析
    const analysisRows = [];
    data.analysis.strengths.forEach(s => {
      analysisRows.push(['优势', s.category, `${s.percentage}%`]);
    });
    data.analysis.weaknesses.forEach(w => {
      analysisRows.push(['劣势', w.category, `${w.percentage}%`]);
    });
    data.analysis.suggestions.forEach(s => {
      analysisRows.push(['建议', s.category, s.suggestion]);
    });
    
    const analysisWs = XLSX.utils.aoa_to_sheet([
      ['类型', '分类', '内容'],
      ...analysisRows
    ]);
    
    XLSX.utils.book_append_sheet(wb, detailWs, '评分明细');
    XLSX.utils.book_append_sheet(wb, summaryWs, '汇总');
    XLSX.utils.book_append_sheet(wb, analysisWs, '分析');
    
    const wbout = XLSX.write(wb, { bookType: 'xlsx', type: 'binary' });
    const blob = new Blob([s2ab(wbout)], { type: 'application/octet-stream' });
    
    return blob;
  }
}

✅ 第四阶段：投标协同的“实时协作与批注”

💥 痛点：投标团队多人协作，但缺乏协同工具

// 投标协同系统
class TenderCollaboration {
  constructor(projectId) {
    this.projectId = projectId;
    this.socket = null;
    this.users = new Map();
    this.annotations = new Map();
    this.versions = [];
    this.currentUser = this.getCurrentUser();
    
    this.init();
  }
  
  async init() {
    // 连接WebSocket
    await this.connectWebSocket();
    
    // 加载现有批注
    await this.loadAnnotations();
    
    // 加载版本历史
    await this.loadVersions();
    
    // 初始化协同编辑器
    this.initCollaborativeEditor();
  }
  
  // WebSocket连接
  async connectWebSocket() {
    return new Promise((resolve, reject) => {
      this.socket = new WebSocket(
        `wss://api.example.com/tender/${this.projectId}/ws?token=${this.getToken()}`
      );
      
      this.socket.onopen = () => {
        console.log('协同连接已建立');
        this.joinRoom();
        resolve();
      };
      
      this.socket.onmessage = (event) => {
        this.handleMessage(JSON.parse(event.data));
      };
      
      this.socket.onclose = () => {
        console.log('协同连接已关闭');
        setTimeout(() => this.reconnect(), 3000);
      };
      
      this.socket.onerror = (error) => {
        console.error('协同连接错误:', error);
        reject(error);
      };
    });
  }
  
  // 处理消息
  handleMessage(message) {
    switch(message.type) {
      case 'user_joined':
        this.handleUserJoined(message.data);
        break;
      case 'user_left':
        this.handleUserLeft(message.data);
        break;
      case 'annotation_added':
        this.handleAnnotationAdded(message.data);
        break;
      case 'annotation_updated':
        this.handleAnnotationUpdated(message.data);
        break;
      case 'annotation_deleted':
        this.handleAnnotationDeleted(message.data);
        break;
      case 'cursor_move':
        this.handleCursorMove(message.data);
        break;
      case 'selection_change':
        this.handleSelectionChange(message.data);
        break;
      case 'chat_message':
        this.handleChatMessage(message.data);
        break;
    }
  }
  
  // 批注系统
  addAnnotation(annotation) {
    const annotationId = generateId();
    const fullAnnotation = {
      id: annotationId,
      ...annotation,
      createdBy: this.currentUser.id,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
    
    // 本地存储
    this.annotations.set(annotationId, fullAnnotation);
    
    // 广播
    this.socket.send(JSON.stringify({
      type: 'annotation_added',
      data: fullAnnotation
    }));
    
    // 渲染
    this.renderAnnotation(fullAnnotation);
    
    return annotationId;
  }
  
  // 版本控制
  async saveVersion(description) {
    const version = {
      id: generateId(),
      timestamp: new Date().toISOString(),
      description: description,
      createdBy: this.currentUser.id,
      data: this.captureVersionData()
    };
    
    // 保存到服务器
    await fetch(`/api/tender/${this.projectId}/versions`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(version)
    });
    
    // 添加到历史
    this.versions.unshift(version);
    
    // 渲染版本历史
    this.renderVersion(version);
  }
  
  captureVersionData() {
    return {
      annotations: Array.from(this.annotations.values()),
      content: this.getCurrentContent(),
      selections: this.getCurrentSelections(),
      metadata: {
        userCount: this.users.size,
        annotationCount: this.annotations.size,
        lastUpdated: new Date().toISOString()
      }
    };
  }
  
  // 协同聊天
  sendChatMessage(content) {
    const message = {
      id: generateId(),
      content: content,
      sender: this.currentUser,
      timestamp: new Date().toISOString(),
      type: 'chat'
    };
    
    this.socket.send(JSON.stringify({
      type: 'chat_message',
      data: message
    }));
    
    this.renderChatMessage(message, true);
  }
  
  // 实时光标
  updateCursor(position) {
    this.socket.send(JSON.stringify({
      type: 'cursor_move',
      data: {
        userId: this.currentUser.id,
        position: position
      }
    }));
  }
  
  // 离线支持
  enableOfflineMode() {
    // 离线时存储操作
    this.offlineOperations = [];
    
    window.addEventListener('online', () => {
      this.syncOfflineOperations();
    });
    
    // 离线检测
    if (!navigator.onLine) {
      this.showOfflineWarning();
    }
  }
  
  async syncOfflineOperations() {
    if (this.offlineOperations.length === 0) return;
    
    this.showSyncProgress();
    
    for (const operation of this.offlineOperations) {
      try {
        await this.syncOperation(operation);
        this.markOperationSynced(operation.id);
      } catch (error) {
        console.error('同步失败:', error);
        this.queueOperationForRetry(operation);
      }
    }
    
    this.hideSyncProgress();
  }
}

三、采购招标特殊优化

1. 时间敏感信息优化

// 招标时间管理
class TenderTimeManager {
  constructor(deadlines) {
    this.deadlines = deadlines;
    this.timers = new Map();
    this.initTimers();
  }
  
  initTimers() {
    this.deadlines.forEach(deadline => {
      this.createTimer(deadline);
    });
  }
  
  createTimer(deadline) {
    const now = Date.now();
    const targetTime = new Date(deadline.time).getTime();
    const remaining = targetTime - now;
    
    if (remaining <= 0) {
      this.markExpired(deadline);
      return;
    }
    
    // 创建倒计时
    const timer = {
      interval: setInterval(() => {
        this.updateCountdown(deadline.id);
      }, 1000),
      element: this.createCountdownElement(deadline)
    };
    
    this.timers.set(deadline.id, timer);
    
    // 重要时间点提醒
    this.scheduleReminders(deadline);
  }
  
  createCountdownElement(deadline) {
    const element = document.createElement('div');
    element.className = 'countdown-timer';
    element.id = `timer-${deadline.id}`;
    
    const update = () => {
      const remaining = this.calculateRemainingTime(deadline.time);
      element.innerHTML = `
        <div class="deadline-name">${deadline.name}</div>
        <div class="deadline-time">${deadline.time}</div>
        <div class="countdown">${remaining}</div>
        <div class="status ${this.getStatusClass(deadline)}"></div>
      `;
    };
    
    update();
    return element;
  }
  
  calculateRemainingTime(targetTime) {
    const now = new Date();
    const target = new Date(targetTime);
    const diff = target - now;
    
    if (diff <= 0) {
      return '已截止';
    }
    
    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
    const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((diff % (1000 * 60)) / 1000);
    # 封装好API供应商demo url=https://console.open.onebound.cn/console/?i=Lex
    if (days > 0) {
      return `${days}天${hours}小时`;
    } else if (hours > 0) {
      return `${hours}小时${minutes}分钟`;
    } else if (minutes > 0) {
      return `${minutes}分钟${seconds}秒`;
    } else {
      return `${seconds}秒`;
    }
  }
  
  scheduleReminders(deadline) {
    const targetTime = new Date(deadline.time).getTime();
    const now = Date.now();
    const remaining = targetTime - now;
    
    // 提前提醒
    const reminders = [
      24 * 60 * 60 * 1000, // 1天前
      12 * 60 * 60 * 1000, // 12小时前
      2 * 60 * 60 * 1000,  // 2小时前
      30 * 60 * 1000,      // 30分钟前
      5 * 60 * 1000        // 5分钟前
    ];
    
    reminders.forEach(reminderTime => {
      if (remaining > reminderTime) {
        setTimeout(() => {
          this.sendReminder(deadline, reminderTime);
        }, remaining - reminderTime);
      }
    });
  }
  
  sendReminder(deadline, timeBefore) {
    const message = `【提醒】${deadline.name} 将在${this.formatTime(timeBefore)}后截止`;
    
    // 浏览器通知
    if ('Notification' in window && Notification.permission === 'granted') {
      new Notification('招标截止提醒', {
        body: message,
        icon: '/notification-icon.png'
      });
    }
    
    // 页面内提醒
    this.showToast(message, 'warning');
  }
}

2. 合规性验证

// 招标合规性检查
class TenderComplianceChecker {
  constructor(content) {
    this.content = content;
    this.rules = this.loadComplianceRules();
    this.violations = [];
  }
  
  loadComplianceRules() {
    return [
      {
        id: 'rule-1',
        name: '资质要求合规性',
        pattern: /不得以.*不合理.*限制|排斥.*潜在.*投标人/i,
        severity: 'high',
        message: '存在不合理限制或排斥潜在投标人的表述'
      },
      {
        id: 'rule-2',
        name: '评分标准明确性',
        pattern: /评分标准.*不明确|评分.*不具体|主观.*评分/i,
        severity: 'medium',
        message: '评分标准不够明确具体'
      },
      {
        id: 'rule-3',
        name: '时间要求合规性',
        pattern: /投标.*时间.*不足.*20天|招标.*时间.*不足/i,
        severity: 'high',
        message: '投标时间可能不符合法定要求'
      },
      {
        id: 'rule-4',
        name: '技术参数合规性',
        pattern: /指定.*品牌|指定.*制造商|唯一.*性.*要求/i,
        severity: 'high',
        message: '存在指定品牌或制造商等限制性条款'
      }
    ];
  }
  
  checkCompliance() {
    this.violations = [];
    
    this.rules.forEach(rule => {
      const matches = this.content.match(rule.pattern);
      if (matches) {
        matches.forEach(match => {
          this.violations.push({
            rule: rule.name,
            severity: rule.severity,
            message: rule.message,
            match: match,
            position: this.findPosition(match)
          });
        });
      }
    });
    
    return this.violations;
  }
  
  generateReport() {
    const high = this.violations.filter(v => v.severity === 'high').length;
    const medium = this.violations.filter(v => v.severity === 'medium').length;
    const low = this.violations.filter(v => v.severity === 'low').length;
    
    return {
      summary: {
        total: this.violations.length,
        high: high,
        medium: medium,
        low: low
      },
      violations: this.violations,
      suggestions: this.generateSuggestions()
    };
  }
}

四、性能监控与优化

1. 招标网站特有指标

class TenderPerformanceMonitor {
  constructor() {
    this.metrics = {
      pageLoad: {
        fcp: 0,
        lcp: 0,
        fid: 0
      },
      fileOperations: {
        downloadTimes: [],
        previewTimes: [],
        batchTimes: []
      },
      collaboration: {
        wsLatency: [],
        syncDelay: []
      },
      userEngagement: {
        avgReadTime: 0,
        attachmentDownloads: 0,
        calculations: 0
      }
    };
    
    this.thresholds = {
      fileDownload: 5000, // 5秒
      wsLatency: 100,     // 100ms
      pageLoad: 3000      // 3秒
    };
  }
  
  monitorFileOperations() {
    // 监控文件下载
    const originalFetch = window.fetch;
    window.fetch = function(...args) {
      const start = performance.now();
      
      return originalFetch.apply(this, args).then(response => {
        const end = performance.now();
        const duration = end - start;
        
        if (args[0].includes('/attachments/')) {
          this.metrics.fileOperations.downloadTimes.push(duration);
          
          if (duration > this.thresholds.fileDownload) {
            this.reportSlowDownload(args[0], duration);
          }
        }
        
        return response;
      });
    }.bind(this);
  }
  
  monitorCollaboration() {
    if (this.socket) {
      // WebSocket延迟监控
      setInterval(() => {
        const start = Date.now();
        this.socket.send(JSON.stringify({ type: 'ping' }));
        
        this.socket.once('pong', () => {
          const latency = Date.now() - start;
          this.metrics.collaboration.wsLatency.push(latency);
          
          if (latency > this.thresholds.wsLatency) {
            this.reportHighLatency(latency);
          }
        });
      }, 30000);
    }
  }
}

五、优化效果对比

六、面试高频追问

Q：采购招标网站和普通电商在性能优化上有何不同？

1. 信息权威性：招标公告必须完整显示，不能随意截断

2. 文件处理：大量PDF/Word附件，需要批量处理和对比

3. 时间敏感性：投标截止时间等关键时间点需要实时提醒

4. 合规性要求：内容必须符合招投标法规

5. 协同工作：投标团队需要多人协同

6. 移动办公：投标人常在工地现场用手机查看

Q：如何优化招标文件的批量下载？

1. 打包下载：使用JSZip将多个文件打包成一个ZIP

2. 分片下载：大文件分片下载，支持断点续传

3. 进度显示：显示总体和单个文件下载进度

4. 失败重试：失败的文件自动重试

5. 后台下载：支持后台下载，不阻塞用户操作

6. 离线缓存：已下载文件本地缓存

Q：招标文件的对比功能如何实现？

1. 文本提取：提取PDF/Word文件的文本内容

2. 差异算法：使用diff-match-patch等算法对比文本

3. 差异高亮：视觉化显示增删改内容

4. 并行处理：多个文件并行对比

5. 结果缓存：缓存对比结果，避免重复计算

6. 导出报告：支持导出对比报告

Q：评分计算器如何保证准确性？

1. 规则引擎：内置评分规则引擎

2. 实时计算：输入时实时计算得分

3. 合规检查：检查输入值是否在合理范围

4. 历史数据：参考历史投标数据

5. 模拟分析：模拟最优方案和竞争对手

6. 审计日志：记录所有计算过程

Q：多人协同如何实现？

1. WebSocket：实时通信

2. 操作转换：处理并发操作的冲突

3. 版本控制：Git-like版本管理

4. 离线支持：离线时本地存储，上线后同步

5. 权限控制：不同角色不同权限

6. 审计追溯：记录所有操作历史

七、总结

采购招标性能优化的核心是：用"智能解析"解决"信息过载"，用"批量处理"解决"附件繁多"，用"实时计算"解决"得分复杂"，用"协同工具"解决"团队协作"。