JavaScript 性能优化（上篇）

Howardxu
259 阅读7分钟 
如何编写高性能的JavaScript

内容概要

  • 内存管理
  • 垃圾lknhgn常见GC算法
  • v8引擎的垃圾回收
  • Performance 工具
  • 代码优化实例

JavaScript中的内存管理

  • 申请内存空间
  • 使用内存空间
  • 释放内存空间

JavaScript中的垃圾

  • JavaScript中内存管理是自动的
  • 对象不再被引用时是垃圾
  • 对象不能从根上访问到时是垃圾 JavaScript中的可达对象
  • 可以访问到的对象就是可达对象（引用、作用域链）
  • 可达的标准就是从根出发是否能够被找到
  • JavaScript中的根可以理解为是全局变量对象

GC算法介绍

  • GC就是垃圾回收机制的简写
  • GC可以找到内存中的垃圾并释放和回收空间

GC里的垃圾是什么

  • 程序中不再需要使用的对象
function func(){
  name = 'lg'
  return `${name} is a coder`
}
func()
  • 程序中不能再访问到的对象
function func(){
  const name = 'lg'
  return `${name} is a coder`
}
func()

GC算法是什么

  • GC是一种机制，垃圾回收器完成具体的工作
  • 工作的内容就是查找垃圾释放空间、回收空间
  • 算法就是工作时查找和回收所遵循的规则

常见GC算法

  • 引用计数
  • 标记清除
  • 标记整理
  • 分代回收

引用计数算法

实现原理

  • 核心思想： 设置引用数，判断当前引用数是否为0
  • 引用计数器
  • 引用关系改变时修改引用数字
  • 引用数字为0立即回收

总结

  • 优点：
    • 发现垃圾时立即回收
    • 最大限度减少程序暂停
  • 缺点：
    • 无法回收循环引用的对象（计数一直不为0）
    • 时间开销大
function fn() {
  const obj1 = {}
  const obj2 = {}
  obj1.name = obj2
  obj2.name = obj1
  return 'circlar object'
}

标记清除算法

实现原理

  • 核心思想： 分标记和清除两个阶段完成
  • 遍历所有对象找标记活动对象
  • 遍历所有对象清除没有标记对象
  • 回收相应的空间

总结

  • 优点：

    • 可以回收循环引用的对象

  • 缺点：

    • 空间碎片化，空间无法最大化使用
    • 不能立即回收垃圾

标记整理算法

实现原理

  • 标记整理可以看做是标记清除的增强
  • 标记阶段的操作和标记清除一致
  • 清除阶段会先执行整理，移动对象位置 回收前 整理后 回收后

总结

  • 优点：-----
  • 缺点：------

常见GC算法总结

引用计数优缺点

  • 可以即时回收垃圾对象
  • 减少程序卡顿时间
  • 无法回收循环引用的对象
  • 资源消耗较大

标记清除优缺点

  • 可以回收循环引用的对象
  • 容易产生碎片化空间，浪费空间
  • 不会立即回收垃圾对象

标记整理优缺点

  • 减少碎片化空间
  • 不会立即回收垃圾对象

认识V8

  • V8是一款主流的JavaScript执行引擎
  • V8采用即时编译
  • V8内存设限

V8垃圾回收策略

  • 采用分代回收的思想
  • 内存分为新生代、老生代
  • 针对不同对象采用不同算法 v8垃圾回收策略图示

V8中常用的GC算法

  • 分代回收
  • 空间复制
  • 标记清除
  • 标记整理
  • 标记增量

V8如何回收新生代对象

V8内存分配

  • 内存空间一分为二
  • 小空间用于存储新生代对象（32M | 16M）
  • 新生代指的是存活时间较短的对象

新生代对象回收实现

  • 回收过程采用复制算法+标记整理
  • 新生代内存区分为二个等大小空间
  • 使用空间为From，空闲空间为To
  • 活动对象存储于From空间
  • 标记整理后将活动对象拷贝至To
  • From与To交换空间完成释放

回收细节说明

  • 拷贝过程中可能出现晋升
  • 晋升就是将新生代对象移动至老生代
  • 一轮GC还存活的新生代需要晋升
  • To 空间的使用率超过25%

V8如何回收老生代对象

  • 老生代对象存放在右侧老生代区域
  • 64位操作系统1.4G，32位操作系统700M
  • 老生代对象就是指存活时间较长的对象

老生代对象回收实现

  • 主要采用标记清除、标记整理、增量标记算法
  • 首先使用标记清除完成垃圾空间的回收
  • 采用标记整理进行空间优化
  • 采用标记增量进行效率优化

新生代与老生代回收的细节对比

  • 新生代区域垃圾回收使用空间换时间
  • 老生代区域垃圾回收不适合复制算法

V8总结

  • V8是一款主流的JavaScript 执行引擎
  • V8内存设置上限
  • V8采用基于分代回收思想实现垃圾回收
  • V8内存分为新生代和老生代
  • V8垃圾回收常见的GC算法

Performance使用步骤

  • 打开浏览器输入目标网址
  • 进入开发人员工具面板，选择性能
  • 开启录制功能，访问具体页面
  • 执行用户行为，一段时间后停止录制
  • 分析界面中记录的内存信息

内存问题的外在表现

  • 页面出现延迟加载或经常性暂停
  • 页面持续性出现糟糕的性能
  • 页面的性能随时间延长越来越差

界定内存问题的标准

  • 内存泄露：内存使用持续升高
  • 内存膨胀：在多数设备上都存在性能问题
  • 频繁垃圾回收：通过内存变化图进行分析

监控内存的几种方式

  • 浏览器任务管理器

  • Timeline 时序图记录
  • 堆快照查找分离DOM
  • 判断是否存在频繁的垃圾回收
    • Timeline 中频繁的上升下降
    • 任务管理器中数据频繁的增加减小

总结

  • 通过Performance 使用流程
  • 内存问题的相关分析
  • Performance 时序图监控内存变化
  • 任务管理器监控内存变化
  • 堆块照查找分离DOM

代码优化

  • 本质上就是采集大量的执行样本进行数学统计和分析
  • 使用jsbench.me/ 来完成

慎用全局变量

  • 全局变量定义在全局执行上下文，是所有作用域链的顶端
  • 全局执行上下文一直存在于上下文执行栈，直到程序退出
  • 如果某个局部作用域出现了同名变量则会遮蔽或污染全局

缓存全局变量

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>缓存全局变量</title>
</head>
<body>
  <input type="button" value="btn" id="btn1">
  <input type="button" value="btn" id="btn2">
  <input type="button" value="btn" id="btn3">
  <input type="button" value="btn" id="btn4">
  <p>1111</p>
  <input type="button" value="btn" id="btn5">
  <input type="button" value="btn" id="btn6">
  <p>222</p>
  <input type="button" value="btn" id="btn7">
  <input type="button" value="btn" id="btn8">
  <p>333</p>
  <input type="button" value="btn" id="btn9">
  <input type="button" value="btn" id="btn10">

  <script>
    function getBtn() {
      let oBtn1 = document.getElementById('btn1')
      let oBtn3 = document.getElementById('btn3')
      let oBtn5 = document.getElementById('btn5')
      let oBtn7 = document.getElementById('btn7')
      let oBtn9 = document.getElementById('btn9')
    }
    //缓存全局变量，性能有所提高
    function getBtn2() {
      let obj = document
      let oBtn1 = obj.getElementById('btn1')
      let oBtn3 = obj.getElementById('btn3')
      let oBtn5 = obj.getElementById('btn5')
      let oBtn7 = obj.getElementById('btn7')
      let oBtn9 = obj.getElementById('btn9')
    }
  </script>

</body>
</html>

通过原型对象添加附加方法

// 构造函数添加方法
var fn1 = function() {
  this.foo = function() {
    console.log(11111)
  }
}

let f1 = new fn1()

// 原型对象添加附加方法，性能更好
var fn2 = function() {}
fn2.prototype.foo = function() {
  console.log(11111)
}

let f2 = new fn2()

避开闭包陷阱

闭包的特点

  • 外部具有指向内部的引用
  • 在“外”部作用域访问“内”部作用域的数据
function foo() {
  var name = 'lg'
  function fn() {
    console.log(name)
  }
  return fn
}
var a = foo()
a()

关于闭包

  • 闭包是一种强大的语法
  • 闭包使用不当很容易出现内存泄露
  • 不要为了闭包而闭包 使用闭包应该在使用结束后将相关变量置为null

避免属性访问方法使用

Javascript 中的面向对象

  • JS不需要属性的访问方法，所有属性都是外部可见的
  • 使用属性访问方法只会增加一层重定义，没有访问的控制力

function Person() {
  this.name = 'icoder'
  this.age = 18
  this.getAge = function() {
    return this.age
  }
}

const p1 = new Person()
const a = p1.getAge()



function Person() {
  this.name = 'icoder'
  this.age = 18
}
const p2 = new Person()
// 没有属性访问方法，直接读取属性即可
const b = p2.age

For循环优化

先缓存数组长度，遍历时就不需要多次获取数组长度了


var arrList = []
arrList[10000] = 'icoder'

for (var i = 0; i < arrList.length; i++) {
  console.log(arrList[i])
}
// 下面的代码性能更好 √
for (var i = arrList.length; i; i--) {
  console.log(arrList[i])
}

遍历数组


var arrList = new Array(1, 2, 3, 4, 5)

arrList.forEach(function(item) {
  console.log(item)
})

for (var i = arrList.length; i; i--) {
  console.log(arrList[i])
}

for (var i in arrList) {
  console.log(arrList[i])
}

三种方式， forEach最佳

文档碎片优化节点添加

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>优化节点添加</title>
</head>
<body>
  <script>
    // 通过循环去添加节点，操作了10次
    for (var i = 0; i < 10; i++) {
      var oP = document.createElement('p')
      oP.innerHTML = i 
      document.body.appendChild(oP)
    }

    const fragEle = document.createDocumentFragment()
    // 先生成文档片段
    for (var i = 0; i < 10; i++) {
      var oP = document.createElement('p')
      oP.innerHTML = i 
      fragEle.appendChild(oP)
    }
    // 然后添加节点，操作一次，性能更好
    document.body.appendChild(fragEle)

  </script>
</body>
</html>

克隆节点优化节点添加

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>克隆优化节点操作</title>
</head>
<body>
  <p id="box1">old</p>

  <script>

    for (var i = 0; i < 3; i++) {
      var oP = document.createElement('p')
      oP.innerHTML = i 
      document.body.appendChild(oP)
    }

    var oldP = document.getElementById('box1')
    for (var i = 0; i < 3; i++) {
      //克隆节点，减少操作，性能更好
      var newP = oldP.cloneNode(false)
      newP.innerHTML = i 
      document.body.appendChild(newP)
    }

  </script>

</body>
</html>

字面量替换new Object()

var a1 = new Array(3)
a1[0] = 1
a1[1] = 2
a1[2] = 3
var o1 = new Object({})
o1.name = 'John'
o1.age = 18

// 使用字面量，简单且性能更好
var a = [1, 2, 3]
var o = { name: 'John', age: 18 }
avatar
文章
阅读
粉丝