JavaScript中的垃圾回收和内存泄漏

摘要： JS内存管理。

• 做者：浪里行舟

Fundebug经受权转载，版权归原做者全部。

前言

程序的运行须要内存。只要程序提出要求，操做系统或者运行时就必须供给内存。所谓的内存泄漏简单来讲是再也不用到的内存，没有及时释放。为了更好避免内存泄漏，咱们先介绍Javascript垃圾回收机制。

在C与C++等语言中，开发人员能够直接控制内存的申请和回收。可是在Java、C#、JavaScript语言中，变量的内存空间的申请和释放都由程序本身处理，开发人员不须要关心。也就是说Javascript具备自动垃圾回收机制(Garbage Collecation)。

1、垃圾回收的必要性

下面这段话引自《JavaScript权威指南（第四版）》

因为字符串、对象和数组没有固定大小，全部当他们的大小已知时，才能对他们进行动态的存储分配。JavaScript程序每次建立字符串、数组或对象时，解释器都必须分配内存来存储那个实体。只要像这样动态地分配了内存，最终都要释放这些内存以便他们可以被再用，不然，JavaScript的解释器将会消耗完系统中全部可用的内存，形成系统崩溃。

这段话解释了为何须要系统须要垃圾回收，JavaScript不像C/C++，它有本身的一套垃圾回收机制。

JavaScript垃圾回收的机制很简单：找出再也不使用的变量，而后释放掉其占用的内存，可是这个过程不是时时的，由于其开销比较大，因此垃圾回收器会按照固定的时间间隔周期性的执行。

var a = "浪里行舟";
var b = "前端工匠";
var a = b; //重写a

这段代码运行以后，“浪里行舟”这个字符串失去了引用（以前是被a引用），系统检测到这个事实以后，就会释放该字符串的存储空间以便这些空间能够被再利用。

2、垃圾回收机制

垃圾回收机制怎么知道，哪些内存再也不须要呢？

垃圾回收有两种方法：标记清除、引用计数。引用计数不太经常使用，标记清除较为经常使用。

1.标记清除

这是javascript中最经常使用的垃圾回收方式。当变量进入执行环境是，就标记这个变量为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，由于只要执行流进入相应的环境，就可能会用到他们。当变量离开环境时，则将其标记为“离开环境”。

垃圾收集器在运行的时候会给存储在内存中的全部变量都加上标记。而后，它会去掉环境中的变量以及被环境中的变量引用的标记。而在此以后再被加上标记的变量将被视为准备删除的变量，缘由是环境中的变量已经没法访问到这些变量了。最后。垃圾收集器完成内存清除工做，销毁那些带标记的值，并回收他们所占用的内存空间。

咱们用个例子，解释下这个方法：

var m = 0,n = 19 // 把 m,n,add() 标记为进入环境。
add(m, n) // 把 a, b, c标记为进入环境。
console.log(n) // a,b,c标记为离开环境，等待垃圾回收。
function add(a, b) {
  a++
  var c = a + b
  return c
}

2. 引用计数

所谓"引用计数"是指语言引擎有一张"引用表"，保存了内存里面全部的资源（一般是各类值）的引用次数。若是一个值的引用次数是0，就表示这个值再也不用到了，所以能够将这块内存释放。

上图中，左下角的两个值，没有任何引用，因此能够释放。

若是一个值再也不须要了，引用数却不为0，垃圾回收机制没法释放这块内存，从而致使内存泄漏。

var arr = [1, 2, 3, 4];
arr = [2, 4, 5]
console.log('浪里行舟');

上面代码中，数组[1, 2, 3, 4]是一个值，会占用内存。变量arr是仅有的对这个值的引用，所以引用次数为1。尽管后面的代码没有用到arr，它仍是会持续占用内存。至于如何释放内存，咱们下文介绍。

第三行代码中，数组[1, 2, 3, 4]引用的变量arr又取得了另一个值，则数组[1, 2, 3, 4]的引用次数就减1，此时它引用次数变成0，则说明没有办法再访问这个值了，于是就能够将其所占的内存空间给收回来。

可是引用计数有个最大的问题： 循环引用

function func() {
    let obj1 = {};
    let obj2 = {};

    obj1.a = obj2; // obj1 引用 obj2
    obj2.a = obj1; // obj2 引用 obj1
}

当函数 func 执行结束后，返回值为 undefined，因此整个函数以及内部的变量都应该被回收，但根据引用计数方法，obj1 和 obj2 的引用次数都不为 0，因此他们不会被回收。

要解决循环引用的问题，最好是在不使用它们的时候手工将它们设为空。上面的例子能够这么作：

obj1 = null;
obj2 = null;

3、哪些状况会引发内存泄漏？

虽然JavaScript会自动垃圾收集，可是若是咱们的代码写法不当，会让变量一直处于“进入环境”的状态，没法被回收。下面列一下内存泄漏常见的几种状况：

1. 意外的全局变量

function foo(arg) {
    bar = "this is a hidden global variable";
}

bar没被声明,会变成一个全局变量,在页面关闭以前不会被释放。

另外一种意外的全局变量可能由 this 建立:

function foo() {
    this.variable = "potential accidental global";
}
// foo 调用本身，this 指向了全局对象（window）
foo();

在 JavaScript 文件头部加上 'use strict'，能够避免此类错误发生。启用严格模式解析 JavaScript ，避免意外的全局变量。

2. 被遗忘的计时器或回调函数

var someResource = getData();
setInterval(function() {
    var node = document.getElementById('Node');
    if(node) {
        // 处理 node 和 someResource
        node.innerHTML = JSON.stringify(someResource));
    }
}, 1000);

这样的代码很常见，若是id为Node的元素从DOM中移除，该定时器仍会存在，同时，由于回调函数中包含对someResource的引用，定时器外面的someResource也不会被释放。

3. 闭包

function bindEvent(){
  var obj=document.createElement('xxx')
  obj.onclick=function(){
    // Even if it is a empty function
  }
}

闭包能够维持函数内局部变量，使其得不到释放。上例定义事件回调时，因为是函数内定义函数，而且内部函数--事件回调引用外部函数，造成了闭包。

// 将事件处理函数定义在外面
function bindEvent() {
  var obj = document.createElement('xxx')
  obj.onclick = onclickHandler
}
// 或者在定义事件处理函数的外部函数中，删除对dom的引用
function bindEvent() {
  var obj = document.createElement('xxx')
  obj.onclick = function() {
    // Even if it is a empty function
  }
  obj = null
}

解决之道，将事件处理函数定义在外部，解除闭包，或者在定义事件处理函数的外部函数中，删除对dom的引用。

4. 没有清理的DOM元素引用

有时，保存 DOM 节点内部数据结构颇有用。假如你想快速更新表格的几行内容，把每一行 DOM 存成字典（JSON 键值对）或者数组颇有意义。此时，一样的 DOM 元素存在两个引用：一个在 DOM 树中，另外一个在字典中。未来你决定删除这些行时，须要把两个引用都清除。

var elements = {
    button: document.getElementById('button'),
    image: document.getElementById('image'),
    text: document.getElementById('text')
};
function doStuff() {
    image.src = 'http://some.url/image';
    button.click();
    console.log(text.innerHTML);
}
function removeButton() {
    document.body.removeChild(document.getElementById('button'));
    // 此时，仍旧存在一个全局的 #button 的引用
    // elements 字典。button 元素仍旧在内存中，不能被 GC 回收。
}

虽然咱们用removeChild移除了button，可是还在elements对象里保存着#button的引用，换言之，DOM元素还在内存里面。

4、内存泄漏的识别方法

新版本的chrome在 performance 中查看：

步骤:

• 打开开发者工具 Performance
• 勾选 Screenshots 和 memory
• 左上角小圆点开始录制(record)
• 中止录制

图中 Heap 对应的部分就能够看到内存在周期性的回落也能够看到垃圾回收的周期,若是垃圾回收以后的最低值(咱们称为min),min在不断上涨,那么确定是有较为严重的内存泄漏问题。

避免内存泄漏的一些方式：

• 减小没必要要的全局变量，或者生命周期较长的对象，及时对无用的数据进行垃圾回收
• 注意程序逻辑，避免“死循环”之类的
• 避免建立过多的对象

总而言之须要遵循一条原则：不用了的东西要及时归还

5、垃圾回收的使用场景优化

1. 数组array优化

将[]赋值给一个数组对象，是清空数组的捷径(例如： arr = [];),可是须要注意的是，这种方式又建立了一个新的空对象，而且将原来的数组对象变成了一小片内存垃圾！实际上，将数组长度赋值为0（arr.length = 0）也能达到清空数组的目的，而且同时能实现数组重用，减小内存垃圾的产生。

const arr = [1, 2, 3, 4];
console.log('浪里行舟');
arr.length = 0  // 能够直接让数字清空，并且数组类型不变。
// arr = []; 虽然让a变量成一个空数组,可是在堆上从新申请了一个空数组对象。

2. 对象尽可能复用

对象尽可能复用，尤为是在循环等地方出现建立新对象，能复用就复用。不用的对象，尽量设置为null，尽快被垃圾回收掉。

var t = {} // 每次循环都会建立一个新对象。
for (var i = 0; i < 10; i++) {
  // var t = {};// 每次循环都会建立一个新对象。
  t.age = 19
  t.name = '123'
  t.index = i
  console.log(t)
}
t = null //对象若是已经不用了，那就当即设置为null；等待垃圾回收。

3. 在循环中的函数表达式，能复用最好放到循环外面。

// 在循环中最好也别使用函数表达式。
for (var k = 0; k < 10; k++) {
  var t = function(a) {
    // 建立了10次  函数对象。
    console.log(a)
  }
  t(k)
}

// 推荐用法
function t(a) {
  console.log(a)
}
for (var k = 0; k < 10; k++) {
  t(k)
}
t = null

参考资料

• JavaScript高级内幕（js高级）
• JavaScript垃圾回收机制
• JavaScript 内存泄漏教程
• JavaScript权威指南（第四版）
• JavaScript 中的垃圾回收
• 4类 JavaScript 内存泄漏及如何避免

关于Fundebug

Fundebug专一于JavaScript、微信小程序、微信小游戏、支付宝小程序、React Native、Node.js和Java线上应用实时BUG监控。 自从2016年双十一正式上线，Fundebug累计处理了10亿+错误事件，付费客户有Google、360、金山软件、百姓网等众多品牌企业。欢迎你们免费试用！