目录

  • 每日一句正能量
  • 摘要
  • 一、引言：为什么调试技巧如此重要？
  • 二、断点调试技巧
  • 2.1 断点类型
  • 2.2 断点调试实现
  • 三、日志分析技巧
  • 3.1 日志级别
  • 3.2 日志分析实现
  • 四、性能分析技巧
  • 4.1 性能分析工具
  • 4.2 性能分析实现
  • 五、调试实战案例
  • 5.1 内存泄漏调试
  • 六、高级调试技巧
  • 6.1 远程调试
  • 6.2 单元测试调试
  • 6.3 性能调优调试
  • 七、常见问题与解决
  • 七、结语：调试是开发的"必修课"

在这里插入图片描述

每日一句正能量

“允许自己偶尔的断电，带着不完美，同样可以好好生活。”
好好生活的条件，并非“先变得完美”；恰恰相反，是带着裂缝、缺口、电量不足的状态，依然可以启动生活。

相信"调试是开发的必修课"。

摘要

摘要：高效的调试是开发效率的保障。本文深入分享DevEco Studio的调试技巧和最佳实践，从断点调试、日志分析到性能分析，提供HarmonyOS开发中的完整调试方法论，帮助开发者快速定位和解决问题。

一、引言：为什么调试技巧如此重要？

"代码写完了，但不知道哪里出了问题。"

"断点打了一堆，还是找不到bug的根源。"

"性能问题只有在真机上才出现，怎么调试？"

调试是开发过程中最耗时的环节，掌握高效的调试技巧可以：

  • 节省时间：快速定位问题，减少无效排查
  • 提高质量：深入理解代码，发现潜在问题
  • 优化性能：找到性能瓶颈，提升应用体验
  • 增强信心：确保代码的正确性和稳定性

二、断点调试技巧

2.1 断点类型

在这里插入图片描述

图1：断点类型——行断点、条件断点、异常断点、日志断点

断点类型描述使用场景快捷键
行断点在指定行暂停通用调试F9
条件断点满足条件时暂停循环调试Ctrl+Shift+F9
异常断点抛出异常时暂停异常定位菜单设置
日志断点输出日志不暂停日志追踪Shift+F9
方法断点进入/退出方法时暂停方法追踪方法签名处

2.2 断点调试实现

// 断点调试示例
class BreakpointDebugger {
  private data: number[] = []
  private counter: number = 0

  // 方法1: 普通断点调试
  processData(items: number[]): number[] {
    const result: number[] = []
    
    // 在此处设置行断点
    for (const item of items) {
      // 在此处设置条件断点: item > 100
      const processed = this.processItem(item)
      result.push(processed)
    }
    
    return result
  }

  // 方法2: 条件断点调试
  processItem(item: number): number {
    // 在此处设置条件断点: item === 42
    if (item < 0) {
      // 在此处设置异常断点
      throw new Error('Negative value not allowed')
    }
    
    // 在此处设置日志断点: console.log(`Processing: ${item}`)
    const result = item * 2
    this.counter++
    
    return result
  }

  // 方法3: 方法断点调试
  calculateSum(a: number, b: number): number {
    // 在此处设置方法断点（进入时）
    const sum = a + b
    // 在此处设置方法断点（退出时）
    return sum
  }

  // 方法4: 异常断点调试
  riskyOperation(): void {
    try {
      // 可能抛出异常的操作
      const result = this.divide(10, 0)
      console.info(`Result: ${result}`)
    } catch (error) {
      // 异常断点会在这里暂停
      console.error('Error caught:', error)
    }
  }

  // 方法5: 日志断点调试
  trackDataFlow(data: any): void {
    // 在此处设置日志断点，不暂停
    console.log(`Data received: ${JSON.stringify(data)}`)
    
    // 处理数据
    const processed = this.transformData(data)
    
    // 在此处设置日志断点，不暂停
    console.log(`Data processed: ${JSON.stringify(processed)}`)
  }

  private divide(a: number, b: number): number {
    if (b === 0) {
      throw new Error('Division by zero')
    }
    return a / b
  }

  private transformData(data: any): any {
    return { ...data, timestamp: Date.now() }
  }
}

三、日志分析技巧

3.1 日志级别

在这里插入图片描述

图2：日志级别——Verbose、Debug、Info、Warn、Error、Fatal

日志级别描述使用场景输出频率
Verbose详细日志开发调试高
Debug调试日志功能验证中
Info信息日志正常运行低
Warn警告日志潜在问题低
Error错误日志错误处理极低
Fatal致命日志崩溃处理极低

3.2 日志分析实现

// 日志分析器
class LogAnalyzer {
  private logs: LogEntry[] = []

  // 添加日志
  addLog(level: LogLevel, message: string, tag?: string): void {
    const entry: LogEntry = {
      timestamp: Date.now(),
      level,
      message,
      tag: tag || 'default'
    }
    
    this.logs.push(entry)
    
    // 根据级别输出到控制台
    switch (level) {
      case LogLevel.VERBOSE:
        console.log(`[V] ${message}`)
        break
      case LogLevel.DEBUG:
        console.debug(`[D] ${message}`)
        break
      case LogLevel.INFO:
        console.info(`[I] ${message}`)
        break
      case LogLevel.WARN:
        console.warn(`[W] ${message}`)
        break
      case LogLevel.ERROR:
        console.error(`[E] ${message}`)
        break
      case LogLevel.FATAL:
        console.error(`[F] ${message}`)
        break
    }
  }

  // 按级别过滤日志
  filterByLevel(level: LogLevel): LogEntry[] {
    return this.logs.filter(log => log.level >= level)
  }

  // 按标签过滤日志
  filterByTag(tag: string): LogEntry[] {
    return this.logs.filter(log => log.tag === tag)
  }

  // 按时间范围过滤日志
  filterByTimeRange(startTime: number, endTime: number): LogEntry[] {
    return this.logs.filter(log => log.timestamp >= startTime && log.timestamp <= endTime)
  }

  // 分析日志模式
  analyzePatterns(): LogPattern[] {
    const patterns: LogPattern[] = []
    
    // 统计各级别的日志数量
    const levelCounts = new Map<LogLevel, number>()
    for (const log of this.logs) {
      const count = levelCounts.get(log.level) || 0
      levelCounts.set(log.level, count + 1)
    }
    
    // 统计各标签的日志数量
    const tagCounts = new Map<string, number>()
    for (const log of this.logs) {
      const count = tagCounts.get(log.tag) || 0
      tagCounts.set(log.tag, count + 1)
    }
    
    // 生成模式报告
    for (const [level, count] of levelCounts) {
      patterns.push({
        type: 'level',
        value: LogLevel[level],
        count,
        percentage: (count / this.logs.length) * 100
      })
    }
    
    return patterns
  }

  // 导出日志
  exportLogs(): string {
    return this.logs.map(log => 
      `[${new Date(log.timestamp).toISOString()}] [${LogLevel[log.level]}] ${log.tag}: ${log.message}`
    ).join('\n')
  }
}

// 日志级别
enum LogLevel {
  VERBOSE = 0,
  DEBUG = 1,
  INFO = 2,
  WARN = 3,
  ERROR = 4,
  FATAL = 5
}

// 日志条目
interface LogEntry {
  timestamp: number
  level: LogLevel
  message: string
  tag: string
}

// 日志模式
interface LogPattern {
  type: string
  value: string
  count: number
  percentage: number
}

四、性能分析技巧

4.1 性能分析工具

在这里插入图片描述

图3：性能分析——CPU Profiler、Memory Profiler、Network Profiler、Energy Profiler

分析工具描述使用场景输出
CPU ProfilerCPU使用率分析热点方法定位火焰图
Memory Profiler内存使用分析内存泄漏检测堆快照
Network Profiler网络请求分析网络性能优化请求瀑布图
Energy Profiler能耗分析功耗优化能耗报告

4.2 性能分析实现

// 性能分析器
class PerformanceProfiler {
  private cpuSamples: CPUSample[] = []
  private memorySamples: MemorySample[] = []
  private isProfiling: boolean = false

  // 开始性能分析
  startProfiling(): void {
    this.isProfiling = true
    this.cpuSamples = []
    this.memorySamples = []
    
    // 启动CPU采样
    this.startCPUSampling()
    
    // 启动内存采样
    this.startMemorySampling()
  }

  // 停止性能分析
  stopProfiling(): PerformanceReport {
    this.isProfiling = false
    
    return {
      cpu: this.analyzeCPU(),
      memory: this.analyzeMemory(),
      recommendations: this.generateRecommendations()
    }
  }

  // CPU采样
  private startCPUSampling(): void {
    const sampleCPU = () => {
      if (!this.isProfiling) return
      
      const sample: CPUSample = {
        timestamp: Date.now(),
        usage: this.getCPUUsage(),
        threadCount: this.getThreadCount()
      }
      
      this.cpuSamples.push(sample)
      setTimeout(sampleCPU, 100)
    }
    
    sampleCPU()
  }

  // 内存采样
  private startMemorySampling(): void {
    const sampleMemory = () => {
      if (!this.isProfiling) return
      
      const sample: MemorySample = {
        timestamp: Date.now(),
        heapSize: this.getHeapSize(),
        heapUsed: this.getHeapUsed(),
        objectCount: this.getObjectCount()
      }
      
      this.memorySamples.push(sample)
      setTimeout(sampleMemory, 1000)
    }
    
    sampleMemory()
  }

  // 分析CPU
  private analyzeCPU(): CPUAnalysis {
    const usages = this.cpuSamples.map(s => s.usage)
    const avgUsage = usages.reduce((a, b) => a + b, 0) / usages.length
    const maxUsage = Math.max(...usages)
    
    return {
      averageUsage: avgUsage,
      peakUsage: maxUsage,
      samples: this.cpuSamples.length
    }
  }

  // 分析内存
  private analyzeMemory(): MemoryAnalysis {
    const heapSizes = this.memorySamples.map(s => s.heapSize)
    const heapUsed = this.memorySamples.map(s => s.heapUsed)
    
    return {
      peakHeapSize: Math.max(...heapSizes),
      averageHeapSize: heapSizes.reduce((a, b) => a + b, 0) / heapSizes.length,
      peakHeapUsed: Math.max(...heapUsed),
      samples: this.memorySamples.length
    }
  }

  // 生成优化建议
  private generateRecommendations(): string[] {
    const recommendations: string[] = []
    
    const cpuAnalysis = this.analyzeCPU()
    const memoryAnalysis = this.analyzeMemory()
    
    if (cpuAnalysis.peakUsage > 80) {
      recommendations.push('CPU使用率过高，建议优化热点方法')
    }
    
    if (memoryAnalysis.peakHeapUsed > memoryAnalysis.peakHeapSize * 0.8) {
      recommendations.push('内存使用率过高，建议检查内存泄漏')
    }
    
    return recommendations
  }

  // 获取CPU使用率
  private getCPUUsage(): number {
    // 获取CPU使用率的实现
    return 0
  }

  // 获取线程数
  private getThreadCount(): number {
    // 获取线程数的实现
    return 0
  }

  // 获取堆大小
  private getHeapSize(): number {
    // 获取堆大小的实现
    return 0
  }

  // 获取已使用堆大小
  private getHeapUsed(): number {
    // 获取已使用堆大小的实现
    return 0
  }

  // 获取对象数量
  private getObjectCount(): number {
    // 获取对象数量的实现
    return 0
  }
}

// CPU样本
interface CPUSample {
  timestamp: number
  usage: number
  threadCount: number
}

// 内存样本
interface MemorySample {
  timestamp: number
  heapSize: number
  heapUsed: number
  objectCount: number
}

// 性能报告
interface PerformanceReport {
  cpu: CPUAnalysis
  memory: MemoryAnalysis
  recommendations: string[]
}

// CPU分析
interface CPUAnalysis {
  averageUsage: number
  peakUsage: number
  samples: number
}

// 内存分析
interface MemoryAnalysis {
  peakHeapSize: number
  averageHeapSize: number
  peakHeapUsed: number
  samples: number
}

五、调试实战案例

5.1 内存泄漏调试

在这里插入图片描述

图4：内存泄漏调试——堆快照、引用链、泄漏点定位

// 内存泄漏调试器
class MemoryLeakDebugger {
  private heapSnapshots: HeapSnapshot[] = []

  // 捕获堆快照
  captureHeapSnapshot(): HeapSnapshot {
    const snapshot: HeapSnapshot = {
      timestamp: Date.now(),
      objects: this.getHeapObjects()
    }
    
    this.heapSnapshots.push(snapshot)
    return snapshot
  }

  // 分析内存泄漏
  analyzeMemoryLeak(): LeakReport[] {
    if (this.heapSnapshots.length < 2) {
      return []
    }

    const leaks: LeakReport[] = []
    const currentSnapshot = this.heapSnapshots[this.heapSnapshots.length - 1]
    const previousSnapshot = this.heapSnapshots[this.heapSnapshots.length - 2]

    // 比较对象数量
    const currentObjects = this.countObjectsByType(currentSnapshot)
    const previousObjects = this.countObjectsByType(previousSnapshot)

    for (const [type, currentCount] of currentObjects) {
      const previousCount = previousObjects.get(type) || 0
      const growth = currentCount - previousCount

      if (growth > 100) {
        leaks.push({
          type,
          currentCount,
          previousCount,
          growth,
          percentage: (growth / previousCount) * 100
        })
      }
    }

    return leaks
  }

  // 按类型统计对象
  private countObjectsByType(snapshot: HeapSnapshot): Map<string, number> {
    const counts = new Map<string, number>()
    
    for (const obj of snapshot.objects) {
      const count = counts.get(obj.type) || 0
      counts.set(obj.type, count + 1)
    }

    return counts
  }

  // 获取堆对象
  private getHeapObjects(): HeapObject[] {
    // 获取堆对象的实现
    return []
  }
}

// 堆快照
interface HeapSnapshot {
  timestamp: number
  objects: HeapObject[]
}

// 堆对象
interface HeapObject {
  id: string
  type: string
  size: number
  references: string[]
}

// 泄漏报告
interface LeakReport {
  type: string
  currentCount: number
  previousCount: number
  growth: number
  percentage: number
}

六、高级调试技巧

在这里插入图片描述

6.1 远程调试

远程调试是HarmonyOS开发中的重要技能，特别是在真机调试时：

// 远程调试配置
class RemoteDebugger {
  private deviceId: string
  private port: number

  constructor(deviceId: string, port: number = 9229) {
    this.deviceId = deviceId
    this.port = port
  }

  // 连接远程设备
  async connect(): Promise<void> {
    // 使用hdc命令连接设备
    await this.executeCommand(`hdc connect ${this.deviceId}`)
    
    // 启动调试服务
    await this.executeCommand(`hdc shell am start -D -n com.example.app/.MainAbility`)
    
    // 端口转发
    await this.executeCommand(`hdc forward tcp:${this.port} tcp:${this.port}`)
  }

  // 执行命令
  private async executeCommand(command: string): Promise<string> {
    // 执行命令的实现
    return ''
  }

  // 断开连接
  async disconnect(): Promise<void> {
    await this.executeCommand(`hdc disconnect ${this.deviceId}`)
  }
}

6.2 单元测试调试

单元测试是调试的重要辅助手段：

// 单元测试示例
import { describe, it, expect } from '@ohos/hypium'

describe('Calculator', () => {
  it('should add two numbers correctly', () => {
    const calculator = new Calculator()
    const result = calculator.add(2, 3)
    expect(result).assertEqual(5)
  })

  it('should handle negative numbers', () => {
    const calculator = new Calculator()
    const result = calculator.add(-2, 3)
    expect(result).assertEqual(1)
  })

  it('should throw error for invalid input', () => {
    const calculator = new Calculator()
    expect(() => calculator.add(2, NaN)).assertThrow('Invalid input')
  })
})

class Calculator {
  add(a: number, b: number): number {
    if (isNaN(a) || isNaN(b)) {
      throw new Error('Invalid input')
    }
    return a + b
  }
}

6.3 性能调优调试

性能调优需要结合多种调试手段：

// 性能调优调试器
class PerformanceDebugger {
  private baseline: Map<string, number> = new Map()

  // 记录基准性能
  recordBaseline(name: string, duration: number): void {
    this.baseline.set(name, duration)
  }

  // 比较性能
  comparePerformance(name: string, currentDuration: number): PerformanceComparison {
    const baselineDuration = this.baseline.get(name)
    
    if (!baselineDuration) {
      return { status: 'unknown', improvement: 0 }
    }

    const improvement = ((baselineDuration - currentDuration) / baselineDuration) * 100

    return {
      status: improvement > 0 ? 'improved' : 'degraded',
      improvement
    }
  }

  // 生成性能报告
  generateReport(): PerformanceReport {
    const report: PerformanceReport = {
      tests: [],
      summary: {
        totalTests: this.baseline.size,
        improved: 0,
        degraded: 0,
        unchanged: 0
      }
    }

    for (const [name, baselineDuration] of this.baseline) {
      // 假设当前性能数据
      const currentDuration = baselineDuration * (0.8 + Math.random() * 0.4)
      const comparison = this.comparePerformance(name, currentDuration)

      report.tests.push({
        name,
        baselineDuration,
        currentDuration,
        improvement: comparison.improvement,
        status: comparison.status
      })

      if (comparison.status === 'improved') {
        report.summary.improved++
      } else if (comparison.status === 'degraded') {
        report.summary.degraded++
      } else {
        report.summary.unchanged++
      }
    }

    return report
  }
}

interface PerformanceComparison {
  status: 'improved' | 'degraded' | 'unknown'
  improvement: number
}

interface PerformanceReport {
  tests: PerformanceTest[]
  summary: {
    totalTests: number
    improved: number
    degraded: number
    unchanged: number
  }
}

interface PerformanceTest {
  name: string
  baselineDuration: number
  currentDuration: number
  improvement: number
  status: string
}

七、常见问题与解决

问题现象原因解决方案
断点不生效代码未暂停编译优化关闭优化、使用debug模式
日志输出不全日志被截断缓冲区限制增加缓冲区大小、使用文件日志
性能分析卡顿分析过程卡顿采样频率过高降低采样频率、减少采样点
内存泄漏检测不到泄漏未被检测检测粒度不够增加采样频率、使用更精确的检测
真机调试失败无法连接真机驱动问题检查驱动、重启设备、检查USB连接
断点进入死循环程序卡死条件断点设置错误检查条件表达式、使用日志断点

七、结语：调试是开发的"必修课"

调试是开发的"必修课"，掌握高效的调试技巧可以：

  • 节省时间：快速定位问题，减少无效排查
  • 提高质量：深入理解代码，发现潜在问题
  • 优化性能：找到性能瓶颈，提升应用体验
  • 增强信心：确保代码的正确性和稳定性

作为一名讲师，我在课上常说：**"调试不是能力问题，而是方法问题。掌握正确的调试方法，可以事半功倍。"**

转载自：https://blog.csdn.net/u014727709/article/details/165008439
欢迎 👍点赞✍评论⭐收藏，欢迎指正

Logo
HarmonyOS开发者社区

讨论HarmonyOS开发技术，专注于API与组件、DevEco Studio、测试、元服务和应用上架分发等。

更多推荐

cover

ToDesk鸿蒙v4.8.1.0首发实测：大屏远控+互动板块+手势指南+实时响应，四项升级值不值？

avatar HarmonyOS开发者社区
cover

HarmonyOS 7 ContainerReader 实战：组件为什么也需要自己的响应式断点【鸿蒙心迹】

avatar HarmonyOS开发者社区
cover

HarmonyOS 7 长列表组件复用：从 @ReusableV2 到全局复用池【鸿蒙心迹】

avatar HarmonyOS开发者社区