• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# ArkTS高性能编程实践
2
3<!--Kit: ArkTS-->
4<!--Subsystem: ArkCompiler-->
5<!--Owner: @zhanyi819-->
6<!--Designer: @qyhuo32-->
7<!--Tester: @kirl75; @zsw_zhushiwei-->
8<!--Adviser: @zhang_yixin13-->
9
10## 概述
11
12本文提供应用性能敏感场景下的高性能编程建议，帮助开发者编写高性能应用。高性能编程实践是在开发过程中总结的一些高性能写法和建议。在实现业务功能时，应同步思考并理解高性能写法的原理，并将其应用于代码逻辑中。关于ArkTS编程规范，请参考[ArkTS编程规范](./arkts-coding-style-guide.md)。
13
14## 声明与表达式
15
16### 使用`const`声明不变的变量
17
18不变的变量推荐使用`const`声明。
19
20``` TypeScript
21const index = 10000; // 该变量在后续过程中未发生改变，建议声明成常量
22```
23
24
25### `number`类型变量避免整型和浮点型混用
26
27针对`number`类型，运行时在优化时会区分整型和浮点型数据。建议避免在初始化后改变数据类型。
28
29``` TypeScript
30let intNum = 1;
31intNum = 1.1;  // 该变量在声明时为整型数据，建议后续不要赋值浮点型数据
32
33let doubleNum = 1.1;
34doubleNum = 1;  // 该变量在声明时为浮点型数据，建议后续不要赋值整型数据
35```
36
37
38### 数值计算避免溢出
39
40常见的可能导致溢出的数值计算包括如下场景，溢出之后，会导致引擎走入慢速的溢出逻辑分支处理，影响后续的性能。
41
42- 针对加法、减法、乘法、指数运算等运算操作，应避免数值大于INT32_MAX（2147483647）或小于INT32_MIN（-2147483648）。
43
44- 针对&（and）、>>>（无符号右移）等运算操作，应避免数值大于INT32_MAX。
45
46
47### 循环中常量提取，减少属性访问次数
48
49如果常量在循环中不会改变，可以将其提取到循环外部，减少访问次数。
50
51``` TypeScript
52class Time {
53  static start: number = 0;
54  static info: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
55}
56
57function getNum(num: number): number {
58  let total: number = 348;
59  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
60    // 此处会多次对Time的info及start进行查找，并且每次查找出来的值是相同的
61    total += ((Time.info[num - Time.start] & index) !== 0) ? 1 : 0;
62  }
63  return total;
64}
65```
66
67优化后的代码如下，可以将`Time.info[num - Time.start]`提取为常量，这样可以显著减少属性访问次数，提升性能。
68
69``` TypeScript
70class Time {
71  static start: number = 0;
72  static info: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
73}
74
75function getNum(num: number): number {
76  let total: number = 348;
77  const info = Time.info[num - Time.start];  // 从循环中提取不变量
78  for (let index: number = 0x8000; index > 0x8; index >>= 1) {
79    if ((info & index) != 0) {
80      total++;
81    }
82  }
83  return total;
84}
85```
86
87
88## 函数
89
90### 建议使用参数传递函数外的变量
91
92使用闭包会造成额外的开销。在性能敏感场景中，建议使用参数传递函数外的变量替代。
93
94``` TypeScript
95let arr = [0, 1, 2];
96
97function foo(): number {
98  return arr[0] + arr[1];
99}
100
101foo();
102```
103
104建议使用参数传递函数外部的变量，以替代使用闭包。
105``` TypeScript
106let arr = [0, 1, 2];
107
108function foo(array: number[]): number {
109  return array[0] + array[1];
110}
111
112foo(arr);
113```
114
115
116### 避免使用可选参数
117
118函数的可选参数表示参数可能为`undefined`，在函数内部使用该参数时，需要进行非空值的判断，造成额外的开销。
119
120``` TypeScript
121function add(left?: number, right?: number): number | undefined {
122  if (left != undefined && right != undefined) {
123    return left + right;
124  }
125  return undefined;
126}
127```
128
129根据业务需求，将函数参数声明为必选参数。考虑使用默认参数。
130``` TypeScript
131function add(left: number = 0, right: number = 0): number {
132  return left + right;
133}
134```
135
136
137## 数组
138
139### 数值数组推荐使用TypedArray
140
141涉及纯数值计算时，推荐使用TypedArray数据结构。
142
143优化前的代码示例：
144``` TypeScript
145const arr1 = new Array<number>(1, 2, 3);
146const arr2 = new Array<number>(4, 5, 6);
147let res = new Array<number>(3);
148for (let i = 0; i < 3; i++) {
149  res[i] = arr1[i] + arr2[i];
150}
151```
152
153优化后的代码示例：
154``` TypeScript
155const typedArray1 = Int8Array.from([1, 2, 3]);
156const typedArray2 = Int8Array.from([4, 5, 6]);
157let res = new Int8Array(3);
158for (let i = 0; i < 3; i++) {
159  res[i] = typedArray1[i] + typedArray2[i];
160}
161```
162
163
164### 避免使用稀疏数组
165
166运行时在分配超过1024大小的数组或稀疏数组时，会采用hash表来存储元素。在该模式下，访问数组元素速度较慢。代码开发时应避免数组变成稀疏数组。
167
168``` TypeScript
169// 直接分配100000大小的数组，运行时会处理成用hash表来存储元素
170let count = 100000;
171let result: number[] = new Array(count);
172
173// 创建数组后，直接在9999处赋值，会变成稀疏数组
174let result: number[] = new Array();
175result[9999] = 0;
176```
177
178
179### 避免使用联合类型数组
180
181避免使用联合类型数组。避免在数值数组中混合使用整型数据和浮点型数据。
182
183``` TypeScript
184let arrNum: number[] = [1, 1.1, 2];  // 数值数组中混合使用整型数据和浮点型数据
185
186let arrUnion: (number | string)[] = [1, 'hello'];  // 联合类型数组
187```
188
189根据业务需求，将相同类型的数据放在同一数组中。
190``` TypeScript
191let arrInt: number[] = [1, 2, 3];
192let arrDouble: number[] = [0.1, 0.2, 0.3];
193let arrString: string[] = ['hello', 'world'];
194```
195
196
197## 异常
198
199### 避免频繁抛出异常
200
201创建异常时会构造异常的栈帧，造成性能损耗。在性能敏感场景下，如`for`循环语句中，应避免频繁抛出异常。
202
203优化前的代码示例：
204
205``` TypeScript
206function div(a: number, b: number): number {
207  if (a <= 0 || b <= 0) {
208    throw new Error('Invalid numbers.');
209  }
210  return a / b;
211}
212
213function sum(num: number): number {
214  let sum = 0;
215  try {
216    for (let t = 1; t < 100; t++) {
217      sum += div(t, num);
218    }
219  } catch (e) {
220    console.info(e.message);
221  }
222  return sum;
223}
224```
225
226优化后的代码示例：
227
228``` TypeScript
229function div(a: number, b: number): number {
230  if (a <= 0 || b <= 0) {
231    return NaN;
232  }
233  return a / b;
234}
235
236function sum(num: number): number {
237  let sum = 0;
238  for (let t = 1; t < 100; t++) {
239    if (num <= 0) {
240      console.info('Invalid numbers.');
241    }
242    sum += div(t, num);
243  }
244  return sum;
245}
246```
247