HarmonyOS——ArkTS高性能编程

大家好，我是青蓝逐码的云杰，今天我们聚焦于应用性能敏感场景下的高性能编程实践，为开发者提供编写高性能应用的具体建议。在实现业务功能时，开发者应深入理解高性能编程的原理，并将这些优化策略融入代码逻辑中。

目录

• 声明与表达式优化

• 函数性能优化

• 数组操作优化

• 异常处理优化

声明与表达式优化

使用 const 声明不变变量

对于不会改变的变量，推荐使用const声明以提升性能和代码可读性。

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

避免 number 类型整型与浮点型混用

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

// 反例：声明时为整型却赋值浮点型
let intNum = 1;
intNum = 1.1;  
// 反例：声明时为浮点型却赋值整型
let doubleNum = 1.1;
doubleNum = 1;  

数值计算避免溢出

数值溢出会导致引擎进入慢速处理逻辑，影响性能。需注意以下溢出场景：

• 加法、减法、乘法、指数运算：避免数值大于INT32_MAX（2147483647）或小于INT32_MIN（-2147483648）

• &（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) {
    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];
}

优化后（TypedArray）：

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 或为稀疏数组时，运行时会使用哈希表存储元素，导致访问效率下降：

// 反例1：直接分配大尺寸数组
let count = 100000;
let result: number[] = new Array(count);
// 反例2：创建稀疏数组
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'];

异常处理优化

避免频繁抛出异常

异常创建时会构造栈帧，产生性能损耗，在循环等性能敏感场景应避免：

优化前（循环内抛异常）：

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
}

总结

通过综合运用这些优化策略，能够有效提升代码性能，助力我们打造高效稳定的应用程序 。在实际开发中，我们还需结合具体业务场景，灵活运用这些技巧，持续对代码进行性能调优。

关于青蓝逐码组织

如果你兴趣想要了解更多的鸿蒙应用开发细节和最新资讯，甚至你想要做出一款属于自己的应用！欢迎在评论区留言或者私信，可以加入技术交流群。