温馨提示：本篇博客的详细代码已发布到 git : https://gitcode.com/nutpi/HarmonyosNext 可以下载运行哦！

概述

本篇文章，将焦点转向函数调用与函数声明的优化策略。在HarmonyOS NEXT API12+的开发过程中，函数的精准定义与高效调用是提升应用性能的关键所在。本文将通过一个具体计算器应用的实例，逐一揭晓几种经过实践检验的优化技巧，旨在引导开发者如何编写出更加高效的代码，从而优化应用性能和用户体验。

函数调用优化

声明参数要和实际的参数一致

在HarmonyOS NEXT开发中，声明的参数要和实际的传入参数个数及类型一致，否则会导致运行时走入慢速路径，影响性能。

反例

 
@Entry
@Component
struct CalculatorBad {@State result: string = '0';// 参数声明与实际使用不一致的计算函数calculate(operation: string, a: number, b: number) {switch(operation) {case 'add':// 错误：传入了多余的参数return this.add(a, b, 0);case 'subtract':// 错误：参数类型不匹配return this.subtract(a.toString(), b.toString());default:return 0;}}// 基础数学运算函数add(a: number, b: number) {return a + b;}subtract(a: number, b: number) {return a - b;}build() {Column() {Text(this.result).fontSize(30).margin(20)Row() {Button('计算示例').onClick(() => {// 错误调用方式this.result = this.calculate('add', 1, 2, 3).toString();})}}.width('100%').height('100%')}
}

正例

 
@Entry
@Component
struct CalculatorGood {@State result: string = '0';@State num1: string = '';@State num2: string = '';// 使用接口定义计算器操作interface Operation {calculate(a: number, b: number): number;symbol: string;}// 预定义所有操作类型private operations: Record<string, Operation> = {add: {calculate: (a: number, b: number): number => a + b,symbol: '+'},subtract: {calculate: (a: number, b: number): number => a - b,symbol: '-'}};// 参数类型和数量完全匹配的计算函数calculate(operation: string): void {const op = this.operations[operation];if (!op) return;const a = Number(this.num1);const b = Number(this.num2);// 参数类型和数量完全匹配this.result = op.calculate(a, b).toString();}build() {Column() {// 计算结果显示Text(this.result).fontSize(30).margin(20)// 输入框TextInput({ placeholder: '第一个数字' }).width('80%').margin(10).onChange((value: string) => {this.num1 = value;})TextInput({ placeholder: '第二个数字' }).width('80%').margin(10).onChange((value: string) => {this.num2 = value;})// 操作按钮Row() {ForEach(Object.keys(this.operations), (key: string) => {Button(this.operations[key].symbol).margin(10).onClick(() => {// 正确的参数传递方式this.calculate(key);})})}.margin(20)}.width('100%').height('100%').justifyContent(FlexAlign.Center)}
}

函数内部变量尽量使用参数传递

在HarmonyOS NEXT开发中，能传递参数的尽量传递参数，不要使用闭包。闭包作为参数会多一次闭包创建和访问，影响性能。

反例

 
@Component
struct CalculationHistoryBad {// 全局历史记录private static history: string[] = [];// 错误示例：使用闭包访问外部变量addToHistory() {// 通过闭包访问静态变量，性能较差CalculationHistoryBad.history.push(`计算时间: ${new Date().toLocaleString()}`);}clearHistory() {// 通过闭包访问静态变量，性能较差CalculationHistoryBad.history = [];}build() {Column() {// 通过闭包访问历史记录ForEach(CalculationHistoryBad.history, (item: string) => {Text(item).fontSize(16).margin(5)})}}
}

正例

 
@Component
struct CalculationHistoryGood {@State history: string[] = [];// 正确示例：通过参数传递数据addToHistory(record: string): void {// 通过参数传递，性能更好this.history = [...this.history, record];}// 使用参数传递新的历史记录状态updateHistory(newHistory: string[]): void {this.history = newHistory;}build() {Column() {// 直接使用组件状态ForEach(this.history, (item: string) => {Text(item).fontSize(16).margin(5)})Button('添加记录').onClick(() => {// 通过参数传递数据this.addToHistory(`计算时间: ${new Date().toLocaleString()}`);})Button('清空记录').onClick(() => {// 通过参数传递空数组this.updateHistory([]);})}}
}

函数与类声明优化

避免动态声明function与class

在HarmonyOS NEXT开发中，动态声明function和class会导致每次调用都重新创建，对内存和性能都会有影响。

反例

 
@Entry
@Component
struct CalculatorFactoryBad {@State result: string = '0';// 错误示例：动态创建计算器类createCalculator(type: string) {if (type === 'scientific') {// 每次调用都会创建新的类，性能差return class ScientificCalculator {sin(x: number): number {return Math.sin(x);}cos(x: number): number {return Math.cos(x);}}} else {// 每次调用都会创建新的类，性能差return class BasicCalculator {add(a: number, b: number): number {return a + b;}subtract(a: number, b: number): number {return a - b;}}}}build() {Column() {Text(this.result).fontSize(30)Button('创建计算器').onClick(() => {// 每次点击都会创建新的类实例const Calculator = this.createCalculator('scientific');const calc = new Calculator();this.result = calc.sin(30).toString();})}}
}

正例

 
// 预定义计算器接口
interface ICalculator {calculate(x: number, y?: number): number;getType(): string;
}// 预定义所有计算器类
class ScientificCalculator implements ICalculator {private static instance: ScientificCalculator;// 使用单例模式static getInstance(): ScientificCalculator {if (!ScientificCalculator.instance) {ScientificCalculator.instance = new ScientificCalculator();}return ScientificCalculator.instance;}calculate(x: number): number {return Math.sin(x);}getType(): string {return '科学计算器';}
}class BasicCalculator implements ICalculator {private static instance: BasicCalculator;static getInstance(): BasicCalculator {if (!BasicCalculator.instance) {BasicCalculator.instance = new BasicCalculator();}return BasicCalculator.instance;}calculate(x: number, y: number): number {return x + y;}getType(): string {return '基础计算器';}
}@Entry
@Component
struct CalculatorFactoryGood {@State result: string = '0';@State currentType: string = 'basic';// 工厂函数返回预定义的类实例getCalculator(type: string): ICalculator {switch (type) {case 'scientific':return ScientificCalculator.getInstance();default:return BasicCalculator.getInstance();}}build() {Column() {Text(this.result).fontSize(30).margin(20)Text(`当前模式: ${this.getCalculator(this.currentType).getType()}`).fontSize(20).margin(10)Row() {Button('基础模式').margin(10).onClick(() => {this.currentType = 'basic';const calc = this.getCalculator('basic');this.result = calc.calculate(1, 2).toString();})Button('科学模式').margin(10).onClick(() => {this.currentType = 'scientific';const calc = this.getCalculator('scientific');this.result = calc.calculate(30).toString();})}}.width('100%').height('100%').justifyContent(FlexAlign.Center)}
}

性能测试示例

下面是一个简单的性能测试组件，用于比较不同实现方式的性能差异：

  // performance-test.ets@Component
export struct PerformanceTest {@State testResults: string = '';aboutToAppear() {this.runPerformanceTests();}// 性能测试函数async runPerformanceTests() {const iterations = 100000;const testArray = [1, 2, 3, 4, 5];// 测试1: 使用闭包const startTime1 = new Date().getTime();let sum1 = 0;const sumWithClosure = () => {for (let i = 0; i < testArray.length; i++) {sum1 += testArray[i];}return sum1;}for (let i = 0; i < iterations; i++) {sumWithClosure();}const endTime1 = new Date().getTime();// 测试2: 使用参数传递const startTime2 = new Date().getTime();let sum2 = 0;const sumWithParams = (arr: number[]): number => {let localSum = 0;for (let i = 0; i < arr.length; i++) {localSum += arr[i];}return localSum;}for (let i = 0; i < iterations; i++) {sum2 = sumWithParams(testArray);}const endTime2 = new Date().getTime();// 更新测试结果this.testResults = `
闭包方式耗时: ${endTime1 - startTime1}ms
参数传递耗时: ${endTime2 - startTime2}ms闭包结果: ${sum1}
参数传递结果: ${sum2}`;}build() {Column() {Text('性能测试结果').fontSize(24).margin(20)Text(this.testResults).fontSize(16).margin(20)// 添加更多测试用例Button('运行更多测试').onClick(() => {this.runMoreTests();}).margin(20)}.width('100%').height('100%').justifyContent(FlexAlign.Center)}// 更多性能测试用例async runMoreTests() {const iterations = 100000;const testArray = [1, 2, 3, 4, 5];// 测试3: 动态函数声明const startTime3 = new Date().getTime();let sum3 = 0;for (let i = 0; i < iterations; i++) {const dynamicSum =  (arr: number[]): number=> {let localSum = 0;for (let j = 0; j < arr.length; j++) {localSum += arr[j];}return localSum;};sum3 = dynamicSum(testArray);}const endTime3 = new Date().getTime();// 测试4: 预定义函数const startTime4 = new Date().getTime();let sum4 = 0;const predefinedSum = (arr: number[]): number => {let localSum = 0;for (let i = 0; i < arr.length; i++) {localSum += arr[i];}return localSum;};for (let i = 0; i < iterations; i++) {sum4 = predefinedSum(testArray);}const endTime4 = new Date().getTime();// 更新测试结果this.testResults += `动态函数声明耗时: ${endTime3 - startTime3}ms
预定义函数耗时: ${endTime4 - startTime4}ms动态函数结果: ${sum3}
预定义函数结果: ${sum4}`;}
}

性能测试结果分析

通过上述性能测试组件，我们可以得出以下结论：

1. 参数传递 vs 闭包：使用参数传递的方式比使用闭包访问外部变量的性能更好，因为闭包需要额外的创建和访问成本。

2. 预定义函数 vs 动态函数：预定义函数的性能明显优于动态声明的函数，因为动态声明会在每次调用时重新创建函数对象。

3. 内存使用：使用参数传递和预定义函数的方式不仅执行速度更快，而且内存使用也更加高效，因为避免了额外的闭包对象和动态函数对象的创建。

最佳实践建议

基于上述性能测试结果，我们建议在HarmonyOS NEXT开发中遵循以下最佳实践：

1. 函数参数传递：

   • 优先使用参数传递而不是闭包访问外部变量
   • 确保参数类型和数量的一致性
   • 避免使用可选参数，而是使用明确的函数重载

2. 函数声明方式：

   • 使用预定义的函数而不是动态声明
   • 采用单例模式管理类实例
   • 避免在循环或条件语句中声明函数

3. 性能优化技巧：

   • 使用TypeScript的类型系统确保类型安全
   • 避免不必要的对象创建和内存分配
   • 利用接口和类型定义提高代码的可维护性

通过遵循这些最佳实践，我们可以编写出更高效、更可靠的HarmonyOS NEXT应用程序。