HarmonyOS：ArkTS高性能编程实践

一、声明与表达式

使用const声明不变的变量
不变的变量推荐使用const声明。

const index = 10000; // 该变量在后续过程中未发生改变，建议声明成常量

number类型变量避免整型和浮点型混用
针对number类型，运行时在优化时会区分整型和浮点型数据。建议避免在初始化后改变数据类型。

export function test1() {
  let intNum = 1;
  intNum = 1.1; // 该变量在声明时为整型数据，建议后续不要赋值浮点型数据

  let doubleNum = 1.1;
  doubleNum = 1; // 该变量在声明时为浮点型数据，建议后续不要赋值整型数据

  console.log(`number类型变量避免整型和浮点型混用：intNum = ${intNum} ， doubleNum = ${doubleNum}`);
}

数值计算避免溢出
常见的可能导致溢出的数值计算包括如下场景，溢出之后，会导致引擎走入慢速的溢出逻辑分支处理，影响后续的性能。

• 针对加法、减法、乘法、指数运算等运算操作，应避免数值大于INT32_MAX或小于INT32_MIN。
• 针对&（and）、>>>（无符号右移）等运算操作，应避免数值大于INT32_MAX。

循环中常量提取，减少属性访问次数
在循环中会大量进行一些常量的访问操作，如果该常量在循环中不会改变，可以提取到循环外部，减少属性访问的次数。

class Time {
  static start: number = 0;
  static info: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
}

function getNum(num: number): number {
  let total: number = 348;
  let actionCount = 0;
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    // 此处会多次对Time的info及start进行查找，并且每次查找出来的值是相同的
    actionCount++
    total += ((Time.info[num - Time.start] & index) !== 0) ? 1 : 0;
  }
  console.log("getNum 方法返回的 total = " + total + " , 共循环次数 actionCount = " + actionCount)
  return total;
}

效果图

优化后代码如下，可以将Time.info[num - Time.start]进行常量提取操作，这样可以大幅减少属性的访问次数，性能收益明显。

export function getNum2(num: number): number {
  let total: number = 348;
  let actionCount = 0;
  let actionTotalAddCount = 0;
  const info = Time.info[num - Time.start]; // 从循环中提取不变量
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    actionCount++
    if ((info & index) != 0) {
      actionTotalAddCount++;
      total++;
    }
  }
  console.log("getNum2 方法返回的 total = " + total + " , 共循环次数 actionCount = " + actionCount +
    " , total 自增次数 actionTotalAddCount = " + actionTotalAddCount)

  return total;
}

效果图

二、函数

建议使用参数传递函数外的变量
使用闭包会造成额外的闭包创建和访问开销。在性能敏感场景中，建议使用参数传递函数外的变量来替代使用闭包。

let arr = [0, 1, 2];

function foo(): number {
  return arr[0] + arr[1];
}

foo();

建议使用参数传递函数外的变量来，替代使用闭包。

let arr = [0, 1, 2];

function foo(array: number[]): number {
  return array[0] + array[1];
}

foo(arr);

避免使用可选参数
函数的可选参数表示参数可能为undefined，在函数内部使用该参数时，需要进行非空值的判断，造成额外的开销。

function add(left?: number, right?: number): number | undefined {
  if (left != undefined && right != undefined) {
    return left + right;
  }
  return undefined;
}

根据业务需要，将函数参数声明为必须参数。可以考虑使用默认参数。

function add(left: number = 0, right: number = 0): number {
  return left + right;
}

三、数组

数值数组推荐使用TypedArray
如果是涉及纯数值计算的场合，推荐使用TypedArray数据结构。

优化前

export function testNoTypedArray() {
  const arr1: Array<number> = [1, 2, 3];
  const arr2: Array<number> = [4, 5, 6];
  let res = new Array<number>(3);
  for (let i = 0; i < 3; i++) {
    res[i] = arr1[i] + arr2[i];
  }
}

优化后

export function testTypedArray() {
  const typedArray1 = new Int8Array([1, 2, 3]);
  const typedArray2 = new Int8Array([4, 5, 6]);
  let res = new Int8Array(3);
  for (let i = 0; i < 3; i++) {
    res[i] = typedArray1[i] + typedArray2[i];
  }
}

效果图

避免使用稀疏数组
运行时在分配超过1024大小的数组或者针对稀疏数组，会采用hash表的方式来存储元素。在该模式下，相比于用偏移访问数组元素速度较慢。在代码开发时，应尽量避免数组变成稀疏数组。

export function testHashArray() {
  // 直接分配100000大小的数组，运行时会处理成用hash表来存储元素
  let count = 100000;
  let result1: number[] = new Array(count);

  // 创建数组后，直接在9999处赋值，会变成稀疏数组
  let result2: number[] = new Array();
  result2[9999] = 0;
}

避免使用联合类型数组
避免使用联合类型数组。避免在数值数组中混合使用整型数据和浮点型数据。

export function testUnion() {
  let arrNum: number[] = [1, 1.1, 2];  // 数值数组中混合使用整型数据和浮点型数据

  let arrUnion: (number | string)[] = [1, 'hello'];  // 联合类型数组
}

根据业务需要，将相同类型的数据放置在同一数组中。

let arrInt: number[] = [1, 2, 3];
let arrDouble: number[] = [0.1, 0.2, 0.3];
let arrString: string[] = ['hello', 'world'];

四、异常

避免频繁抛出异常
创建异常时会构造异常的栈帧，造成性能损耗。在性能敏感场景下，例如在for循环语句中，避免频繁抛出异常。

优化前

function div(a: number, b: number): number {
  if (a <= 0 || b <= 0) {
    throw new Error('Invalid numbers.')
  }
  return a / b
}

function sum(num: number): number {
  let sum = 0
  try {
    for (let t = 1; t < 100; t++) {
      sum += div(t, num)
    }
  } catch (e) {
    console.log(e.message)
  }
  return sum
}

优化后

function div2(a: number, b: number): number {
  if (a <= 0 || b <= 0) {
    return NaN
  }
  return a / b
}

function sum2(num: number): number {
  let sum = 0
  for (let t = 1; t < 100; t++) {
    if (t <= 0 || num <= 0) {
      console.log('Invalid numbers.')
    }
    sum += div(t, num)
  }
  return sum
}

五、示例代码

TestHighPerformance.ets

/**
 number类型变量避免整型和浮点型混用
 针对number类型，运行时在优化时会区分整型和浮点型数据。建议避免在初始化后改变数据类型。
 */
export function test1() {
  let intNum = 1;
  intNum = 1.1; // 该变量在声明时为整型数据，建议后续不要赋值浮点型数据

  let doubleNum = 1.1;
  doubleNum = 1; // 该变量在声明时为浮点型数据，建议后续不要赋值整型数据

  console.log(`number类型变量避免整型和浮点型混用：intNum = ${intNum} ， doubleNum = ${doubleNum}`);
}

/*
循环中常量提取，减少属性访问次数
在循环中会大量进行一些常量的访问操作，如果该常量在循环中不会改变，可以提取到循环外部，减少属性访问的次数。
 */

class Time {
  static start: number = 0;
  static info: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
}

function getNum(num: number): number {
  let total: number = 348;
  let actionCount = 0;
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    // 此处会多次对Time的info及start进行查找，并且每次查找出来的值是相同的
    actionCount++
    total += ((Time.info[num - Time.start] & index) !== 0) ? 1 : 0;
  }
  console.log("getNum 方法返回的 total = " + total + " , 共循环次数 actionCount = " + actionCount)
  return total;
}

//优化后代码如下，可以将Time.info[num - Time.start]进行常量提取操作，这样可以大幅减少属性的访问次数，性能收益明显。
export function getNum2(num: number): number {
  let total: number = 348;
  let actionCount = 0;
  let actionTotalAddCount = 0;
  const info = Time.info[num - Time.start]; // 从循环中提取不变量
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    actionCount++
    if ((info & index) != 0) {
      actionTotalAddCount++;
      total++;
    }
  }
  console.log("getNum2 方法返回的 total = " + total + " , 共循环次数 actionCount = " + actionCount +
    " , total 自增次数 actionTotalAddCount = " + actionTotalAddCount)

  return total;
}


/*
函数

建议使用参数传递函数外的变量
使用闭包会造成额外的闭包创建和访问开销。在性能敏感场景中，建议使用参数传递函数外的变量来替代使用闭包。
 */
let arr = [0, 1, 2];

export function foo(): number {
  return arr[0] + arr[1];
}

//建议使用参数传递函数外的变量来，替代使用闭包。
export function foo2(array: number[]): number {
  return array[0] + array[1];
}

/*
避免使用可选参数
函数的可选参数表示参数可能为undefined，在函数内部使用该参数时，需要进行非空值的判断，造成额外的开销。
 */

function add(left?: number, right?: number): number | undefined {
  if (left != undefined && right != undefined) {
    return left + right;
  }
  return undefined;
}

//根据业务需要，将函数参数声明为必须参数。可以考虑使用默认参数。
function add2(left: number = 0, right: number = 0): number {
  return left + right;
}


/*
数组
数值数组推荐使用TypedArray
如果是涉及纯数值计算的场合，推荐使用TypedArray数据结构。
 */

// 优化前
export function testNoTypedArray() {
  const arr1: Array<number> = [1, 2, 3];
  const arr2: Array<number> = [4, 5, 6];
  let res = new Array<number>(3);
  for (let i = 0; i < 3; i++) {
    res[i] = arr1[i] + arr2[i];
  }
}

// 优化后
export function testTypedArray() {
  const typedArray1 = new Int8Array([1, 2, 3]);
  const typedArray2 = new Int8Array([4, 5, 6]);
  let res = new Int8Array(3);
  for (let i = 0; i < 3; i++) {
    res[i] = typedArray1[i] + typedArray2[i];
  }
  console.log(`testTypedArray 方法 res = ${res}`);
}

/*
  避免使用稀疏数组
运行时在分配超过1024大小的数组或者针对稀疏数组，会采用hash表的方式来存储元素。在该模式下，相比于用偏移访问数组元素速度较慢。在代码开发时，应尽量避免数组变成稀疏数组。
 */

export function testHashArray() {
  // 直接分配100000大小的数组，运行时会处理成用hash表来存储元素
  let count = 100000;
  let result1: number[] = new Array(count);

  // 创建数组后，直接在9999处赋值，会变成稀疏数组
  let result2: number[] = new Array();
  result2[9999] = 0;
}

/*
避免使用联合类型数组
避免使用联合类型数组。避免在数值数组中混合使用整型数据和浮点型数据。
 */

export function testUnion() {
  let arrNum: number[] = [1, 1.1, 2];  // 数值数组中混合使用整型数据和浮点型数据

  let arrUnion: (number | string)[] = [1, 'hello'];  // 联合类型数组
}

// 根据业务需要，将相同类型的数据放置在同一数组中。
let arrInt: number[] = [1, 2, 3];
let arrDouble: number[] = [0.1, 0.2, 0.3];
let arrString: string[] = ['hello', 'world'];


/*
异常
避免频繁抛出异常
创建异常时会构造异常的栈帧，造成性能损耗。在性能敏感场景下，例如在for循环语句中，避免频繁抛出异常。
 */

//优化前
function div(a: number, b: number): number {
  if (a <= 0 || b <= 0) {
    throw new Error('Invalid numbers.')
  }
  return a / b
}

function sum(num: number): number {
  let sum = 0
  try {
    for (let t = 1; t < 100; t++) {
      sum += div(t, num)
    }
  } catch (e) {
    console.log(e.message)
  }
  return sum
}

// 优化后
function div2(a: number, b: number): number {
  if (a <= 0 || b <= 0) {
    return NaN
  }
  return a / b
}

function sum2(num: number): number {
  let sum = 0
  for (let t = 1; t < 100; t++) {
    if (t <= 0 || num <= 0) {
      console.log('Invalid numbers.')
    }
    sum += div(t, num)
  }
  return sum
}

export class TestHighPerformanceExample {
  test() {
    // test1()
    // getNum(6)
    // getNum2(6)
    // foo();
    // foo2(arr);
    testTypedArray();
  }
}