MoeKoeMusic 故障排查与调试指南：技术侦探的音乐客户端排错手册

2026-05-06 10:21:16作者：尤辰城Agatha

一款开源简洁高颜值的酷狗第三方客户端 An open-source, concise, and aesthetically pleasing third-party client for KuGou that supports Windows / macOS / Linux / Web :electron:

项目地址：https://gitcode.com/gh_mirrors/mo/MoeKoeMusic

MoeKoeMusic是一款开源简洁高颜值的酷狗第三方客户端，支持Windows/macOS/Linux平台，提供音乐播放、歌单管理、歌词显示等核心功能。本文将以"技术侦探"的视角，通过"问题发现→根源分析→解决方案→预防措施"四阶段框架，帮助开发者系统性排查和解决应用中的各类故障。

1 建立故障排查思维框架

1.1 故障排查的四阶段方法论

作为技术侦探，面对任何故障都需要遵循科学的排查流程：

graph TD
    A[问题发现] --> B[证据收集]
    B --> C[根源分析]
    C --> D[解决方案实施]
    D --> E[预防措施制定]
    E --> F[文档记录]

[!TIP] 所有故障排查都应遵循"先现象后本质，先简单后复杂，先软件后硬件"的基本原则，避免盲目操作导致问题扩大化。

1.2 必备调试环境配置

在开始故障排查前，确保开发环境已配置以下工具：

# 安装项目依赖
npm install

# 启动开发模式并开启详细日志
npm run dev -- --debug

# 实时监控日志输出
tail -f logs/app.log | grep -E "ERROR|WARN"

2 问题发现：识别故障特征

2.1 客户端常见故障表现

MoeKoeMusic的故障通常表现为以下几种可观察现象：

播放异常：音频无法播放、卡顿或音质问题
界面异常：UI元素错位、空白或渲染错误
功能失效：按钮无响应、操作无法完成
数据异常：歌曲信息错误、歌单丢失或重复

图1：MoeKoeMusic播放器界面，展示正常播放状态下的歌词显示和控制区域

2.2 错误信息收集方法

有效的证据收集是故障排查的基础：

// 在src/utils/request.js中增强错误日志收集
httpClient.interceptors.response.use(
  response => response.data,
  error => {
    // 收集详细错误信息
    const errorDetails = {
      timestamp: new Date().toISOString(),
      url: error.config.url,
      method: error.config.method,
      status: error.response?.status,
      data: error.response?.data,
      stack: error.stack  // 记录调用栈信息
    };
    
    // 输出到控制台
    console.error('API请求错误:', JSON.stringify(errorDetails, null, 2));
    
    // 同时记录到本地日志文件
    logToFile('api_errors.log', errorDetails);
    
    return Promise.reject(error);
  }
);

3 根源分析：侦探式证据解读

3.1 反向追踪法：从现象到代码

反向追踪法是最常用的故障定位技术，从用户报告的现象出发，逐步追踪到代码层面：

故障现象：播放按钮点击后无响应

排查步骤：

检查浏览器控制台是否有JavaScript错误
在src/components/player/AudioController.js中找到播放按钮事件处理函数
添加日志记录执行流程：

// src/components/player/AudioController.js
async play() {
  console.log('[AudioController] 播放按钮点击', { 
    currentTrack: this.currentTrack?.id,
    audioState: this.audio.state,
    isPlaying: this.isPlaying
  });
  
  try {
    if (this.isPlaying) {
      await this.pause();
    } else {
      // 检查音频元素是否已初始化
      if (!this.audioElement) {
        console.error('[AudioController] 音频元素未初始化');
        this.showError('播放器初始化失败，请刷新页面重试');
        return;
      }
      await this.audioElement.play();
      this.isPlaying = true;
    }
  } catch (error) {
    console.error('[AudioController] 播放失败:', error);
    this.handlePlayError(error);
  }
}

验证方法：观察控制台输出，确认是初始化失败、权限问题还是资源加载错误

3.2 环境隔离法：排除外部干扰

环境隔离法通过控制变量来确定故障是否与特定环境因素相关：

# 创建干净的测试环境
mkdir -p ~/moe-test && cd ~/moe-test

# 克隆全新代码库
git clone https://gitcode.com/gh_mirrors/mo/MoeKoeMusic

# 安装依赖
cd MoeKoeMusic && npm install

# 启动基础版本，排除配置和扩展影响
npm run dev -- --clean

通过比较不同环境（开发/生产、不同设备、网络条件）的表现，确定故障是否与特定环境因素相关。

3.3 数据流追踪法：监控数据流转

对于数据相关故障，跟踪数据从API请求到UI渲染的完整路径：

// src/views/PlaylistDetail.vue
async loadPlaylistDetail(playlistId) {
  // 追踪数据请求开始
  console.log(`[PlaylistDetail] 开始加载歌单 ${playlistId}`);
  
  try {
    this.isLoading = true;
    // 使用带追踪ID的请求
    const traceId = `pl_${Date.now()}`;
    const response = await request.get(`/playlist/detail?id=${playlistId}`, {
      headers: { 'X-Trace-Id': traceId }
    });
    
    console.log(`[PlaylistDetail] 数据加载完成`, { traceId, dataLength: response.songs?.length });
    
    // 验证数据结构
    if (!Array.isArray(response.songs)) {
      throw new Error('歌单数据格式错误，预期歌曲数组');
    }
    
    this.playlist = response;
    this.processSongs(response.songs);
  } catch (error) {
    console.error(`[PlaylistDetail] 加载失败:`, error);
    this.error = error.message;
  } finally {
    this.isLoading = false;
  }
}

4 解决方案：针对特定故障的修复方案

4.1 修复音频播放异常

故障现象：部分歌曲播放时卡顿或无声

错误代码：

// 问题代码：未处理音频格式兼容性和预加载
playAudio(url) {
  const audio = new Audio(url);
  audio.play();
}

修复代码：

// 修复代码：添加格式检查和预加载策略
async playAudio(url) {
  // 检查浏览器支持的格式
  const audio = new Audio();
  
  // 监听错误事件
  audio.addEventListener('error', (e) => {
    console.error('音频播放错误:', e);
    this.handleAudioError(e, url);
  });
  
  // 监听进度事件，用于诊断缓冲问题
  audio.addEventListener('progress', (e) => {
    if (audio.buffered.length > 0) {
      const bufferedEnd = audio.buffered.end(audio.buffered.length - 1);
      const duration = audio.duration;
      console.log(`[Audio] 缓冲进度: ${(bufferedEnd / duration * 100).toFixed(2)}%`);
      
      // 检测缓冲不足情况
      if (duration > 0 && bufferedEnd / duration < 0.2) {
        console.warn('[Audio] 缓冲不足，可能导致播放卡顿');
        this.showBufferingWarning();
      }
    }
  });
  
  // 尝试不同格式的后备URL
  try {
    // 首先尝试主URL
    audio.src = url;
    await audio.load();
    
    // 预加载至少2秒数据再播放
    await new Promise(resolve => {
      const checkBuffer = () => {
        if (audio.buffered.length > 0 && audio.buffered.end(0) > 2) {
          resolve();
        } else {
          setTimeout(checkBuffer, 100);
        }
      };
      checkBuffer();
    });
    
    await audio.play();
    return audio;
  } catch (error) {
    console.error('主URL播放失败，尝试备用格式:', error);
    
    // 尝试备用格式
    const fallbackUrl = url.replace('.mp3', '.m4a');
    audio.src = fallbackUrl;
    await audio.load();
    await audio.play();
    return audio;
  }
}

4.2 解决API请求超时问题

故障现象：网络不稳定时API请求频繁超时

修复方案：实现智能重试机制和超时控制

// src/utils/request.js
// 添加智能重试逻辑
const requestWithRetry = async (config, retries = 3, delay = 1000) => {
  try {
    // 动态设置超时时间，根据不同API调整
    const timeout = getApiTimeout(config.url);
    const response = await axios({ ...config, timeout });
    return response;
  } catch (error) {
    // 只对特定错误类型重试
    if (retries > 0 && isRetryableError(error)) {
      console.log(`请求重试 (${retries} 次 remaining): ${config.url}`);
      
      // 指数退避策略
      await new Promise(resolve => setTimeout(resolve, delay * (4 - retries)));
      
      // 递归重试
      return requestWithRetry(config, retries - 1, delay);
    }
    throw error;
  }
};

// 判断是否可重试的错误类型
const isRetryableError = (error) => {
  // 网络错误、500系列状态码或429限流错误可重试
  return !error.response || 
         (error.response.status >= 500) || 
         error.response.status === 429;
};

// 根据API设置不同超时
const getApiTimeout = (url) => {
  if (url.includes('/audio/')) return 15000; // 音频相关API超时较长
  if (url.includes('/large/')) return 20000; // 大文件请求
  return 5000; // 默认超时
};

4.3 修复Vue组件渲染错误

故障现象：歌单详情页在歌曲数量过多时渲染异常

修复方案：实现虚拟滚动和组件优化

<!-- src/components/PlaylistGrid.vue -->
<template>
  <div class="playlist-container">
    <!-- 使用虚拟滚动列表优化大量数据渲染 -->
    <virtual-list
      :data="songs"
      :height="500"
      :item-height="60"
      :buffer="5"
    >
      <template v-slot="{ item, index }">
        <song-item 
          :song="item" 
          :index="index"
          :key="item.id"
          @play="handlePlay(index)"
        />
      </template>
    </virtual-list>
  </div>
</template>

<script>
import { defineComponent, shallowRef, computed } from 'vue';
import VirtualList from 'vue-virtual-scroller';
import SongItem from './SongItem.vue';

export default defineComponent({
  components: {
    VirtualList,
    SongItem
  },
  props: {
    songs: {
      type: Array,
      required: true
    }
  },
  setup(props) {
    // 使用shallowRef避免深层响应式带来的性能问题
    const songsRef = shallowRef(props.songs);
    
    // 计算属性缓存处理后的数据
    const processedSongs = computed(() => {
      return songsRef.value.map(song => ({
        ...song,
        // 预计算显示需要的属性，避免在渲染时计算
        displayDuration: formatDuration(song.duration),
        isHighQuality: song.quality === 'HQ' || song.quality === 'SQ'
      }));
    });
    
    const handlePlay = (index) => {
      // 仅在需要时才获取完整歌曲数据
      const song = processedSongs.value[index];
      console.log(`播放歌曲: ${song.name} (ID: ${song.id})`);
      // 触发播放事件
      this.$emit('play', song);
    };
    
    return {
      songs: processedSongs,
      handlePlay
    };
  }
});
</script>

5 预防措施：构建健壮的防御体系

5.1 前端错误监控系统

实现全面的前端错误捕获机制：

// src/plugins/ErrorTrackingPlugin.js
export default {
  install(app) {
    // 捕获Vue错误
    app.config.errorHandler = (err, vm, info) => {
      logError({
        type: 'vue',
        message: err.message,
        stack: err.stack,
        component: vm?.$options.name,
        info
      });
    };
    
    // 捕获全局错误
    window.addEventListener('error', (event) => {
      logError({
        type: 'window',
        message: event.error.message,
        stack: event.error.stack,
        filename: event.filename,
        lineno: event.lineno,
        colno: event.colno
      });
    });
    
    // 捕获未处理的Promise拒绝
    window.addEventListener('unhandledrejection', (event) => {
      logError({
        type: 'promise',
        reason: event.reason?.message || String(event.reason),
        stack: event.reason?.stack
      });
      // 防止默认处理（控制台警告）
      event.preventDefault();
    });
    
    // 错误日志发送函数
    function logError(errorData) {
      const errorInfo = {
        ...errorData,
        timestamp: new Date().toISOString(),
        appVersion: process.env.VUE_APP_VERSION,
        userId: localStorage.getItem('userId') || 'anonymous',
        deviceInfo: `${navigator.userAgent}`
      };
      
      // 控制台输出
      console.error('捕获到错误:', errorInfo);
      
      // 发送到后端（使用 navigator.sendBeacon 确保可靠发送）
      if (navigator.sendBeacon) {
        navigator.sendBeacon('/api/log/error', JSON.stringify(errorInfo));
      } else {
        fetch('/api/log/error', {
          method: 'POST',
          body: JSON.stringify(errorInfo),
          keepalive: true
        });
      }
    }
  }
};

5.2 后端服务健壮性增强

在api/server.js中添加全局错误处理和资源监控：

// api/server.js
// 添加未捕获异常处理
process.on('uncaughtException', (error) => {
  console.error('未捕获的异常:', error);
  // 记录详细错误信息
  logger.error({
    type: 'uncaughtException',
    message: error.message,
    stack: error.stack,
    timestamp: new Date().toISOString()
  });
  // 优雅重启服务
  gracefulRestart();
});

// 添加未处理的Promise拒绝处理
process.on('unhandledRejection', (reason, promise) => {
  console.error('未处理的Promise拒绝:', reason);
  logger.error({
    type: 'unhandledRejection',
    reason: reason?.message || String(reason),
    stack: reason?.stack,
    promise: promise.toString(),
    timestamp: new Date().toISOString()
  });
});

// 实现API请求限流
const rateLimit = require('express-rate-limit');
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 100, // 每个IP限制请求数
  standardHeaders: true,
  legacyHeaders: false,
  // 自定义响应
  message: {
    code: 429,
    message: '请求过于频繁，请稍后再试'
  }
});

// 对敏感API应用限流
app.use('/api/comment', apiLimiter);
app.use('/api/login', rateLimit({
  windowMs: 60 * 60 * 1000,
  max: 5,
  message: { code: 429, message: '登录尝试次数过多，请1小时后再试' }
}));

5.3 自动化测试与持续集成

配置GitHub Actions实现自动化测试：

# .github/workflows/test.yml
name: 自动化测试

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        node-version: [14.x, 16.x]
        
    steps:
    - uses: actions/checkout@v3
    
    - name: 使用 Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
        
    - name: 安装依赖
      run: npm ci
      
    - name: 代码风格检查
      run: npm run lint
      
    - name: 单元测试
      run: npm test
      
    - name: 构建测试
      run: npm run build
      
    - name: API集成测试
      run: npm run test:api
      
    - name: 生成测试报告
      if: always()
      run: npm run test:report
      
    - name: 上传测试报告
      uses: actions/upload-artifact@v3
      with:
        name: test-report
        path: test-report/

6 错误模式识别：常见故障特征与解决方案

6.1 认证失效模式

特征：

操作时突然跳转到登录页面
API请求返回401或403状态码
控制台出现"token expired"相关错误

解决方案：实现无感刷新token机制

// src/utils/auth.js
let isRefreshing = false;
let failedQueue = [];

// 处理token刷新
const refreshToken = async () => {
  if (isRefreshing) {
    return new Promise(resolve => {
      failedQueue.push(resolve);
    });
  }
  
  isRefreshing = true;
  const refreshToken = localStorage.getItem('refreshToken');
  
  try {
    const response = await axios.post('/api/login/refresh', { refreshToken });
    const { token, newRefreshToken } = response.data;
    
    localStorage.setItem('token', token);
    localStorage.setItem('refreshToken', newRefreshToken);
    
    // 重试队列中的请求
    failedQueue.forEach(resolve => resolve(token));
    failedQueue = [];
    
    return token;
  } catch (error) {
    // 刷新失败，需要重新登录
    localStorage.removeItem('token');
    localStorage.removeItem('refreshToken');
    window.location.href = '/login';
    throw error;
  } finally {
    isRefreshing = false;
  }
};

6.2 资源加载失败模式

特征：

图片显示破碎图标
音频播放提示"文件格式不支持"
控制台出现404或503错误

解决方案：实现资源加载降级策略

// src/utils/resourceLoader.js
export const loadImageWithFallback = (src, fallbacks = []) => {
  return new Promise((resolve, reject) => {
    const img = new Image();
    
    const tryNextFallback = (index) => {
      if (index >= fallbacks.length) {
        // 所有备选都失败，使用默认图片
        img.src = '/assets/images/default-cover.png';
        return;
      }
      
      img.src = fallbacks[index];
      img.onerror = () => tryNextFallback(index + 1);
    };
    
    img.onload = () => resolve(img);
    img.onerror = () => {
      if (fallbacks.length > 0) {
        tryNextFallback(0);
      } else {
        // 没有备选，使用默认图片
        img.src = '/assets/images/default-cover.png';
        resolve(img);
      }
    };
    
    img.src = src;
  });
};

6.3 状态管理异常模式

特征：

UI显示与实际状态不一致
操作后状态未更新
组件间状态同步问题

解决方案：优化状态管理逻辑

// src/stores/musicQueue.js
import { defineStore } from 'pinia';

export const useMusicQueueStore = defineStore('musicQueue', {
  state: () => ({
    queue: [],
    currentIndex: -1,
    // 添加状态追踪
    history: [],
    isProcessing: false
  }),
  
  actions: {
    // 添加严格的状态更新逻辑
    async addToQueue(songs, playNow = false) {
      if (!Array.isArray(songs)) {
        console.error('addToQueue: 歌曲必须是数组');
        return;
      }
      
      // 防止并发修改
      if (this.isProcessing) {
        console.warn('队列操作正在进行中，请稍后再试');
        return;
      }
      
      this.isProcessing = true;
      
      try {
        // 验证歌曲数据有效性
        const validSongs = songs.filter(song => 
          song.id && song.name && song.url
        );
        
        if (validSongs.length === 0) {
          console.warn('没有有效的歌曲添加到队列');
          return;
        }
        
        // 记录历史状态用于撤销
        this.history.push({
          queue: [...this.queue],
          currentIndex: this.currentIndex
        });
        
        if (playNow) {
          // 立即播放时插入到当前位置之后
          this.queue.splice(this.currentIndex + 1, 0, ...validSongs);
          this.currentIndex += 1;
        } else {
          this.queue.push(...validSongs);
        }
        
        console.log(`成功添加 ${validSongs.length} 首歌曲到队列`);
      } catch (error) {
        console.error('添加到队列失败:', error);
      } finally {
        this.isProcessing = false;
      }
    },
    
    // 添加撤销功能
    undoLastAction() {
      if (this.history.length === 0) return;
      
      const lastState = this.history.pop();
      this.queue = lastState.queue;
      this.currentIndex = lastState.currentIndex;
    }
  }
});

6.4 性能瓶颈模式

特征：

页面加载缓慢
滚动时卡顿
操作响应延迟超过300ms

解决方案：性能优化策略

// src/utils/performance.js
// 实现关键路径优化
export const optimizeCriticalPath = () => {
  // 1. 延迟加载非关键组件
  const lazyLoadComponents = () => {
    const components = [
      () => import('@/components/CommentSection.vue'),
      () => import('@/components/RelatedSongs.vue'),
      () => import('@/components/SharePanel.vue')
    ];
    
    // 当页面空闲时加载
    if (window.requestIdleCallback) {
      components.forEach((loader, index) => {
        window.requestIdleCallback(() => {
          loader().then(() => {
            console.log(`延迟加载组件 ${index + 1} 完成`);
          });
        }, { timeout: 2000 });
      });
    } else {
      // 降级方案
      components.forEach((loader, index) => {
        setTimeout(() => loader(), 500 * (index + 1));
      });
    }
  };
  
  // 2. 优化图片加载
  const optimizeImages = () => {
    const images = document.querySelectorAll('img.lazy-load');
    if ('IntersectionObserver' in window) {
      const imageObserver = new IntersectionObserver((entries, observer) => {
        entries.forEach(entry => {
          if (entry.isIntersecting) {
            const img = entry.target;
            img.src = img.dataset.src;
            img.classList.remove('lazy-load');
            imageObserver.unobserve(img);
          }
        });
      });
      
      images.forEach(img => imageObserver.observe(img));
    }
  };
  
  // 3. 启动优化
  document.addEventListener('DOMContentLoaded', () => {
    lazyLoadComponents();
    optimizeImages();
    
    // 记录性能指标
    setTimeout(() => {
      if (window.performance) {
        const perfData = window.performance.getEntriesByType('navigation')[0];
        console.log('页面加载性能:', {
          loadTime: perfData.loadEventEnd - perfData.startTime,
          domReadyTime: perfData.domContentLoadedEventEnd - perfData.startTime
        });
      }
    }, 1000);
  });
};

6.5 跨平台兼容性模式

特征：

在特定操作系统上功能异常
不同浏览器表现不一致
移动设备适配问题

解决方案：跨平台适配策略

// src/utils/platform.js
export const platform = {
  // 检测当前平台
  detect() {
    const userAgent = navigator.userAgent;
    
    return {
      isWindows: userAgent.includes('Windows'),
      isMac: userAgent.includes('Macintosh'),
      isLinux: userAgent.includes('Linux') && !userAgent.includes('Android'),
      isAndroid: userAgent.includes('Android'),
      isIOS: /iPhone|iPad|iPod/.test(userAgent),
      isElectron: window.process?.type === 'renderer',
      isChrome: userAgent.includes('Chrome') && !userAgent.includes('Edge'),
      isFirefox: userAgent.includes('Firefox'),
      isSafari: userAgent.includes('Safari') && !userAgent.includes('Chrome')
    };
  },
  
  // 获取适合当前平台的API实现
  getApiAdapter() {
    const os = this.detect();
    
    // 音频API适配
    if (os.isSafari) {
      return {
        audio: () => import('@/adapters/audio/safari.js'),
        notification: () => import('@/adapters/notification/safari.js')
      };
    } else if (os.isElectron) {
      return {
        audio: () => import('@/adapters/audio/electron.js'),
        notification: () => import('@/adapters/notification/electron.js')
      };
    } else {
      return {
        audio: () => import('@/adapters/audio/default.js'),
        notification: () => import('@/adapters/notification/default.js')
      };
    }
  },
  
  // 应用平台特定的CSS类
  applyPlatformClasses() {
    const os = this.detect();
    const root = document.documentElement;
    
    // 添加平台类
    Object.entries(os).forEach(([key, value]) => {
      if (value) {
        root.classList.add(`platform-${key.toLowerCase()}`);
      }
    });
  }
};

7 实用工具与决策指南

7.1 故障排查决策树

graph TD
    A[开始排查] --> B{问题类型}
    
    B -->|播放问题| C[检查音频URL是否有效]
    C -->|有效| D[检查系统音频设备]
    C -->|无效| E[检查API响应]
    D -->|正常| F[检查音频格式支持]
    D -->|异常| G[重启音频服务]
    F -->|支持| H[检查播放器组件状态]
    F -->|不支持| I[切换备用格式]
    
    B -->|界面问题| J[检查控制台错误]
    J -->|有错误| K[定位错误组件]
    J -->|无错误| L[检查数据状态]
    K --> M[修复组件渲染问题]
    L --> N[检查数据接口返回]
    
    B -->|网络问题| O[检查网络连接]
    O -->|正常| P[检查API服务状态]
    O -->|异常| Q[修复网络连接]
    P -->|正常| R[检查请求参数]
    P -->|异常| S[联系服务管理员]
    
    B -->|功能问题| T[检查权限设置]
    T -->|已授权| U[检查功能实现代码]
    T -->|未授权| V[引导用户授权]
    U --> W[单元测试验证功能]
    
    H --> X[修复播放器状态]
    I --> X
    M --> X
    N --> X
    R --> X
    W --> X
    X[问题解决] --> Z[记录解决方案]

7.2 开发环境检测脚本

创建bash脚本检查开发环境配置：

#!/bin/bash
# check-environment.sh - MoeKoeMusic开发环境检测脚本

echo "=== MoeKoeMusic 开发环境检测 ==="

# 检查Node.js版本
echo -n "Node.js版本检查: "
NODE_VERSION=$(node -v 2>/dev/null)
if [ $? -ne 0 ]; then
  echo "未安装Node.js"
  exit 1
fi
echo "$NODE_VERSION"

# 检查npm版本
echo -n "npm版本检查: "
NPM_VERSION=$(npm -v 2>/dev/null)
if [ $? -ne 0 ]; then
  echo "未安装npm"
  exit 1
fi
echo "$NPM_VERSION"

# 检查依赖安装
echo -n "项目依赖检查: "
if [ ! -d "node_modules" ]; then
  echo "未安装依赖，正在安装..."
  npm install
else
  echo "已安装"
fi

# 检查端口占用
echo -n "端口8080占用检查: "
PORT_USED=$(netstat -tuln | grep :8080 | wc -l)
if [ $PORT_USED -gt 0 ]; then
  echo "端口已占用"
  echo "提示: 使用 lsof -i:8080 查找占用进程"
else
  echo "可用"
fi

# 检查Git配置
echo -n "Git配置检查: "
GIT_USER=$(git config user.name)
if [ -z "$GIT_USER" ]; then
  echo "未配置Git用户信息"
else
  echo "已配置: $GIT_USER"
fi

# 检查环境变量
echo -n "环境变量检查: "
if [ -f ".env" ]; then
  echo "已找到.env文件"
  echo "关键配置: $(grep -v '^#' .env | grep -v '^$' | wc -l)项"
else
  echo "未找到.env文件，使用默认配置"
fi

echo "=== 检测完成 ==="
echo "如果有问题，请根据提示修复后再启动开发服务"

7.3 错误日志分析正则表达式模板

常用日志分析正则表达式：

# 匹配API错误
API错误: (\d{3}) (\w+) (.*)

# 匹配播放错误
播放失败: (.*) \((\w+)\)

# 匹配认证错误
认证失败: (.*) 用户ID: (\w+)

# 匹配网络超时
超时错误: (.*) 耗时: (\d+)ms URL: (.*)

# 匹配数据库错误
数据库错误: (.*) SQL: (.*)

# 使用方法示例
# grep -E "API错误: [45][0-9]{2}" logs/app.log
# grep -E "播放失败: .*" logs/app.log | sed -E "s/播放失败: (.*) \((\w+)\)/\1 - 错误代码:\2/"