关于javascript:JavaScript中的垃圾回收和内存泄漏

前言

程序的运行须要内存。只有程序提出要求，操作系统或者运行时就必须供应内存。所谓的内存透露简略来说是不再用到的内存，没有及时开释。为了更好防止内存透露，咱们先介绍 Javascript 垃圾回收机制。

在 C 与 C ++ 等语言中，开发人员能够间接管制内存的申请和回收。然而在 Java、C#、JavaScript 语言中，变量的内存空间的申请和开释都由程序本人解决，开发人员不须要关怀。也就是说 Javascript 具备主动垃圾回收机制(Garbage Collecation)。

一、垃圾回收的必要性

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

因为字符串、对象和数组没有固定大小，所有当他们的大小已知时，能力对他们进行动静的存储调配。JavaScript 程序每次创立字符串、数组或对象时，解释器都必须分配内存来存储那个实体。只有像这样动静地调配了内存，最终都要开释这些内存以便他们可能被再用，否则，JavaScript 的解释器将会耗费完零碎中所有可用的内存，造成零碎解体。

这段话解释了为什么须要零碎须要垃圾回收，JavaScript 不像 C /C++，它有本人的一套垃圾回收机制。

JavaScript 垃圾回收的机制很简略：找出不再应用的变量，而后开释掉其占用的内存，然而这个过程不是时时的，因为其开销比拟大，所以垃圾回收器会依照固定的工夫距离周期性的执行。

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

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

二、垃圾回收机制

垃圾回收机制怎么晓得，哪些内存不再须要呢？

垃圾回收有两种办法：标记革除、援用计数。援用计数不太罕用，标记革除较为罕用。

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; 

三、哪些状况会引起内存透露？

尽管 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 元素还在内存外面。

四、内存透露的识别方法

新版本的 chrome 在 performance 中查看：

步骤:

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

图中 Heap 对应的局部就能够看到内存在周期性的回落也能够看到垃圾回收的周期, 如果垃圾回收之后的最低值(咱们称为 min),min 在一直上涨, 那么必定是有较为重大的内存透露问题。

防止内存透露的一些形式：

• 缩小不必要的全局变量，或者生命周期较长的对象，及时对无用的数据进行垃圾回收
• 留神程序逻辑，防止“死循环”之类的
• 防止创立过多的对象

总而言之须要遵循一条 准则：不必了的货色要及时偿还

五、垃圾回收的应用场景优化

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