Vite 生产环境的代码分割策略：动态 import、分包配置与预加载优化的全链路拆解

一、为什么 Vite 默认的代码分割不够用

Vite 基于 Rollup 的生产构建，默认的代码分割策略是：所有dynamic import()语句自动生成独立 chunk。这个策略在小型项目中够用，但在两个场景下暴露缺陷。

第一，共享依赖的重复打包。假设页面 A 和页面 B 都动态 import 了 lodash-es 的debounce。默认策略下，lodash-es 的 debounce 及其依赖链会被同时打入页面 A 和页面 B 的 chunk，造成冗余。更严重的是，如果页面 C 也静态引用了 lodash-es，那么 debounce 会出现三次——两次在动态 chunk 中，一次在主 bundle 中。

第二，首次加载的水合成本。Vite 默认不做 chunk 预加载。当用户从首页导航到页面 A 时，浏览器需要先下载页面 A 的 chunk，然后发现这个 chunk 依赖了 lodash-es chunk，再发起第二次请求。串行下载在 HTTP/2 环境下浪费了多路复用的能力。

这两个问题的解决方案不是"手动写更多 dynamic import"，而是从分包策略和预加载机制两个维度系统性优化。

二、动态 import 与手动分包的分界线

动态 import 是代码分割的触发机制，但它不是分包策略本身。分包策略决定的是"哪些模块应该打包在一起"，而不是"哪些模块应该懒加载"。

一个常见的误用：为了把某个大模块从主 bundle 中拆出来，手动将其改为 dynamic import。比如将import { Chart } from 'chart.js'改为const { Chart } = await import('chart.js')。这确实减小了主 bundle 体积，但如果 Chart 组件在首页就需要展示，dynamic import 反而增加了首屏的串行请求开销。

正确思路：dynamic import 用于路由级别的懒加载，分包配置用于依赖级别的聚合。

flowchart TB A[源码模块] --> B{是否有 dynamic import?} B -->|是| C[自动分割为独立 chunk] B -->|否| D[进入主 bundle 或共享 chunk] C --> E[依赖模块如何分配?] E --> F[手动分包策略: manualChunks] D --> F F --> G[产出 chunk 集合] G --> H[预加载优化: preload]

// vite.config.ts — 手动分包配置 import { defineConfig } from 'vite'; export default defineConfig({ build: { rollupOptions: { output: { manualChunks(id, { getModuleInfo }) { // 策略一：大型第三方库独立分包 // 避免 lodash/chart.js/moment 等混入业务 chunk if (id.includes('node_modules/lodash-es')) { return 'vendor-lodash'; } if (id.includes('node_modules/chart.js')) { return 'vendor-chart'; } // 策略二：高频共享依赖聚合为单个 chunk // react/react-dom/vue 等框架核心几乎被所有页面使用 if (id.includes('node_modules/react') || id.includes('node_modules/react-dom')) { return 'vendor-react'; } // 策略三：业务模块按功能域分包 // 同一个业务域的模块打包在一起，减少跨 chunk 依赖 const moduleInfo = getModuleInfo(id); if (moduleInfo?.importers.length > 2) { // 被 2 个以上模块引用的公共业务模块，独立分包 const match = id.match(/src\/(\w+)\/(.+)\.(ts|tsx)$/); if (match) { return `biz-${match[1]}`; } } }, }, }, }, });

手动分包需要遵守三个原则：

原则一：分包粒度不是越小越好。每个 chunk 都是一组 HTTP 请求和解析成本。超过 20 个独立 chunk 时，浏览器并行下载的边际收益递减。目标是将 chunk 数量控制在 10-15 个，每个 chunk 大小在 50-150KB 之间（gzip 前）。

原则二：共享依赖必须集中到一个 chunk。如果模块 X 被 chunk A 和 chunk B 同时引用，X 应该独立为一个 chunk，而不是复制到 A 和 B 中。Rollup 的manualChunks默认就是这样工作的——如果一个模块被分配到某个 chunk，所有引用它的 chunk 都会通过 import 关联到这个 chunk。

原则三：路由 chunk 不要包含共享依赖。路由级别的 dynamic import chunk 应该只包含该路由的页面逻辑，依赖通过 import 声明指向已分包的 vendor chunk。这样路由 chunk 的体积最小，加载速度最快。

三、分包配置的依赖图分析与冲突排查

手动分包最棘手的问题：循环依赖导致的 chunk 分配冲突。当模块 A 被分配到 chunk-X，但 A 的某个依赖 B 被分配到 chunk-Y，而 B 又反向依赖 A 时，Rollup 无法确定 A 应该在哪个 chunk 中。

// 依赖图分析工具：检测分包配置中的循环依赖 interface ChunkAssignment { moduleId: string; chunkName: string; } function detectChunkConflicts( assignments: ChunkAssignment[], moduleGraph: ModuleGraph ): ConflictReport[] { const conflicts: ConflictReport[] = []; for (const assignment of assignments) { const deps = moduleGraph.getDependencies(assignment.moduleId); for (const dep of deps) { const depAssignment = assignments.find(a => a.moduleId === dep.id); if (!depAssignment) continue; // 检测：A 在 chunk-X，B 在 chunk-Y，B 依赖 A // 这本身不是冲突，但需要确保 B 的 chunk 能 import A 的 chunk if (depAssignment.chunkName !== assignment.chunkName) { // 检查是否存在反向依赖（循环） const reverseDeps = moduleGraph.getDependencies(dep.id); const hasReverseDependency = reverseDeps.some( rd => rd.id === assignment.moduleId ); if (hasReverseDependency) { conflicts.push({ type: 'circular_cross_chunk', moduleA: assignment.moduleId, chunkA: assignment.chunkName, moduleB: dep.id, chunkB: depAssignment.chunkName, message: `循环跨 chunk 依赖: ${assignment.chunkName} <-> ${depAssignment.chunkName}`, }); } } } } return conflicts; }

解决循环跨 chunk 依赖的方法：将冲突的两个模块合并到同一个 chunk，或者将它们之间的共享部分提取为第三个 chunk。

// 冲突解决策略：将循环依赖的模块合并到同一个 chunk function resolveCircularConflict( conflict: ConflictReport, assignments: ChunkAssignment[] ): ChunkAssignment[] { const updated = [...assignments]; // 策略：将 moduleB 合入 moduleA 的 chunk // 或将两者都合入一个新的专用 chunk const mergedChunk = `${conflict.chunkA}-${conflict.chunkB}-shared`; for (const a of updated) { if (a.moduleId === conflict.moduleA || a.moduleId === conflict.moduleB) { a.chunkName = mergedChunk; } } return updated; }

依赖图分析应该在开发阶段就做，而不是等到构建报错才发现。一个实用的做法：在 CI pipeline 中加入构建产物分析步骤，检查 chunk 间的依赖关系是否符合预期。

四、预加载优化：从串行请求到并行水合

分包解决了模块归属问题，但没解决加载时序问题。Vite 默认不做 chunk 预加载——浏览器只有在执行到 dynamic import 语句时，才发起 chunk 下载。这导致路由切换时的串行加载链路：用户点击 → 触发 dynamic import → 下载路由 chunk → 发现依赖 → 下载 vendor chunk → 渲染。

预加载的核心思路：在用户可能导航到某个路由之前，提前下载该路由的 chunk 及其依赖链。

sequenceDiagram participant U as 用户 participant P as 预加载器 participant B as 浏览器 U->>P: 首页加载完成 P->>P: 分析路由依赖图 P->>B: <link rel="modulepreload"> 路由 A 的 chunk P->>B: <link rel="modulepreload"> vendor-react chunk P->>B: <link rel="modulepreload"> vendor-lodash chunk Note over B: 所有 chunk 已缓存 U->>P: 点击导航到路由 A P->>B: dynamic import(routeA) B->>B: chunk 已缓存, 无需网络请求 B->>U: 立即渲染

Vite 提供了modulePreload配置选项，但它的默认行为只预加载直接依赖。要实现完整的依赖链预加载，需要自定义resolveDependencies函数：

// vite.config.ts — 依赖链预加载配置 export default defineConfig({ build: { modulePreload: { // 自定义预加载依赖解析 // 返回当前 chunk 的所有依赖 chunk 路径 resolveDependencies(filename, deps, { getModuleInfo }) { // 过滤掉不需要预加载的巨型 chunk const filteredDeps = deps.filter(dep => { const info = getModuleInfo(dep); // 大于 200KB 的 chunk 不预加载，避免占用首页带宽 if (info?.code?.length > 200 * 1024) { return false; } return true; }); // 递归收集依赖链中的间接依赖 const allDeps = new Set<string>(); for (const dep of filteredDeps) { collectDepsRecursive(dep, getModuleInfo, allDeps, 3); // 最多递归 3 层 } return [...allDeps]; }, }, }, }); /** * 递归收集模块依赖链 * @param moduleId - 起始模块 ID * @param getModuleInfo - Rollup 模块信息获取函数 * @param collected - 已收集的依赖集合 * @param maxDepth - 最大递归深度，防止无限递归 */ function collectDepsRecursive( moduleId: string, getModuleInfo: (id: string) => ModuleInfo | null, collected: Set<string>, maxDepth: number ): void { if (maxDepth <= 0 || collected.has(moduleId)) return; const info = getModuleInfo(moduleId); if (!info) return; const dynamicDeps = info.dynamicDependencies; for (const dep of dynamicDeps) { collected.add(dep); collectDepsRecursive(dep, getModuleInfo, collected, maxDepth - 1); } }

更激进的做法：在路由配置层面声明预加载策略，结合用户行为预测提前触发下载。

// 路由级预加载策略：基于用户行为概率预加载 interface RoutePreloadConfig { route: string; // 该路由 chunk 的依赖列表 chunks: string[]; // 预加载触发条件 trigger: 'hover' | 'viewport' | 'mount' | 'idle'; } const preloadConfigs: RoutePreloadConfig[] = [ { route: '/dashboard', chunks: ['route-dashboard', 'vendor-chart', 'vendor-lodash'], trigger: 'hover', // 用户 hover 导航链接时预加载 }, { route: '/settings', chunks: ['route-settings', 'vendor-react'], trigger: 'idle', // 空闲时预加载（优先级最低） }, ]; // 预加载执行器：根据触发条件加载 chunk class ChunkPreloader { private loadedChunks = new Set<string>(); /** * 按触发条件执行预加载 * hover: 用户 hover 时立即加载 * idle: requestIdleCallback 中加载 * viewport: IntersectionObserver 触发 */ preload(config: RoutePreloadConfig): void { const unloadedChunks = config.chunks.filter(c => !this.loadedChunks.has(c)); switch (config.trigger) { case 'hover': // 立即发起预加载 this.loadChunks(unloadedChunks); break; case 'idle': // 空闲时预加载，不抢占主线程 requestIdleCallback(() => this.loadChunks(unloadedChunks)); break; case 'viewport': // 当预加载触发元素进入可视区域时加载 this.observeViewport(config.route, unloadedChunks); break; default: // mount: 组件挂载后立即加载 this.loadChunks(unloadedChunks); } } private async loadChunks(chunks: string[]): Promise<void> { for (const chunk of chunks) { try { await import(/* @vite-ignore */ `/assets/${chunk}.js`); this.loadedChunks.add(chunk); } catch (error) { // 预加载失败不影响正常功能 // 正常导航时的 dynamic import 会重新尝试加载 console.warn(`预加载 chunk 失败: ${chunk}`, error); } } } }

五、总结

Vite 生产构建的代码分割是一个三层策略：触发层、归属层、时序层。

触发层由 dynamic import 控制，决定模块是否懒加载。归属层由manualChunks配置控制，决定模块打包在哪个 chunk 中。时序层由预加载机制控制，决定 chunk 在什么时候被下载。

三层策略的常见错误都是因为只关注了某一层而忽视其他。只用 dynamic import 拆分，忽视分包配置——导致共享依赖冗余和 chunk 碎片化。只调 manualChunks，忽视预加载——导致路由切换的串行请求延迟。只做预加载，忽视依赖链完整性——预加载的 chunk 缺少依赖 chunk，实际导航时仍然串行。

正确的做法是三层联动：先通过依赖图分析确定分包方案，确保共享依赖集中、无循环冲突；然后为每个路由 chunk 配置完整的依赖链预加载；最后用构建产物分析工具验证 chunk 体积、数量和依赖关系是否符合预期。代码分割不是"拆得越碎越好"，而是"在控制 chunk 数量的前提下，最大化缓存命中率与最小化首次加载成本"。