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