鸿蒙Next ArkTS高性能编程实战

一、引言

在应用开发中，高性能编程对于提升用户体验至关重要。本文将详细介绍鸿蒙Next ArkTS在高性能编程方面的实践经验，包括声明与表达式、函数、数组以及异常处理等方面的优化技巧，助力开发者打造高效能的应用。

二、声明与表达式

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

在编程过程中，对于那些在后续代码中不会发生改变的变量，应使用const进行声明。这样做不仅可以使代码意图更加清晰，还能帮助编译器进行优化。例如：

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

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

ArkTS运行时在优化时会区分整型和浮点型数据，因此建议在初始化后避免改变number类型变量的数据类型。例如：

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

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

（三）数值计算避免溢出

在进行数值计算时，要特别注意可能导致溢出的情况。常见的溢出场景包括加法、减法、乘法、指数运算以及&（and）、>>>（无符号右移）等运算操作。溢出会导致引擎进入慢速的溢出逻辑分支处理，影响性能。因此，应确保数值在合适的范围内，避免大于INT32_MAX或小于INT32_MIN（对于某些运算操作，如&、>>>等，应避免大于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;
}

// 优化后代码
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);

（二）避免使用可选参数

函数的可选参数表示参数可能为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数据结构。它能够提供更好的性能表现。例如：

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

（二）避免使用稀疏数组

当运行时分配超过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
}