同样的功能，别人的代码跑1秒，你的要跑10秒？今天带你彻底解决JSA性能问题！

上周帮同事优化一段JSA代码，他处理5万行数据需要3分钟，我优化后只用了8秒。他问我：“你施了什么魔法？”

其实哪有什么魔法，只是掌握了一些JSA性能优化的核心技巧。今天，我把这些技巧整理成10个方法，手把手教你让JSA飞起来！

一、性能瓶颈诊断：先找到“罪魁祸首” #1.1 你的代码慢在哪里？ #

JavaScript

// 性能计时器模板function 性能测试(函数名, 测试函数) { console.time(函数名); 测试函数(); console.timeEnd(函数名);}// 使用示例性能测试("原始代码", () => { // 你的代码...});性能测试("优化代码", () => { // 优化后的代码...});// 输出示例：// 原始代码: 3250ms// 优化代码: 480ms1.2 JSA性能瓶颈排行榜 #

根据实际测试，JSA代码慢的“罪魁祸首”通常是：

频繁读写单元格（占80%的性能问题）循环嵌套（尤其O(n²)复杂度）重复获取对象（每次获取都有开销）屏幕刷新和事件（未关闭时拖慢速度）低效算法（冒泡排序 vs 快速排序）二、10个优化方法，逐个击破 #方法1：数组批量读写代替逐单元格操作（性能提升10-100倍） #

这是最重要的优化技巧，没有之一！

JavaScript

// ❌ 极慢写法：逐单元格操作function 逐单元格处理() { let ws = Application.ActiveSheet; let 最后行 = ws.UsedRange.Rows.Count; for (let i = 1; i <= 最后行; i++) { for (let j = 1; j <= 10; j++) { let cell = ws.Cells(i, j); if (!isNaN(cell.Value2)) { cell.Value2 = cell.Value2 * 1.2; // 每次循环都读写单元格 } } }}// ✅ 极快写法：数组批量处理function 数组批量处理() { let ws = Application.ActiveSheet; let 最后行 = ws.UsedRange.Rows.Count; // 1. 一次性读取到数组（1次IO） let 数据区域 = ws.Range(`A1:J${最后行}`); let 数据 = 数据区域.Value2; // 二维数组 // 2. 在内存中处理数组（0次IO） for (let i = 0; i < 数据.length; i++) { for (let j = 0; j < 数据[i].length; j++) { if (!isNaN(数据[i][j])) { 数据[i][j] *= 1.2; } } } // 3. 一次性写回单元格（1次IO） 数据区域.Value2 = 数据;}// 性能对比测试性能测试("逐单元格", () => { 逐单元格处理(); // 5万行：约15秒});性能测试("数组批量", () => { 数组批量处理(); // 5万行：约0.3秒});

原理说明：Excel/WPS的单元格对象是COM对象，每次读写都有巨大的开销（约0.1-1ms）。而数组操作在内存中进行，速度是纳秒级的。所以把10万次IO变成2次IO，性能自然飞升。

方法2：关闭屏幕刷新和自动计算（性能提升2-5倍） #

JavaScript

// ✅ 优化模板：开关控制function 高性能执行(执行函数) { try { // 关闭屏幕刷新 Application.ScreenUpdating = false; // 关闭自动计算（如果不需要实时公式） Application.Calculation = -4135; // xlCalculationManual // 关闭事件（防止触发Change事件） Application.EnableEvents = false; // 关闭分页显示（可选） ActiveSheet.DisplayPageBreaks = false; // 执行主要逻辑 let 结果 = 执行函数(); return 结果; } finally { // 恢复设置（无论如何都要恢复） Application.ScreenUpdating = true; Application.Calculation = -4105; // xlCalculationAutomatic Application.EnableEvents = true; ActiveSheet.DisplayPageBreaks = true; }}// 使用示例高性能执行(() => { // 你的代码... for (let i = 1; i <= 10000; i++) { // 大量操作 }});

注意事项：

ScreenUpdating一定要成对使用，忘记恢复会导致界面一直卡住如果代码中需要读取公式计算结果，记得先执行Application.Calculate()方法3：缓存对象引用，避免重复获取 #

JavaScript

// ❌ 低效写法：每次循环都获取对象function 低效写法() { for (let i = 1; i <= 10000; i++) { Application.ActiveWorkbook.ActiveSheet.Cells(i, 1).Value2 = i; // 每次都从Application开始层层获取 }}// ✅ 高效写法：缓存对象引用function 高效写法() { let ws = Application.ActiveWorkbook.ActiveSheet; // 只获取一次 for (let i = 1; i <= 10000; i++) { ws.Cells(i, 1).Value2 = i; // 直接使用缓存对象 }}// ✅ 更高效的写法：连Cells都缓存function 更高效写法() { let ws = Application.ActiveWorkbook.ActiveSheet; let cells = ws.Cells; // 缓存Cells集合 for (let i = 1; i <= 10000; i++) { cells(i, 1).Value2 = i; }}

优化原理：每次通过属性访问对象都有开销，缓存对象引用可以减少95%的对象访问次数。

方法4：使用现代JS语法和数据结构 #

JavaScript

// ❌ 低效写法：传统for循环加iffunction 低效过滤(数据) { let 结果 = []; for (let i = 0; i < 数据.length; i++) { if (数据[i] > 100) { 结果.push(数据[i] * 1.2); } } return 结果;}// ✅ 高效写法：使用filter和map（JS引擎优化）function 高效过滤(数据) { return 数据 .filter(item => item > 100) .map(item => item * 1.2);}// ✅ 极致性能：使用for循环但减少操作function 极致性能过滤(数据) { let 结果 = new Array(); let len = 数据.length; for (let i = 0; i < len; i++) { let val = 数据[i]; if (val > 100) { 结果.push(val * 1.2); } } return 结果;}// 测试：哪种更快？性能测试("传统for", () => { 低效过滤(测试数据); // 约120ms});性能测试("filter+map", () => { 高效过滤(测试数据); // 约85ms（现代JS引擎优化）});性能测试("优化for", () => { 极致性能过滤(测试数据); // 约75ms（最快）});

JSA特有优化：在WPS JSA中，for循环通常比forEach快，因为forEach有函数调用开销。但现代JS引擎对map/filter有优化，在数据量适中时两者差距不大。

方法5：避免在循环中创建对象 #

JavaScript

// ❌ 低效写法：循环内创建对象function 低效处理(数据) { let 结果 = []; for (let i = 0; i < 数据.length; i++) { let 临时对象 = { // 每次循环都创建新对象 索引: i, 原始值: 数据[i], 处理值: 数据[i] * 1.2 }; 结果.push(临时对象); } return 结果;}// ✅ 高效写法：复用对象模板function 高效处理(数据) { let 结果 = new Array(数据.length); for (let i = 0; i < 数据.length; i++) { // 直接操作数组元素，避免创建临时对象 结果[i] = { 索引: i, 原始值: 数据[i], 处理值: 数据[i] * 1.2 }; } return 结果;}// ✅ 极致优化：如果不需要索引，直接用数组function 极致优化(数据) { let 结果 = new Array(数据.length); let len = 数据.length; for (let i = 0; i < len; i++) { 结果[i] = 数据[i] * 1.2; // 简单数据类型，最快 } return 结果;}方法6：使用Set和Map代替数组去重和查找 #

JavaScript

// ❌ 低效去重：indexOffunction 低效去重(数组) { let 结果 = []; for (let i = 0; i < 数组.length; i++) { if (结果.indexOf(数组[i]) === -1) { 结果.push(数组[i]); } } return 结果;}// ✅ 高效去重：Setfunction 高效去重(数组) { return [...new Set(数组)];}// ❌ 低效查找：数组遍历function 低效查找(数组, 目标) { for (let i = 0; i < 数组.length; i++) { if (数组[i] === 目标) return i; } return -1;}// ✅ 高效查找：Mapfunction 高效查找(数组, 目标) { let 映射 = new Map(); 数组.forEach((值, 索引) => 映射.set(值, 索引)); return 映射.get(目标) || -1;}// 性能对比（10万条数据）性能测试("indexOf去重", () => { 低效去重(大数据); // 约3000ms});性能测试("Set去重", () => { 高效去重(大数据); // 约50ms（60倍提升！）});

原理：Set和Map基于哈希表实现，查找时间复杂度O(1)，而数组的indexOf是O(n)。

方法7：减少字符串操作，使用数组拼接 #

JavaScript

// ❌ 低效字符串拼接function 低效拼接(数组) { let 结果 = ""; for (let i = 0; i < 数组.length; i++) { 结果 += 数组[i] + ","; // 字符串不可变，每次创建新字符串 } return 结果.slice(0, -1);}// ✅ 高效拼接：数组joinfunction 高效拼接(数组) { return 数组.join(",");}// 性能对比（10万条）性能测试("字符串+=拼接", () => { 低效拼接(大数据); // 约450ms});性能测试("数组join", () => { 高效拼接(大数据); // 约30ms（15倍提升）});方法8：使用二分查找代替线性查找 #

JavaScript

// ❌ 线性查找（数据量大时慢）function 线性查找(有序数组, 目标) { for (let i = 0; i < 有序数组.length; i++) { if (有序数组[i] === 目标) return i; if (有序数组[i] > 目标) return -1; } return -1;}// ✅ 二分查找（快）function 二分查找(有序数组, 目标) { let 左 = 0; let 右 = 有序数组.length - 1; while (左 <= 右) { let 中 = Math.floor((左 + 右) / 2); let 中值 = 有序数组[中]; if (中值 === 目标) return 中; if (中值 < 目标) { 左 = 中 + 1; } else { 右 = 中 - 1; } } return -1;}// 性能对比（100万条数据）性能测试("线性查找", () => { 线性查找(大数据, 999999); // 约15ms});性能测试("二分查找", () => { 二分查找(大数据, 999999); // 约0.1ms（150倍提升！）});

适用场景：数据必须是有序的，且查找操作频繁。

方法9：利用录制宏学习高效API #

JavaScript

// 技巧：用录制宏找出最高效的API// 例如：删除空行，录制宏得到代码function 录制宏得到的代码() { Selection.SpecialCells(4).Select(); // 4代表常量单元格 Selection.EntireRow.Delete();}// 优化后：直接使用APIfunction 优化后的代码() { let ws = Application.ActiveSheet; ws.Cells.SpecialCells(4).EntireRow.Delete(); // 一行搞定}

学习建议：当你不知道某个操作用什么API最高效时，先用录制宏生成代码，然后分析优化。录制宏虽然代码啰嗦，但能给你正确的API调用方式。

方法10：使用VSCode + AI辅助编写优化代码 #

JavaScript

// 在VSCode中编写JSA，享受智能提示// 安装fittencode插件，AI可以帮你优化代码// 输入注释，AI自动生成优化代码// 需求：将A列数据去重后排序，写入B列// AI生成的优化代码：function 去重排序() { let ws = Application.ActiveSheet; let 最后行 = ws.Cells(ws.Rows.Count, 1).End(-4162).Row; // -4162 = xlUp // 批量读取 let 数据 = ws.Range(`A1:A${最后行}`).Value2.flat(); // 去重排序（利用Set和sort） let 处理结果 = [...new Set(数据)] .filter(v => v !== null && v !== "") .sort((a, b) => a - b); // 批量写入 ws.Range(`B1:B${处理结果.length}`).Value2 = 处理结果.map(v => [v]);}

配置方法：下载JSA类型声明文件，在VSCode中享受智能提示。

三、优化实战：完整案例对比 #3.1 原始代码（处理5万行，3分钟） #

JavaScript

function 原始版本() { let ws = Application.ActiveSheet; let 最后行 = ws.UsedRange.Rows.Count; // 逐行处理 for (let i = 2; i <= 最后行; i++) { // 读取单元格 let 姓名 = ws.Cells(i, 1).Value2; let 部门 = ws.Cells(i, 2).Value2; let 销售额 = ws.Cells(i, 3).Value2; let 日期 = ws.Cells(i, 4).Value2; // 业务逻辑 if (部门 === "销售部" && 销售额 > 10000) { ws.Cells(i, 5).Value2 = "优秀"; ws.Cells(i, 6).Value2 = 销售额 * 0.1; } else if (部门 === "技术部" && 日期 > new Date("2024-01-01")) { ws.Cells(i, 5).Value2 = "新员工"; } // 每100行更新状态 if (i % 100 === 0) { Application.StatusBar = `处理中：${i}/${最后行}`; } } Application.StatusBar = false;}3.2 优化后代码（处理5万行，8秒） #

JavaScript

function 优化版本() { // 性能优化开关 Application.ScreenUpdating = false; Application.Calculation = -4135; Application.EnableEvents = false; try { let ws = Application.ActiveSheet; let 最后行 = ws.UsedRange.Rows.Count; // 1. 批量读取数据到数组 let 数据区域 = ws.Range(`A1:D${最后行}`); let 数据 = 数据区域.Value2; // 二维数组 // 2. 准备结果数组 let 结果E列 = new Array(数据.length - 1); let 结果F列 = new Array(数据.length - 1); // 3. 内存中处理（最快的部分） for (let i = 1; i < 数据.length; i++) { // i=1跳过表头 let 行 = 数据[i]; let 部门 = 行[1]; // B列 let 销售额 = 行[2]; // C列 let 日期 = 行[3]; // D列 // 业务逻辑 if (部门 === "销售部" && 销售额 > 10000) { 结果E列[i-1] = "优秀"; 结果F列[i-1] = 销售额 * 0.1; } else if (部门 === "技术部" && 日期 && new Date(日期) > new Date("2024-01-01")) { 结果E列[i-1] = "新员工"; } } // 4. 批量写回结果 if (结果E列.some(v => v !== undefined)) { ws.Range(`E2:E${最后行}`).Value2 = 结果E列.map(v => [v || ""]); } if (结果F列.some(v => v !== undefined)) { ws.Range(`F2:F${最后行}`).Value2 = 结果F列.map(v => [v || ""]); } } finally { // 恢复设置 Application.ScreenUpdating = true; Application.Calculation = -4105; Application.EnableEvents = true; }}3.3 性能对比表 #

操作

原始版本

优化版本

提升倍数

单元格读写

50,000次

2次

25,000倍

屏幕刷新

50,000次

0次

-

总执行时间

3分钟

8秒

22.5倍

四、性能优化检查清单 #

写完代码后，用这个清单检查：

4.1 必检查项 #是否用了数组批量读写代替逐单元格操作？是否关闭了ScreenUpdating？是否缓存了重复使用的对象？循环中是否创建了不必要的对象？是否用了Set/Map代替数组查找？4.2 加分项 #是否用二分查找优化了有序数据查找？是否用字符串join代替了+=拼接？是否用try-finally确保恢复设置？是否给用户提供了进度提示？五、避坑指南 #坑1：过度优化 #

JavaScript

// ❌ 没必要优化的地方let a = 1;let b = 2;let c = a + b; // 这需要优化吗？不需要！// ✅ 把精力花在刀刃上// 重点优化：循环、IO操作、复杂算法坑2：忘记恢复设置 #

JavaScript

// ❌ 忘记恢复function 有问题的函数() { Application.ScreenUpdating = false; // ... 执行操作 // 忘记恢复，用户界面卡住了！}// ✅ 用try-finally保证恢复function 安全的函数() { try { Application.ScreenUpdating = false; // ... 执行操作 } finally { Application.ScreenUpdating = true; }}坑3：滥用数组操作 #

JavaScript

// 数据量很小时，逐单元格操作反而更快// 因为创建数组也有开销if (数据量 < 100) { // 可以直接逐单元格操作 逐单元格处理();} else { // 数据量大时用数组 数组批量处理();}六、总结：10个优化方法速记 #数组批量读写：10万次IO变2次，提升百倍关闭屏幕刷新：让WPS专心计算，不拖后腿缓存对象引用：避免重复获取对象用现代JS语法：filter/map/Set/Map避免循环内创建对象：内存中一次搞定Set/Map代替数组查找：O(1) vs O(n)数组join代替字符串+：减少字符串创建二分查找优化有序数据：O(log n) vs O(n)学习录制宏：找到最佳APIVSCode+AI辅助：写出更优代码

最后记住：

优化的核心不是写更快的代码，而是做更少的操作。

如果这篇文章帮你解决了性能问题：

点赞 支持更多干货内容关注我 ➕ 第一时间获取JSA系列教程分享 让更多同事告别“代码卡死”