ArkTS 高性能编程实践指南

一、引言

在应用开发中，性能是至关重要的因素。本文聚焦于 ArkTS 高性能编程实践，提供一系列在应用性能敏感场景下的编程建议，旨在帮助开发者打造高效能的应用。通过遵循这些建议，开发者能够在实现业务功能的同时，优化代码性能，提升用户体验。

二、声明与表达式

（一）使用 const 声明不变的变量

对于在后续过程中不会发生改变的变量，推荐使用 const 进行声明。例如：

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

这样做有助于编译器进行优化，提高代码执行效率。

（二）number 类型变量避免整型和浮点型混用

在 ArkTS 中，number 类型在运行时优化会区分整型和浮点型数据。因此，建议在变量声明后不要改变其数据类型。例如：

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

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

保持数据类型的一致性可以避免不必要的类型转换开销，提升性能。

（三）数值计算避免溢出

某些数值计算可能导致溢出，进而使引擎进入慢速的溢出逻辑分支处理，影响性能。在进行加法、减法、乘法、指数运算等操作时，应确保数值在 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;
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    // 此处会多次对 Time 的 info 及 start 进行查找，并且每次查找出来的值是相同的
    total += ((Time.info[num - Time.start] & index)!== 0)? 1 : 0;
  }
  return total;
}

// 优化后代码
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;
  const info = Time.info[num - Time.start];  // 从循环中提取不变量
  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
    if ((info & index)!= 0) {
      total++;
    }
  }
  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);

这种方式可以减少不必要的开销，提高函数执行效率。

（二）避免使用可选参数

函数的可选参数在函数内部使用时需要进行非空值判断，这会造成额外的开销。例如：

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 数据结构。例如：

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

// 优化后
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];
}

TypedArray 能够提供更高效的数值处理能力，提升计算性能。

（二）避免使用稀疏数组

当运行时分配超过 1024 大小的数组或处理稀疏数组时，会采用 hash 表的方式存储元素，这种方式相比于偏移访问数组元素速度较慢。因此，在开发过程中应尽量避免数组变为稀疏数组。例如：

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

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

注意数组的创建和赋值方式，防止出现稀疏数组情况。

（三）避免使用联合类型数组

应避免在数值数组中混合使用整型数据和浮点型数据，以及使用联合类型数组。例如：

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 div(a: number, b: number): number {
  if (a <= 0 || b <= 0) {
    return NaN
  }
  return a / b
}

function sum(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
}

通过合理处理错误情况，减少异常抛出次数，可以提升代码性能。

遵循以上 ArkTS 高性能编程实践建议，开发者能够在开发过程中有效优化代码性能，提升应用的整体质量和用户体验。在实际项目中，应根据具体业务场景和性能需求，灵活运用这些技巧，打造高效稳定的应用程序。