鸿蒙NEXT开发【ArkTS高性能编程】性能

ArkTS高性能编程概述

高性能编程指的是在语法使用过程中，通过优化一些影响性能的代码片段，使代码以最优的方式执行。以下实践是在开发过程中逐步总结出来的一些高性能的写法和建议，实践包含变量声明、属性的访问、数值计算、数据结构的使用以及函数声明与使用等内容，在业务功能实现过程中，要同步思考并理解高性能写法的原理，运用到代码逻辑实现中。

变量声明

使用const声明常量

对于初期明确不会改变的变量，尽量使用const进行初始化，这里的常量包含基础类型和引用类型。通过const保证地址不会发生变化，能够极大减少由于编码时误操作导致的赋值等行为，造成对原有逻辑的改变，声明为const能够在编辑时及时发现错误。其中当const声明的是引用类型时，引用类型内部的属性变化是允许的，对于这种不存在地址变化的情况下，也建议使用const声明。

【反例】

// 该变量在后续过程并未发生改变，建议声明为常量
let PRICE = 10000;

function getPrice() {
  return PRICE;
}

class ClassA {
  propA: string = 'propA'
} 
// 该引用类型的变量在后续过程变量地址并未发生改变，仅修改了变量的属性，建议使用const声明
let classA: ClassA = new ClassA();
classA.propA = 'Property A';

【正例】

const PRICE = 10000; // 常量声明为基础类型时，其内容不可改变

function getPrice() {
  return PRICE;
}

class ClassA {
  propA: string = 'propA'
}

// 常量声明为引用类型时，其地址不可改变，但可以改变属性
const classA: ClassA = new ClassA();
classA.propA = 'Property A';

指定number的类型

对于number类型，编译器在优化时会区分int和double类型。开发者在初始化number类型的变量时，如果预期是整数类型就初始化为0，小数类型就初始化为0.0，避免将一个number类型初始化为undefined或者null。

【正例】

function calAddSum(addNum: number): number {
  // count预期是int，不要声明成undefined/null或0.0，直接初始化为0
  let count = 0;
  count += addNum;
  return count;
}

减少使用ESObject

ESObject主要用于在ArkTS和TS/JS跨语言调用的场景中作为类型标注，在非跨语言场景中使用ESObject标注类型，会引入不必要的跨语言调用，造成额外的性能开销，建议在非跨语言调用的场景下，避免使用ESObject，引入明确的类型进行注释。

【反例】

// lib.ets
interface TestA {
  sum: number
}

export function getObject(value: number): TestA {
  let obj: TestA = { sum: value };
  return obj;
}

// app.ets
import { getObject } from 'lib';
let obj:ESObject = getObject(123); // 通过ESObject定义接受类型

【正例】

1、在lib.ets文件中导出对应的接口类型和方法

// lib.ets
export interface TestA {
  sum: number
}

export function getObject(value: number): TestA {
  let obj: TestA = { sum: value };
  return obj;
}

2、在使用该方法的文件app.ets，引入对应的类型

// app.ets
import { getObject, TestA } from './lib';

let obj: TestA = getObject(123); // 显式引入标注类型

属性访问

减少变量的属性查找

在要求性能的场景下，建议通过使用将全局变量存储为局部变量的方式来减少全局查找，因为访问局部变量的速度要比访问全局变量的速度更快。重复的访问同一个变量，将造成不必要的消耗，尤其当类似的访问出现在循环过程中，其对于性能的影响更大。

在实际中可能会遇到在循环中会大量进行一些常量的访问操作，该常量在循环中不会改变，可以提取到循环外部，减少属性访问的次数。例如下面这个用例，Time是一个包含了日期信息的对象，Time.Info是记录日期的数组，示例中对于Time.INFO[year - Time.START]的访问，在每一次循环中，都会执行一次。

【反例】

class Time {
  static START: number = 1987;
  static INFO: number[] = [2001, 2002, 2003, 2004, 2005, 2006]
}

function getDay(year: number): number {
  let totalDays: number = 348;
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    // 此处会多次对Time的INFO及START进行查找，并且每次查找出来的值是相同的
    totalDays += ((Time.INFO[year - Time.START] & index) !== 0) ? 1 : 0;
  }
  return totalDays;
}

【正例】

// 优化后代码
class Time {
  static START: number = 1987;
  static INFO: number[] = [2001, 2002, 2003, 2004, 2005, 2006];
}

function getDay(year: number): number {
  let totalDays: number = 348;
  // 从循环中提取不变量
  const info = Time.INFO[year - Time.START]; 
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    if ((info & index) !== 0) {
      totalDays++;
    }
  }
  return totalDays;
}

给类属性添加访问修饰符

在ArkTS中，对于类结构的属性提供了private、protected和public可访问修饰符。默认情况下一个属性的可访问修饰符为public。选取适当的可访问修饰符可以提升代码的安全性、可读性。

【反例】

class Counter {
  // 没有设置访问修饰符默认为public
  count: number = 0;

  getCount(): number {
    return this.count;
  }
}
// 访问时
const counter:Counter = new Counter();
console.info(counter.count.toString()); // 可以通过实例访问
console.info(counter.getCount().toString());

【正例】

class Counter {
  // 设置访问修饰符为private
  private count: number = 0;

  public getCount(): number {
    return this.count;
  }
}
// 访问时
const counter:Counter = new Counter();
let res = counter.getCount();

说明

当设置为private时，无法通过对象字面量的方式初始化类，在有需要通过字面量创建、或者直接访问属性时，设置为public。

数值计算

数值计算使用TypedArray

如果是纯数值计算的场合，推荐使用TypedArray数据结构。TypedArray类型化数组是一种类似数组的对象，其提供了一种用于在内存缓冲中访问原始二进制数据的机制。在一些图像数据处理、加解密的数据计算过程中使用TypedArray可以提高数据处理的效率，因为TypedArray是基于ArrayBuffer实现，在性能方面也能够进行较大提升。

【反例】

const array1 = new Array(1, 2, 3);  // 针对这一场景，建议不要使用new Array(1, 2, 3)
const array2 = new Array(4, 5, 6);  // 针对这一场景，建议不要使用new Array(4, 5, 6)
const res = new Array<number>(3);
for (let i = 0; i < 3; i++) {
  res[i] = array1[i] + array2[i];
}

【正例】

const typedArray1 = new Int8Array([1, 2, 3]);  // 针对这一场景，建议不要使用new Array([1, 2, 3])
const typedArray2 = new Int8Array([4, 5, 6]);  // 针对这一场景，建议不要使用new Array([4, 5, 6])
const res = new Int8Array(3);
for (let i = 0; i < 3; i++) {
  res[i] = typedArray1[i] + typedArray2[i];
}

数据结构的使用

选取合适的数据结构

有些时候会采用Record的方式作为临时容器来处理属性存取的逻辑，例如如下案例中，对于info执行的操作是set存储以及读取的操作，这里更好的方式是采用标准内置Map以及基础类库提供的高性能容器类如HashMap。HashMap是ArkTS提供的高性能容器类，底层使用红黑树实现，提供了高性能的数据读写操作，可以用来实现快速读写键值。

【反例】

class InfoUtil {
  getInfo(t1: string, t2: string): string {
    if (t1 === t2) {
      return "";
    }
    // 此处使用Record普通对象作为容器
    let info: Record<string, string> = {};
    this.setInfo(info);
    let t3 = info[t2];
    return (t3 != null) ? t3 : "";
  }

  setInfo(info: Record<string, string>) {
    // 接口内部实际上进行的是map的操作
    info.aaa = 'aaa';
    info.bbb = 'bbb';
    info.ccc = 'ccc';
  }
}

【正例】

import HashMap from '@ohos.util.HashMap';

class InfoUtil {
  getInfo(t1: string, t2: string): string {
    if (t1 === t2) {
      return "";
    }
    // 此处改为使用HashMap进行读写操作
    let info: HashMap<string, string> = new HashMap();
    this.setInfo(info);
    let t3 = info.get(t2);
    return (t3 != null) ? t3 : "";
  }
  setInfo(info:HashMap<string, string>) {
    // ...
    info.set('aaa','aaa');
    info.set('bbb','bbb');
    info.set('ccc','ccc');
  }
}

避免造成稀疏数组

分配数组时，需要避免使用如下的方式进行处理。当虚拟机在分配大小超过1024大小的数组时，会变成用哈希表来存储元素，相对数组用偏移来访问元素速度较慢，在开发时，尽量避免数组变成稀疏数组。

【反例】

// 下面情形会变成稀疏数组
// 1. 直接分配100000大小的数组，虚拟机会处理成用hash表来存储元素
let count = 100000;
let result: number[] = new Array(count);
// 2. 分配数组之后直接，在9999处初始化，会变成稀疏数组
result[9999] = 0;

函数声明与使用

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

能传递参数的尽量传递参数，不要使用闭包，闭包作为参数会多一次闭包的创建和访问。在普通函数中，修改外部作用域的变量时，建议通过函数的参数传递，因为在直接声明时引用外部作用域的变量，如果没有及时清理，可能有内存泄漏的风险。ArkTS中函数参数是引用类型时，作用于引用类型的修改会进行引用传递，函数内对形参的修改也会作用在实参上。

【反例】

const arr:number[] = [0, 1, 2];
function foo() {
  arr[0] = 1;
  // arr 保持对外部变量的使用
  return arr[0] + arr[1];
}
let aFoo = foo;
aFoo();

【正例】

let arr: number[] = [0, 1, 2];
// 改为通过参数传递
function foo(array: Array<number>): number {
  array[0] = 1;
  return array[0] + array[1];
}

foo(arr);

减少使用嵌套export */import *的方式

减少使用嵌套export *的方式全量导出

【反例】在使用export *导出方法时，中间不要嵌套多层文件，层层不断导出“export * from …”

// Numbers.ets
export const One: number = 1;

// ...
// 此处嵌套多层export *

// Utils.ets
export * from './Numbers';

// SecondPage.ets
export * from './Utils';

// Index.ets
import * from './SecondPage';

Numbers文件导出变量One，需要在Index.ets中使用，但在Utils文件中export * from ‘./Numbers’，在SecondPage文件再次 export * from ‘./Utils’，中间嵌套多层导出文件，直到最后在实际引用方Index.ets文件中 import * from ‘./SecondPage’。

【正例】优化后，去掉冗余嵌套的export，即在Index.ets中直接import { One } from ‘./Numbers’

// Numbers.ets
export const One: number = 1;

// Index.ets
import { One } from './Numbers';

由于依赖模块解析采用深度优先遍历的方式来遍历模块依赖关系图中每一个模块记录，会先从入口文件的第一个导入语句开始一层层往更深层查找，直到最后一个没有导入语句的模块为止，连接好这个模块的导出变量之后又会回到上一级的模块重复这个步骤，因此多层export *的使用会导致依赖模块解析、文件执行阶段耗时增长。

减少import *的方式全量引用

应用程序加载过程中，需要使用不同模块中的变量或函数，通常开发者会将相同类型的变量或函数放在同一个工具类文件中，使用时通过import的方式引入对应的模块，当工具类中存在较多暴露函数或变量时，推荐按需引用使用到的变量代替“import *”的方式，可以减少该阶段中.ets文件执行耗时，即减少文件中所有export变量的初始化过程。

【反例】Index.ets中使用“import * as nm from ‘…/utils/Numbers’”。

// Index.ets
import * as nm from '../utils/Numbers'; // 不推荐import *的方式
hilog.info(0x0000, 'testTag', '%{public}d', nm.One); // 此处仅用到变量One
// Numbers.ets
export const One: number = 1;
export const Two: number = 2;
// ...
// 此处省略100000条数据

【正例】Index.ets中使用“import { One } from ‘…/utils/Numbers’”。

// Index.ets
import { One } as nm from '../utils/Numbers'; // 推荐按需引用变量
hilog.info(0x0000, 'testTag', '%{public}d', One); // 此处仅用到变量One
// Numbers.ets
export const One: number = 1;
export const Two: number = 2;
// ...
// 此处省略100000条数据

延迟加载Lazy-Import使用指导

随着应用功能持续增加，应用规模不断扩大，依赖的模块文件逐渐变多，应用冷启动加载模块的时间也越来越长。而在实际冷启动过程中执行了很多应用整体依赖但当前未使用的文件，此时可以通过延迟加载 [Lazy-Import] 的方法延缓对这些冗余文件的加载，使待加载文件在冷启动阶段不被加载，而在后续导出变量被真正使用时再同步加载执行文件，节省资源以提高应用冷启动性能。

Lazy-Import与动态加载的区别

Lazy-Import与动态加载都可以实现主动延后特定文件的执行时间，帮助设备均摊性能消耗，缓解特定时段性能压力的能力。

	动态加载	Lazy-Import
语法示例	let A= await import(“./A”);	import lazy { A } from “./A”
性能开销	1. 创建异步任务开销。

1. 执行到动态加载时，触发依赖模块的模块解析+源码执行。 | 1. Lazy-Import的模块解析耗时在冷启动依旧会触发遍历。
2. 导入的变量A被使用到时，触发模块的源码执行。 |
   | 使用位置 | 代码块/运行逻辑中使用 | 需要写在源码开头 |
   | 是否可以运行时拼接待加载模块名 | 是 | 否 |
   | 加载时序 | 异步 | 同步 |

开发者在使用动态加载时，需要将静态加载的代码（同步导入）改写成动态加载语法（异步导入），修改量较大。其次如果希望通过动态加载在冷启动阶段产生优化，需要开发者明确感知被动态加载文件不会在冷启动被执行才会有收益，否则会增大冷启动开销（放入异步队列等）。相较于动态加载，使用Lazy-Import延迟加载，开发者只需要在import语法中增加lazy关键字就可以实现延迟加载，使用更加方便。

使用场景

下述例子中A文件被引用，在应用启动到点击按钮的这段时间里，A文件并没有被实际执行，在冷启动阶段加载A文件的行为属于冗余。

// A为任意可以被引入的ets文件
import { A } from "./A"

@Entry
@Component
struct Index {
  build() {
    RelativeContainer() {
      Button('点击执行A')
        .onClick(() => {
          console.log('执行A' + A)
        })
    }
    // ...
  }
}

通过抓取Trace图查看调用栈可发现，应用在冷启动时加载了A文件。

使用方法

ArkTS冗余文件检测 工具

在规避冗余文件时，首先需要筛选出哪些依赖文件在冷启动时未被使用，此时可以使用ArkTS冗余文件检测工具，梳理出冷启动加载过程中未被使用的文件名单。

工具使用

1. 打开模块化日志打印打点开关，重启设备。

    hdc shell param set persist.ark.properties 0x200105c
    hdc shell reboot

1. 启动应用，启动结束后关闭应用。

2. 下载文件到本地，其中${bundleName}为应用名。

   hdc file recv data/app/el2/100/base/${bundleName}/files/${bundleName}_redundant_file.txt D:\
   pause

1. 对上述示例代码获取到的文件进行分析。

   

   大致结构：

   1. Summary ：加载各项文件的总耗时。
   2. used file：冷启动2s内应用使用到的文件。
   3. unused file：冷启动2S内应用没有使用的文件（即冷启动阶段可延迟加载的文件）。

Lazy-Import示例

在通过工具筛选出冗余文件后，开发者可选择在引入时添加 lazy 关键字对文件进行标识，表示该文件可被延迟加载。

import lazy { A } from "./A"

@Entry
@Component
struct Index {
  build() {
    RelativeContainer() {
      Button('点击执行A')
        .onClick(() => {
          console.log('执行A' + A)
        })
    }
    .height('100%')
    .width('100%')
  }
}

通过抓取Trace图查看调用栈可发现，使用Lazy-Import标识后，应用在冷启动时不再加载A文件。

说明

1. 由于Lazy-Import的后续加载是同步加载，可能在某些场景阻塞任务执行（比如在点击业务时触发了懒加载，那么运行时会执行冷启动为加载的文件，增加执行耗时，存在掉帧风险），是否使用延迟加载仍需要开发者自行评估。
2. 不推荐开发者在未根据实际业务梳理出可延迟文件时盲目增加延迟加载，过多的延迟加载同样会增大编译及运行时的识别开销。
3. 已经被动态加载的文件同时使用Lazy-Import时，这些文件会执行lazy标识，在动态加载的then逻辑中同步加载。

性能分析

	加载文件耗时（微秒us）
优化前	412us
优化后	350us

根据上述优化前后案例Trace图对比分析，使用延迟加载后应用冷启动时不再加载A文件，在资源加载阶段减少因加载冗余文件产生的耗时约15%，提高了应用冷启动性能。（由于案例仅演示场景，优化数据仅做参考，在实际业务中随着引用文件的复杂度提高，引用文件数量增多，优化效果也会随之提升。）