简介

JS的性能没法和C++比，有些编码习惯会影响性能，优先选择高效的写法。
参考文章

高效写法

• 变量默认用const修饰，编译不过了改成let

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

• 避免整形和浮点型混用。既然这样，为什么不推出int和double关键字，非要弄个number？

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

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

• 循环中常量提取，减少属性访问次数

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);

• 避免使用可选参数，用默认参数替代

/// 函数的可选参数表示参数可能为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，既然这样，推出number类型的意义在哪里？恢复int和double不是更好？

/// 纯数字，用number性能低
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'];

• 避免频繁抛出异常

/// 创建异常时会构造异常的栈帧，造成性能损耗。
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
}

/// 用特殊值NaN替代异常，提高性能
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
}