WPS JS宏编程教程（从基础到进阶）-- 第七部分：JS对象在WPS中的应用

所有章节教程word文件可以点击如下链接获取
wps-excel办公+JS宏编程教程基础到进阶+函数使用手册

第7章 JS对象在WPS中的应用

7-1 对象创建的几种方法

从零理解对象：数据收纳盒

想象一下，对象就像是一个多层的收纳盒，每个抽屉（属性）可以存放不同类型的东西——数字、文本、公式，甚至另一个收纳盒（嵌套对象）。在WPS表格中，用对象管理数据能让代码更清晰。

两种基础创建方式

1. 空盒子起手
   用new Object()或字面量{}创建一个空对象，适合逐步填充数据：

   // 方法1：构造函数
   var student = new Object();
   
   // 方法2：字面量（更常用）
   var product = {};
   

2. 预装数据的盒子
   初始化时直接定义属性，适合固定结构的数据：

   var order = {
     id: "202309001",       // 字符串
     items: ["笔记本", "鼠标"], // 数组
     total: 599.99,         // 数字
     isValid: true,         // 布尔值
     getDiscount: function() {  // 函数
       return this.total * 0.9;
     }
   };
   

代码解析表

7-2 对象属性的查、改、增、删

像操作Excel单元格一样管理属性

对象属性操作类似表格中的单元格——可随时读取、修改、删除。关键在于灵活使用两种操作符：

1. 点操作符（静态键名）

• 适合已知属性名：直接通过.访问

  // 读取
  console.log(order.id);      // 输出"202309001"
  
  // 修改
  order.total = 699.99;       // 总价更新为699.99
  
  // 删除
  delete order.isValid;       // 移除是否有效标识
  

2. 中括号操作符（动态键名）

• 适合变量或特殊字符：

  var key = "total";
  console.log(order[key]);    // 输出699.99
  
  // 添加带空格的属性
  order["delivery address"] = "北京市朝阳区"; 
  

动态属性应用场景

假设需要根据单元格A1的值动态读取属性：

var cellValue = Range("A1").Value();
var data = {
  January: 1500,
  February: 2300
};
console.log(data[cellValue]);  // 若A1是"February"，输出2300

7-3 循环对象中的属性

批量操作：像筛选行一样遍历对象

当需要处理对象中的所有属性时，三种方法轻松实现遍历：

方法对比表

实战：将对象写入Excel

var sales = {
  产品A: 1200,
  产品B: 980,
  产品C: 1560
};

// 写入A列（产品名）和B列（销售额）
var row = 1;
Object.entries(sales).forEach(([product, amount]) => {
  Cells(row, 1).Value2 = product;  // A列
  Cells(row, 2).Value2 = amount;  // B列
  row++;
});

7-4 实例1：提取各项目最后1条记录

场景：抓取最新数据

假设有一个不断更新的销售记录表，需要提取每个客户的最后一次交易数据。对象可以像“实时监控器”一样，始终保留最新值。

原始数据示例

代码实现

function 提取最后记录() {
  var data = Range("A2:C5").Value();  // 读取原始数据
  var latestData = {};                // 空对象存储最新记录
  
  // 遍历每一行数据
  data.forEach(row => {
    var name = row[0];               // 提取姓名（A列）
    latestData[name] = row.slice(1); // 更新为当前行的数据
  });

  // 将对象转为数组并写入新区域
  var output = Object.entries(latestData).map(([key, val]) => [key, ...val]);
  Range("E2").Resize(output.length, 3).Value2 = output;
}

代码解析表

输出结果

7-5 实例2：提取各项目第1条记录

场景：记录首次出现的数据

需要统计每个客户的首次交易信息，类似在Excel中标记“首次出现”的筛选功能。

原始数据（同7-4）

代码实现

function 提取第一条记录() {
  var data = Range("A2:C5").Value();
  var firstData = {};                 // 存储首次记录
  var counter = 1;                    // 序号生成器

  data.forEach(row => {
    var name = row[0];
    if (!firstData[name]) {           // 仅当不存在时存储
      firstData[name] = [counter++, ...row.slice(1)]; // 添加序号
    }
  });

  // 转换并写入结果
  var output = Object.values(firstData);
  Range("E2").Resize(output.length, 4).Value2 = output;
}

代码解析表

输出结果

7-6 实例3：按指定字段汇总数据

场景：快速统计分组总和

类似Excel的“SUMIF”函数，但用对象实现动态聚合。

原始数据（同7-4）

代码实现

function 按姓名汇总() {
  var data = Range("A2:C5").Value();
  var sumData = {};  // 用对象存储累加结果

  data.forEach(row => {
    var name = row[0];
    var amount = row[1];
    // 累加逻辑：如果存在则加，否则初始化
    sumData[name] = (sumData[name] || 0) + amount;
  });

  // 转为二维数组并写入
  var output = Object.entries(sumData);
  Range("E2").Resize(output.length, 2).Value2 = output;
}

代码解析表

输出结果

7-7 实例4：按指定字段做多种汇总

场景：多维数据统计

需要同时计算每个产品的销售额总和、最大值和平均值，类似Excel的数据透视表功能。

原始数据（扩展版）

代码实现

function 多维统计() {
  var data = Range("A2:C6").Value();
  var statData = {};  // 存储统计数据的对象
  
  data.forEach(row => {
    var product = row[0];
    var amount = row[1];
    
    // 初始化或更新统计数据
    if (!statData[product]) {
      statData[product] = {
        total: 0,
        max: -Infinity,
        count: 0
      };
    }
    
    // 更新统计值
    statData[product].total += amount;
    statData[product].max = Math.max(statData[product].max, amount);
    statData[product].count++;
  });

  // 生成输出数组
  var output = Object.entries(statData).map(([product, data]) => [
    product,
    data.total,
    data.max,
    data.total / data.count
  ]);
  
  // 写入结果
  Range("E2").Resize(output.length, 4).Value2 = output;
}

代码解析表

输出结果

7-8 实例5：按多字段做多种汇总

场景：复合条件分析

需要按"产品+月份"组合统计数据，类似Excel中的多级分类汇总。

原始数据（同7-7）

代码实现

function 复合键统计() {
  var data = Range("A2:C6").Value();
  var statData = {};  // 存储复合键统计结果
  
  data.forEach(row => {
    var product = row[0];
    var month = row[2];
    var amount = row[1];
    var key = product + "|" + month;  // 构建复合键
    
    // 初始化或更新统计
    if (!statData[key]) {
      statData[key] = {
        total: 0,
        transactions: []
      };
    }
    statData[key].total += amount;
    statData[key].transactions.push(amount);
  });

  // 生成输出数组
  var output = Object.entries(statData).map(([key, data]) => {
    var [product, month] = key.split("|");
    return [
      product,
      month,
      data.total,
      Math.max(...data.transactions),
      data.transactions.length
    ];
  });
  
  // 写入结果
  Range("E2").Resize(output.length, 5).Value2 = output;
}

代码解析表

输出结果

7-9 实例6：按条件读取多表再拆成多表

场景：跨表数据整合

从多个工作表中提取数据，按指定条件合并后重新拆分到新表。

原始数据（假设有3个月份表）

1月表：

2月表：

代码实现

function 跨表合并拆分() {
  var mergedData = {};  // 存储合并后的数据
  var sheets = ["1月", "2月", "3月"];  // 目标工作表名
  
  sheets.forEach(sheetName => {
    var sheet = Sheets(sheetName);
    var data = sheet.Range("A2:B" + sheet.Range("A1").End(xlDown).Row).Value();
    
    data.forEach(row => {
      var product = row[0];
      if (!mergedData[product]) {
        mergedData[product] = [];
      }
      mergedData[product].push([sheetName, row[1]]);  // 添加月份数据
    });
  });

  // 创建新工作簿写入数据
  var newWb = Workbooks.Add();
  Object.entries(mergedData).forEach(([product, data]) => {
    var ws = newWb.Sheets.Add();
    ws.Name = product;
    ws.Range("A1").Value2 = ["月份", "销售额"];
    ws.Range("A2").Resize(data.length, 2).Value2 = data;
  });
}

代码解析表

输出效果

手机表：

耳机表：

7-10 实例7：拆分单表到多工作簿下的多表

场景：数据分库存储

将一张包含全国各城市销售数据的总表，按省份拆分为独立工作簿（每个省份一个文件），适合数据分发场景。

原始数据

代码实现

function 按省份拆分工作簿() {
  var mainData = Range("A2:C6").Value();  // 读取源数据
  var provinceData = {};                  // 按省份分组存储
  
  // 数据分组
  mainData.forEach(row => {
    var province = row[1];
    if (!provinceData[province]) {
      provinceData[province] = [];
    }
    provinceData[province].push(row);
  });

  // 创建独立工作簿
  Object.entries(provinceData).forEach(([province, data]) => {
    var newWb = Workbooks.Add();          // 新建工作簿
    var ws = newWb.ActiveSheet;
    ws.Name = province + "销售数据";
    
    // 写入表头和内容
    ws.Range("A1:C1").Value2 = [["城市", "省份", "销售额"]];
    ws.Range("A2").Resize(data.length, 3).Value2 = data;
    
    // 保存文件
    var path = ThisWorkbook.Path + "\\" + province + ".xlsx";
    newWb.SaveAs(path);
    newWb.Close();
  });
}

代码解析表

生成文件示例

浙江.xlsx内容：

7-11 对象的属性值为函数用法

场景：封装工具方法

将常用功能（如格式设置、计算逻辑）封装为对象方法，实现代码复用。

案例：颜色管理器

// 定义工具对象
var formatTool = {
  // 设置单元格背景色（输入范围对象，输出无）
  setColor: function(rng, colorIndex) {
    rng.Interior.ColorIndex = colorIndex;
  },
  
  // 生成随机颜色值（输入无，输出数字）
  randomColor: function() {
    return Math.floor(Math.random() * 56) + 1;
  }
};

// 应用示例
function 随机着色() {
  var dataRng = Range("A2:C6");
  formatTool.setColor(dataRng, formatTool.randomColor());
}

方法说明表

执行效果

• A2:C6区域背景色变为随机索引色（1-56）

7-12 用构造函数自定义类-1

场景：标准化数据处理

创建可复用的数据处理器类，统一管理同类操作。

订单处理类

// 定义构造函数
function OrderProcessor(sheetName) {
  // 属性初始化
  this.sheet = Sheets(sheetName);
  this.dataRange = this.sheet.UsedRange;
  
  // 方法：获取总销售额
  this.getTotalSales = function() {
    return this.dataRange.Columns(3).Value().flat().reduce((a,b) => a + b);
  };
}

// 使用示例
function 处理订单() {
  var processor = new OrderProcessor("订单表");  // 实例化对象
  console.log("总销售额：" + processor.getTotalSales());
}

类结构解析表

输入输出示例

• 输入：new OrderProcessor("订单表")
• 输出方法：getTotalSales()返回数值如150000

7-13 用构造函数自定义类-2

场景：动态数据容器

构建支持动态分析的数据模型，适合实时计算场景。

销售分析器类

function SalesAnalyzer(dataRange) {
  // 初始化数据
  this.rawData = dataRange.Value();
  
  // 方法：按产品过滤
  this.filterByProduct = function(product) {
    return this.rawData.filter(row => row[0] === product);
  };
  
  // 方法：计算平均值
  this.getAverage = function() {
    var values = this.rawData.map(row => row[1]);
    return values.reduce((a,b) => a + b) / values.length;
  };
}

// 使用示例
function 分析数据() {
  var analyzer = new SalesAnalyzer(Range("A2:B10"));
  var phoneData = analyzer.filterByProduct("手机");
  console.log("手机平均销售额：" + analyzer.getAverage());
}

方法参数说明

7-14 用class构造自定义类-3

场景：现代化代码封装

ES6的class语法让面向对象编程更直观，适合构建复杂工具。我们将重构7-13节的销售分析器，体验现代语法优势。

类定义：销售统计器

class SalesAnalyzer {
  constructor(dataRange) {
    // 初始化数据源
    this.rawData = dataRange.Value();
  }

  // 方法1：按产品过滤数据
  filterByProduct(product) {
    return this.rawData.filter(row => row[0] === product);
  }

  // 方法2：计算平均值（保留两位小数）
  getAverage() {
    const sum = this.rawData
      .map(row => row[1])
      .reduce((a, b) => a + b);
    return Number(sum / this.rawData.length).toFixed(2);
  }

  // 方法3：生成统计报告
  generateReport() {
    return `共${this.rawData.length}条数据，平均销售额：${this.getAverage()}`;
  }
}

代码解析表

使用示例

function 生成分析报告() {
  const analyzer = new SalesAnalyzer(Range("A2:B10"));  // 输入数据区域
  console.log(analyzer.generateReport());               // 输出：共9条数据，平均销售额：13500.00
}

7-15 实例8：自定义关于[唯一性]的类

场景：数据去重与可视化

需要为表格中的唯一值自动着色（如分类标识），并通过类封装实现复用。

类设计：唯一值处理器

class UniqueValueProcessor {
  constructor(targetRange) {
    this.range = targetRange;              // 存储目标区域
    this.uniqueValues = [];                // 存储唯一值列表
  }

  // 方法1：提取唯一值
  extractUniqueValues() {
    const allValues = this.range.Value().flat();
    this.uniqueValues = [...new Set(allValues)];  // Set去重
  }

  // 方法2：为唯一值随机着色
  colorizeUniqueValues() {
    this.uniqueValues.forEach(value => {
      const color = Math.floor(Math.random() * 56) + 1;  // 1-56号颜色
      this.range.Cells.Find(value).Interior.ColorIndex = color;
    });
  }
}

使用演示

function 处理唯一值() {
  const processor = new UniqueValueProcessor(Range("B2:B10"));  // 输入分类列
  processor.extractUniqueValues();   // 提取唯一值
  processor.colorizeUniqueValues();  // 着色单元格
}

输入输出示例

• 输入数据（B列）：

  分类
  电子产品
  服装
  食品
  电子产品

• 执行结果：

  • uniqueValues数组：["电子产品", "服装", "食品"]
  • B列中每个分类显示不同背景色

7-16 实例8: [唯一性]类的应用

场景：跨表数据整合

将多个工作表中相同列的唯一值汇总，并生成全局统计报告。

扩展应用：跨表处理器

class CrossSheetUniqueProcessor {
  constructor(sheetNames, columnIndex) {
    this.sheets = sheetNames;    // 工作表名数组
    this.column = columnIndex;   // 要处理的列号（从1开始）
    this.globalUniqueSet = new Set();  // 存储全局唯一值
  }

  // 方法：遍历所有表提取唯一值
  collectAllUniqueValues() {
    this.sheets.forEach(sheetName => {
      const sheet = Sheets(sheetName);
      const range = sheet.Columns(this.column);
      const values = range.Value().flat();
      values.forEach(v => this.globalUniqueSet.add(v));
    });
  }

  // 方法：生成汇总报告
  generateReport() {
    const reportSheet = Sheets.Add();
    reportSheet.Name = "唯一值汇总";
    const uniqueArray = [...this.globalUniqueSet];
    reportSheet.Range("A1").Resize(uniqueArray.length, 1).Value2 = uniqueArray;
  }
}

使用示例

function 跨表汇总() {
  const processor = new CrossSheetUniqueProcessor(["1月", "2月", "3月"], 2);  // 处理各表B列
  processor.collectAllUniqueValues();  // 收集数据
  processor.generateReport();          // 生成汇总表
}

输入输出示例

• 输入表结构（各月表B列）：

  1月表	2月表
  笔记本电脑	智能手机
  智能手机	耳机

• 输出结果（汇总表A列）：

  唯一值汇总
  笔记本电脑
  智能手机
  耳机

本章小结

通过对象和类，我们实现了：

1. 数据封装：将复杂操作隐藏在类内部
2. 代码复用：通过实例化重复使用逻辑
3. 可维护性：修改类定义即可影响所有调用处

尝试用面向对象思维设计你的下一个WPS宏项目吧！