HarmonyOS开发：大对象处理与大文件内存优化

📌 核心要点：掌握大对象分块处理、流式读取、内存映射三大核心技术，避免大文件全量加载导致的内存暴涨，让你的应用在处理GB级数据时依然稳如泰山。

一、背景与动机

想象一下这个场景：你的应用需要展示一份100MB的高清地图数据，或者处理一段500MB的视频文件。如果你选择"一把梭"——把整个文件读进内存，结果会怎样？在2GB内存的入门设备上，应用直接OOM崩溃；在4GB的中端设备上，系统开始疯狂GC，UI卡成PPT；即使在8GB的旗舰设备上，内存占用也居高不下，用户切换应用时被系统杀掉的概率大幅增加。

这不是危言耸听，而是每天都在真实发生的事情。在HarmonyOS的生态中，设备内存从手表的512MB到平板的16GB，跨度高达32倍。如果你的代码习惯性地全量加载大对象，那么在低端设备上就是"定时炸弹"。

大对象处理的核心矛盾在于：用户想要完整的功能体验，但设备给不了无限的内存。解决这个矛盾的关键思路有三个：

1. 分而治之：把大对象拆成小块，按需加载，用完即释
2. 流式处理：像水管一样，数据流过内存但不蓄积
3. 映射而非拷贝：让操作系统帮你管理，数据只在需要时才真正加载到内存

接下来，让我们逐一攻克这些技术。

二、核心原理

2.1 大对象对内存的影响

flowchart TD
    A[大对象加载方式] --> B[全量加载]
    A --> C[分块加载]
    A --> D[流式处理]
    A --> E[内存映射]

    B --> B1[内存占用 = 文件大小]
    B --> B2[GC压力极大]
    B --> B3[低端设备OOM]

    C --> C1[内存占用 = 块大小]
    C --> C2[按需加载按需释放]
    C --> C3[适合随机访问场景]

    D --> D1[内存占用 ≈ 缓冲区大小]
    D --> D2[数据流过不蓄积]
    D --> D3[适合顺序处理场景]

    E --> E1[内存占用由OS管理]
    E --> E2[懒加载按页映射]
    E --> E3[适合大文件随机读写]

    classDef rootStyle fill:#FF8A65,stroke:#D84315,stroke-width:3px,color:#000
    classDef badStyle fill:#EF9A9A,stroke:#C62828,stroke-width:2px,color:#000
    classDef goodStyle fill:#A5D6A7,stroke:#2E7D32,stroke-width:2px,color:#000

    class A rootStyle
    class B,B1,B2,B3 badStyle
    class C,C1,C2,C3,D,D1,D2,D3,E,E1,E2,E3 goodStyle

2.2 大文件处理策略选择

flowchart LR
    START[大文件处理需求] --> Q1{访问模式?}
    Q1 -->|顺序读取| STREAM[流式处理]
    Q1 -->|随机访问| Q2{文件大小?}
    Q1 -->|混合访问| MMAP[内存映射]

    Q2 -->|< 100MB| CHUNK[分块加载]
    Q2 -->|≥ 100MB| MMAP

    STREAM --> R1[✅ 内存恒定]
    CHUNK --> R2[✅ 按需加载]
    MMAP --> R3[✅ OS自动管理]

    classDef decisionStyle fill:#FFF176,stroke:#F9A825,stroke-width:2px,color:#000
    classDef resultStyle fill:#81D4FA,stroke:#0277BD,stroke-width:2px,color:#000
    classDef methodStyle fill:#CE93D8,stroke:#7B1FA2,stroke-width:2px,color:#000

    class Q1,Q2 decisionStyle
    class R1,R2,R3 resultStyle
    class STREAM,CHUNK,MMAP methodStyle

选择处理策略的关键在于理解你的访问模式。如果是逐行解析日志文件，流式处理最合适；如果需要跳转到文件的任意位置读取数据，分块加载或内存映射更优。选错策略，就像用筷子喝汤——不是不行，但效率堪忧。

三、代码实战

3.1 基础：大文件分块读取

分块读取是最直观的大文件处理方式：把大文件切成固定大小的块，每次只加载当前需要的块到内存中。

import { fileIo as fs } from '@kit.CoreFileKit';

// 大文件分块读取器
class ChunkFileReader {
  private filePath: string;          // 文件路径
  private fileSize: number;          // 文件总大小
  private chunkSize: number;         // 每块大小
  private totalChunks: number;       // 总块数
  private currentChunk: number = 0;  // 当前读取位置
  private fileFd: number = -1;       // 文件描述符

  constructor(filePath: string, chunkSizeKB: number = 256) {
    this.filePath = filePath;
    this.chunkSize = chunkSizeKB * 1024;  // KB转字节

    // 获取文件信息
    const stat = fs.statSync(filePath);
    this.fileSize = stat.size;
    this.totalChunks = Math.ceil(this.fileSize / this.chunkSize);

    console.info(`[ChunkReader] 文件大小: ${this.formatSize(this.fileSize)}, ` +
      `块大小: ${this.formatSize(this.chunkSize)}, 总块数: ${this.totalChunks}`);
  }

  // 打开文件
  open(): boolean {
    try {
      this.fileFd = fs.openSync(this.filePath, fs.OpenMode.READ_ONLY).fd;
      this.currentChunk = 0;
      console.info('[ChunkReader] 文件已打开');
      return true;
    } catch (err) {
      console.error(`[ChunkReader] 打开文件失败: ${JSON.stringify(err)}`);
      return false;
    }
  }

  // 读取指定块的数据
  readChunk(chunkIndex: number): ArrayBuffer | undefined {
    if (chunkIndex < 0 || chunkIndex >= this.totalChunks) {
      console.error(`[ChunkReader] 块索引越界: ${chunkIndex}/${this.totalChunks}`);
      return undefined;
    }

    try {
      // 计算当前块的偏移量和实际读取长度
      const offset = chunkIndex * this.chunkSize;
      const readLength = Math.min(this.chunkSize, this.fileSize - offset);
      const buffer = new ArrayBuffer(readLength);

      // 从指定位置读取数据
      fs.readSync(this.fileFd, buffer, { offset: 0, length: readLength, position: offset });
      this.currentChunk = chunkIndex;

      console.info(`[ChunkReader] 读取块 ${chunkIndex}: ` +
        `偏移=${offset}, 长度=${this.formatSize(readLength)}`);
      return buffer;
    } catch (err) {
      console.error(`[ChunkReader] 读取块失败: ${JSON.stringify(err)}`);
      return undefined;
    }
  }

  // 读取下一块
  readNext(): ArrayBuffer | undefined {
    if (this.currentChunk >= this.totalChunks - 1) {
      console.info('[ChunkReader] 已到达文件末尾');
      return undefined;
    }
    return this.readChunk(this.currentChunk + 1);
  }

  // 获取读取进度
  getProgress(): number {
    return this.currentChunk / this.totalChunks;
  }

  // 关闭文件
  close(): void {
    if (this.fileFd !== -1) {
      fs.closeSync(this.fileFd);
      this.fileFd = -1;
      console.info('[ChunkReader] 文件已关闭');
    }
  }

  // 格式化文件大小
  private formatSize(bytes: number): string {
    if (bytes < 1024) return `${bytes}B`;
    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
  }
}

3.2 进阶：流式处理避免全量加载

流式处理是处理大文件最"优雅"的方式——数据像流水一样经过处理管道，不会在内存中堆积。特别适合日志解析、CSV处理、JSON流式解析等场景。

import { fileIo as fs } from '@kit.CoreFileKit';

// 流式文件处理器
class StreamFileProcessor {
  private filePath: string;
  private bufferSize: number;  // 缓冲区大小

  constructor(filePath: string, bufferSizeKB: number = 64) {
    this.filePath = filePath;
    this.bufferSize = bufferSizeKB * 1024;
  }

  // 流式逐行处理文本文件
  async processByLine(
    lineHandler: (line: string, lineNumber: number) => boolean  // 返回false停止处理
  ): Promise<{ totalLines: number; processedLines: number }> {
    let totalLines = 0;
    let processedLines = 0;
    let remainder = '';  // 缓冲区末尾可能是不完整的行

    const file = fs.openSync(this.filePath, fs.OpenMode.READ_ONLY);
    const buffer = new ArrayBuffer(this.bufferSize);

    try {
      let bytesRead: number;
      let position = 0;

      while (true) {
        // 读取一块数据
        bytesRead = fs.readSync(file.fd, buffer, {
          offset: 0,
          length: this.bufferSize,
          position: position
        });

        if (bytesRead === 0) break;  // 文件读取完毕

        position += bytesRead;

        // 将缓冲区转为字符串，拼接上一次的剩余部分
        const chunk = remainder + String.fromCharCode(...new Uint8Array(buffer, 0, bytesRead));

        // 按行分割
        const lines = chunk.split('\n');

        // 最后一个元素可能是不完整的行，留到下次处理
        remainder = lines.pop() ?? '';

        // 逐行处理
        for (const line of lines) {
          totalLines++;
          const shouldContinue = lineHandler(line.trim(), totalLines);
          if (shouldContinue) {
            processedLines++;
          } else {
            // 处理器要求停止
            console.info(`[StreamProcessor] 在第${totalLines}行停止处理`);
            return { totalLines, processedLines };
          }
        }
      }

      // 处理最后的剩余行
      if (remainder.trim().length > 0) {
        totalLines++;
        lineHandler(remainder.trim(), totalLines);
        processedLines++;
      }

      console.info(`[StreamProcessor] 处理完成: 总行数=${totalLines}, 已处理=${processedLines}`);
      return { totalLines, processedLines };
    } finally {
      fs.closeSync(file.fd);
    }
  }

  // 流式处理二进制数据（适合音视频文件）
  async processBinaryChunks(
    chunkHandler: (chunk: ArrayBuffer, offset: number, totalSize: number) => boolean
  ): Promise<boolean> {
    const stat = fs.statSync(this.filePath);
    const totalSize = stat.size;
    const file = fs.openSync(this.filePath, fs.OpenMode.READ_ONLY);
    const buffer = new ArrayBuffer(this.bufferSize);

    try {
      let offset = 0;

      while (offset < totalSize) {
        const readLength = Math.min(this.bufferSize, totalSize - offset);
        const bytesRead = fs.readSync(file.fd, buffer, {
          offset: 0,
          length: readLength,
          position: offset
        });

        if (bytesRead === 0) break;

        // 只传递实际读取的数据
        const actualChunk = buffer.slice(0, bytesRead);
        const shouldContinue = chunkHandler(actualChunk, offset, totalSize);

        if (!shouldContinue) {
          console.info(`[StreamProcessor] 在偏移${offset}处停止处理`);
          return false;
        }

        offset += bytesRead;
      }

      return true;
    } finally {
      fs.closeSync(file.fd);
    }
  }
}

3.3 进阶：大文件下载优化

大文件下载如果不做优化，不仅内存暴涨，还可能因为网络中断导致前功尽弃。断点续传和分片下载是两大核心优化手段。

import { http } from '@kit.NetworkKit';
import { fileIo as fs } from '@kit.CoreFileKit';

// 大文件下载器（支持断点续传）
class LargeFileDownloader {
  private savePath: string;            // 保存路径
  private chunkSize: number;           // 分片大小
  private onProgress?: (percent: number) => void;  // 进度回调

  constructor(savePath: string, chunkSizeMB: number = 4) {
    this.savePath = savePath;
    this.chunkSize = chunkSizeMB * 1024 * 1024;  // MB转字节
  }

  // 设置进度回调
  setProgressCallback(callback: (percent: number) => void): void {
    this.onProgress = callback;
  }

  // 下载大文件（支持断点续传）
  async download(url: string): Promise<boolean> {
    try {
      // 第一步：获取文件总大小
      const headResponse = await http.createHttp().request(url, {
        method: http.RequestMethod.HEAD  // 只获取头信息
      });

      const totalSize = parseInt(headResponse.header['content-length'] ?? '0');
      if (totalSize === 0) {
        console.error('[Downloader] 无法获取文件大小');
        return false;
      }

      // 第二步：检查已下载的进度（断点续传）
      let downloadedSize = 0;
      if (fs.accessSync(this.savePath)) {
        const stat = fs.statSync(this.savePath);
        downloadedSize = stat.size;
        console.info(`[Downloader] 断点续传: 已下载 ${this.formatSize(downloadedSize)}`);
      }

      if (downloadedSize >= totalSize) {
        console.info('[Downloader] 文件已下载完成');
        return true;
      }

      // 第三步：创建/追加写入文件
      const file = fs.openSync(this.savePath,
        fs.OpenMode.WRITE_ONLY | fs.OpenMode.CREATE | fs.OpenMode.APPEND);

      try {
        // 第四步：分片下载
        while (downloadedSize < totalSize) {
          const start = downloadedSize;
          const end = Math.min(start + this.chunkSize - 1, totalSize - 1);

          // 使用Range头请求指定范围的数据
          const response = await http.createHttp().request(url, {
            method: http.RequestMethod.GET,
            header: { 'Range': `bytes=${start}-${end}` }
          });

          if (response.responseCode === 206 || response.responseCode === 200) {
            const chunkData = response.result as ArrayBuffer;
            fs.writeSync(file.fd, chunkData);
            downloadedSize += chunkData.byteLength;

            // 更新进度
            const percent = (downloadedSize / totalSize) * 100;
            this.onProgress?.(percent);
            console.info(`[Downloader] 进度: ${percent.toFixed(1)}% ` +
              `(${this.formatSize(downloadedSize)}/${this.formatSize(totalSize)})`);
          } else {
            console.error(`[Downloader] 下载失败: HTTP ${response.responseCode}`);
            return false;
          }
        }

        console.info('[Downloader] 下载完成');
        return true;
      } finally {
        fs.closeSync(file.fd);
      }
    } catch (err) {
      console.error(`[Downloader] 下载异常: ${JSON.stringify(err)}`);
      return false;
    }
  }

  private formatSize(bytes: number): string {
    if (bytes < 1024) return `${bytes}B`;
    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
  }
}

3.4 完整：大对象处理实战——地图数据加载器

将分块读取和流式处理结合，实现一个地图数据按需加载器，只在可视区域内加载对应的地图块。

import { fileIo as fs } from '@kit.CoreFileKit';

// 地图块定义
interface MapTile {
  x: number;               // 块X坐标
  y: number;               // 块Y坐标
  zoom: number;            // 缩放级别
  data: ArrayBuffer;       // 块数据
  lastAccess: number;      // 最后访问时间
}

// 地图数据加载器（按需加载 + LRU淘汰）
class MapDataLoader {
  private dataPath: string;                        // 地图数据文件路径
  private tileCache: Map<string, MapTile>;          // 块缓存
  private maxCacheTiles: number;                    // 最大缓存块数
  private tileSize: number;                         // 每块数据大小

  constructor(dataPath: string, maxCacheTiles: number = 20) {
    this.dataPath = dataPath;
    this.tileCache = new Map();
    this.maxCacheTiles = maxCacheTiles;
    this.tileSize = 256 * 1024;  // 每块256KB
  }

  // 加载指定区域的地图块
  loadTile(x: number, y: number, zoom: number): MapTile | undefined {
    const key = `${zoom}_${x}_${y}`;

    // 缓存命中
    const cached = this.tileCache.get(key);
    if (cached) {
      cached.lastAccess = Date.now();
      console.info(`[MapLoader] 缓存命中: ${key}`);
      return cached;
    }

    // 缓存未命中，从文件加载
    try {
      const offset = this.calculateOffset(x, y, zoom);
      const file = fs.openSync(this.dataPath, fs.OpenMode.READ_ONLY);
      const buffer = new ArrayBuffer(this.tileSize);

      fs.readSync(file.fd, buffer, {
        offset: 0,
        length: this.tileSize,
        position: offset
      });
      fs.closeSync(file.fd);

      // 检查缓存容量，淘汰旧块
      if (this.tileCache.size >= this.maxCacheTiles) {
        this.evictOldest();
      }

      // 创建新的缓存块
      const tile: MapTile = {
        x, y, zoom,
        data: buffer,
        lastAccess: Date.now()
      };
      this.tileCache.set(key, tile);

      console.info(`[MapLoader] 加载块: ${key}, 缓存数: ${this.tileCache.size}`);
      return tile;
    } catch (err) {
      console.error(`[MapLoader] 加载块失败: ${JSON.stringify(err)}`);
      return undefined;
    }
  }

  // 加载可视区域的所有块
  loadVisibleArea(
    minX: number, maxX: number,
    minY: number, maxY: number,
    zoom: number
  ): MapTile[] {
    const tiles: MapTile[] = [];

    for (let x = minX; x <= maxX; x++) {
      for (let y = minY; y <= maxY; y++) {
        const tile = this.loadTile(x, y, zoom);
        if (tile) {
          tiles.push(tile);
        }
      }
    }

    console.info(`[MapLoader] 加载可视区域: ` +
      `(${minX},${minY})-(${maxX},${maxY}), 块数=${tiles.length}`);
    return tiles;
  }

  // 计算块在文件中的偏移量
  private calculateOffset(x: number, y: number, zoom: number): number {
    // 简化的偏移计算：按zoom层级 + x + y线性排列
    const tilesPerZoom = Math.pow(2, zoom) * Math.pow(2, zoom);
    let offset = 0;
    for (let z = 0; z < zoom; z++) {
      offset += tilesPerZoom * this.tileSize / Math.pow(4, zoom - z);
    }
    const tilesInRow = Math.pow(2, zoom);
    offset += (y * tilesInRow + x) * this.tileSize;
    return offset;
  }

  // 淘汰最久未访问的块
  private evictOldest(): void {
    let oldestKey = '';
    let oldestTime = Infinity;

    this.tileCache.forEach((tile, key) => {
      if (tile.lastAccess < oldestTime) {
        oldestTime = tile.lastAccess;
        oldestKey = key;
      }
    });

    if (oldestKey) {
      this.tileCache.delete(oldestKey);
      console.info(`[MapLoader] 淘汰旧块: ${oldestKey}`);
    }
  }

  // 释放所有缓存
  releaseAll(): void {
    this.tileCache.clear();
    console.info('[MapLoader] 已释放所有缓存块');
  }
}

// UI层使用示例
@Entry
@Component
struct MapDemoPage {
  @State tiles: MapTile[] = [];
  @State memoryUsage: string = '0 KB';
  private mapLoader: MapDataLoader | null = null;

  aboutToAppear(): void {
    const context = getContext(this);
    this.mapLoader = new MapDataLoader(
      `${context.filesDir}/map_data.bin`,
      30  // 最多缓存30块
    );
  }

  build() {
    Column({ space: 16 }) {
      Text('大对象处理演示 - 地图数据加载')
        .fontSize(22)
        .fontWeight(FontWeight.Bold)

      Text(`内存占用: ${this.memoryUsage}`)
        .fontSize(14)
        .fontColor('#666666')

      // 模拟地图区域
      Row({ space: 8 }) {
        Button('加载区域(0,0)-(2,2)')
          .onClick(() => {
            this.tiles = this.mapLoader?.loadVisibleArea(0, 2, 0, 2, 1) ?? [];
            this.updateMemoryUsage();
          })

        Button('加载区域(3,3)-(5,5)')
          .onClick(() => {
            this.tiles = this.mapLoader?.loadVisibleArea(3, 5, 3, 5, 2) ?? [];
            this.updateMemoryUsage();
          })

        Button('释放缓存')
          .onClick(() => {
            this.mapLoader?.releaseAll();
            this.tiles = [];
            this.updateMemoryUsage();
          })
      }

      Text(`当前加载块数: ${this.tiles.length}`)
        .fontSize(14)
    }
    .width('100%')
    .padding(16)
  }

  private updateMemoryUsage(): void {
    const totalBytes = this.tiles.reduce((sum, tile) => sum + tile.data.byteLength, 0);
    this.memoryUsage = totalBytes < 1024 * 1024
      ? `${(totalBytes / 1024).toFixed(1)} KB`
      : `${(totalBytes / (1024 * 1024)).toFixed(1)} MB`;
  }
}

四、踩坑与注意事项

坑点1：ArrayBuffer的slice不是真拷贝

在ArkTS中，ArrayBuffer.slice()返回的是一个新的ArrayBuffer，数据是拷贝的。但如果你使用Uint8Array的subarray()方法，返回的是原缓冲区的视图，两者共享同一块内存。如果你释放了原始ArrayBuffer，subarray创建的视图也会失效。

// ❌ 危险：subarray共享内存
const view = new Uint8Array(buffer).subarray(0, 100);
// 如果buffer被释放，view也会失效

// ✅ 安全：slice创建独立拷贝
const copy = buffer.slice(0, 100);

坑点2：文件描述符泄漏

每次fs.openSync()都会占用一个文件描述符，系统对单个进程的文件描述符数量有限制（通常1024个）。如果在大文件处理循环中忘记关闭文件描述符，很快就会达到上限，导致后续所有文件操作失败。

最佳实践：始终使用try-finally确保文件关闭，或者使用fs.readSync的position参数避免反复打开文件。

坑点3：流式处理中的字符编码问题

当缓冲区边界恰好切断了多字节字符（如中文UTF-8编码占3字节）时，直接按字节分割会导致乱码。必须在缓冲区末尾找到最后一个完整的行分隔符或字符边界。

// ❌ 错误：直接按字节分割可能切断多字节字符
const text = buffer.toString();

// ✅ 正确：按行分隔符分割，保留不完整的末尾
const lines = text.split('\n');
remainder = lines.pop() ?? '';  // 最后一行可能不完整

坑点4：大文件下载时Range头不被服务器支持

并非所有服务器都支持Range请求头。如果服务器返回200而非206，说明它忽略了Range头，返回了完整文件。此时需要判断响应码，并回退到普通下载模式。

if (response.responseCode === 206) {
  // 服务器支持断点续传，处理部分内容
} else if (response.responseCode === 200) {
  // 服务器不支持断点续传，从头下载
  console.warn('[Downloader] 服务器不支持断点续传');
}

坑点5：分块大小选择不当

分块太小（如4KB），会导致频繁的IO操作，磁盘寻道开销大；分块太大（如64MB），又失去了分块的意义。经验值：

• 顺序读取：64KB-256KB（与磁盘预读策略匹配）
• 随机访问：4KB-16KB（与系统页面大小匹配）
• 网络下载：2MB-8MB（平衡网络延迟和内存占用）

坑点6：内存映射在32位进程中的地址空间限制

32位进程的虚拟地址空间只有4GB，可用用户空间通常只有2-3GB。如果映射的文件超过这个大小，会映射失败。虽然HarmonyOS应用都是64位进程，但在模拟器上调试时可能遇到此问题。

坑点7：大对象在GC中的"停顿"问题

即使你及时释放了大对象的引用，GC回收大块内存时也可能造成明显的UI停顿。建议在空闲时段主动触发GC（如果平台支持），或者将大对象的生命周期与应用关键路径错开。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. 文件IO性能优化：HarmonyOS 6对fs.readSync的随机读取性能做了显著优化，小分块随机读取的延迟降低约40%
2. ArrayBuffer上限调整：单个ArrayBuffer的最大大小从1GB提升至2GB（64位进程）
3. 网络下载超时策略：默认连接超时从30秒调整为60秒，读取超时从60秒调整为120秒，更适合大文件下载场景

适配代码

// HarmonyOS 6 流式读取适配
async function streamReadFile(filePath: string): Promise<void> {
  try {
    // HarmonyOS 6 新增的流式读取API
    const stream = fs.createReadStream(filePath, {
      highWaterMark: 64 * 1024  // 64KB缓冲区
    });

    stream.on('data', (chunk: ArrayBuffer) => {
      // 处理每个数据块
      console.info(`[Stream] 接收数据块: ${chunk.byteLength} bytes`);
    });

    stream.on('end', () => {
      console.info('[Stream] 读取完成');
    });

    stream.on('error', (err: Error) => {
      console.error(`[Stream] 读取错误: ${err.message}`);
    });

  } catch (err) {
    // 降级：使用传统分块读取
    console.warn('[Stream] 流式API不可用，降级为分块读取');
    const reader = new ChunkFileReader(filePath, 64);
    reader.open();
    let chunk: ArrayBuffer | undefined;
    while ((chunk = reader.readNext()) !== undefined) {
      // 处理每个数据块
    }
    reader.close();
  }
}

// HarmonyOS 6 内存映射适配
async function mmapReadFile(filePath: string, offset: number, length: number): Promise<ArrayBuffer> {
  try {
    // HarmonyOS 6 新增的内存映射API
    const mapped = fs.mmap(filePath, { offset, length, readOnly: true });
    return mapped;
  } catch (err) {
    // 降级：使用普通读取
    console.warn('[Mmap] 内存映射不可用，降级为普通读取');
    const file = fs.openSync(filePath, fs.OpenMode.READ_ONLY);
    const buffer = new ArrayBuffer(length);
    fs.readSync(file.fd, buffer, { offset: 0, length, position: offset });
    fs.closeSync(file.fd);
    return buffer;
  }
}

六、总结

三维度评价表

大对象处理是移动端开发中"看不见的冰山"——用户只看到应用流畅运行，却不知道背后开发者为了那几MB的内存优化做了多少工作。但正是这些看不见的优化，决定了应用在低端设备上是"能用"还是"好用"。

记住三个关键词：分块、流式、按需。不要试图一口吞下大象，把大问题拆成小问题逐个击破，才是工程思维的精髓。在HarmonyOS 6中，流式读取API和内存映射的加入，让大文件处理变得更加优雅，但也不要忘记做好降级适配——毕竟，兼容性才是应用生存的根基。