前言

像C语言这样的底层语言一般都有底层的内存管理接口，比如malloc()和free()用于分配和释放内存。而对于JavaScript来说，会在创建变量时分配内存，并且在不再使用它们时自动释放内存，这个自动释放内存的过程称为垃圾回收，因为自动垃圾回收机制的存在，让大多JavaScript开发者感觉他么可以不关系内存的管理，所以会在一些情况下导致内存泄漏

内存的生命周期

分配内存 -> 使用内存 -> 释放内存

JavaScript环境中分配的内存有如下生命周期：

1. 内存分配：当我们声明变量、函数、对象的时候，系统会自动为它们分配内存
2. 内存使用：即读写内存，也就是使用变量、函数等
3. 内存回收：使用完毕，由垃圾回收机制自动回收不再使用的内存

JavaScript的内存分配

为了不让开发人员费心分配内存，JavaScript在定义变量时就完成了内存分配

var n = 123; // 给数值变量分配内存
var s = "azerty"; // 给字符串分配内存

var o = {
  a: 1,
  b: null
}; // 给对象及其包含的值分配内存

// 给数组及其包含的值分配内存（就像对象一样）
var a = [1, null, "abra"]; 

function f(a){
  return a + 2;
} // 给函数（可调用的对象）分配内存

// 函数表达式也能分配一个对象
someElement.addEventListener(‘click‘, function(){
  someElement.style.backgroundColor = ‘blue‘;
}, false);

有些函数调用结果是分配对象内存：

var d = new Date(); // 分配一个 Date 对象
var e = document.createElement(‘div‘); // 分配一个 DOM 元素

有些方法分配新变量或者新对象

var s = "azerty";
var s2 = s.substr(0, 3); // s2 是一个新的字符串
// 因为字符串是不变量，
// JavaScript 可能决定不分配内存，
// 只是存储了 [0-3] 的范围。

var a = ["ouais ouais", "nan nan"];
var a2 = ["generation", "nan nan"];
var a3 = a.concat(a2); 
// 新数组有四个元素，是 a 连接 a2 的结果

JavaScript的内存使用

使用值的过程实际上是对分配的内存进行读取与写入的操作。读取与写入可能是写入一个变量或者一个对象的属性值，甚至传递函数的参数。

var a = 10; // 分配内存
console.log(a); // 对内存的使用

JavaScript的内存回收

JavaScript有自动垃圾回收机制，那么这个自动垃圾回收机制的原理是什么？其实就是找出那些不再继续使用的值，然后释放其占用的内存。

大多数内存管理的问题都在这个阶段。在这里最艰难的任务就是找到不在需要使用的变量。

不再需要使用的变量也就是生命周期结束的变量，是局部变量，局部变量只在函数的执行过程中存在，当函数运行结束，没有其他引用（闭包）那么该变量会被标记回收。

全局变量的生命周期直至浏览器卸载页面才会结束，也就是说全局变量不会被当成垃圾回收。

因为自动垃圾回收机制的存在，开发人员可以不关心不注意内存释放的相关问题，但对于无用内存的释放是客观存在的。不幸的是，即使不考虑垃圾回收机制对性能的影响，目前最新的来及回收算法也无法只能回收所有的极端情况。

垃圾回收

引用

垃圾回收算法主要依赖于引用的概念。

在内存管理的环境中，一个对象如果有访问另一个对象的权限（隐式或者显式），就叫做一个对象引用另一个对象。

引用计数垃圾收集

引用计数算法定义“内存不再使用”的标准很简单，就是看一个对象是否有指向它的引用。 如果没有其他对象指向它了，说明该对象已经不再需了。

var o = { 
  a: {
    b:2
  }
}; 
// 两个对象被创建，一个作为另一个的属性被引用，另一个被分配给变量o
// 很显然，没有一个可以被垃圾收集


var o2 = o; // o2变量是第二个对“这个对象”的引用

o = 1;      // 现在，“这个对象”的原始引用o被o2替换了

var oa = o2.a; // 引用“这个对象”的a属性
// 现在，“这个对象”有两个引用了，一个是o2，一个是oa

o2 = "yo"; // 最初的对象现在已经是零引用了
           // 他可以被垃圾回收了
           // 然而它的属性a的对象还在被oa引用，所以还不能回收

oa = null; // a属性的那个对象现在也是零引用了
           // 它可以被垃圾回收了

由上面可以看出，引用技术算法是个简单有效的算法。但它却存在一个致命的问题：循环引用

如果两个对象相互引用，尽管他们已经不再使用，垃圾回收不会进行回收，导致内存泄漏。

function f(){
  var o = {};
  var o2 = {};
  o.a = o2; // o 引用 o2
  o2.a = o; // o2 引用 o  这里

  return "azerty";
}

f();

上面的函数f，其中包含两个相互引用的对象。在调用函数结束后，对象实际航已经离开函数范围，即不在需要了。但根据引用计数原则，他们之间相互引用依然存在，因此这部分内存不会被回收，内存泄漏不可避免

var div = document.createElement("div");
div.onclick = function() {
    console.log("click");
};　

 创建一个DOM元素并绑定一个点击事件，此时变量div有事件处理函数的引用，同时事件处理函数也有div的引用，这也造成了循环引用，该部分的内存无法避免的泄露了

*标记清除算法*(重要)

标记清除算法将”不再使用的对象“定义为”无法达到的对象“。就是从根部（JavaScript全局对象）出发定时扫描内存中的对象。凡是能从根部到达的对象都是还需要使用的。那些无法由根部出发触及到的对象被标记为不再使用，稍后进行回收。

工作流程：

1. 垃圾收集器会在运行的时候会给存储在内存中的所有变量都加上标记。
2. 从根部出发将能触及到的对象的标记清除。
3. 那些还存在标记的变量被视为准备删除的变量
4. 最后垃圾收集器会执行最后一步内存清除的工作，销毁那些带标记的值并且收回他们所占用的内存空间。  

标记清除算法分为两个阶段：标记阶段（mark）；清除阶段（sweep）。

1. 标记阶段：垃圾回收器会从根对象开始遍历。每一个可以从根对象访问到的对象都会被添加一个标识，于是这个对象就被表示为可到达对象。
2. 清除阶段：垃圾回收器会对堆内存从头到尾进行线性遍历，如果发现有对象没有被标识为可到达对象，那么就将此对象占用的内存回收，并且将原来编辑为可到达对象的标识清除，以便进行下一次垃圾回收操作。

ChromeV8垃圾回收算法分代回收（Generation GC）

node --max-old-space-size=1700 app.js //单位为MB
node --max-new-space-size=1024 app.js //单位为MB

内存泄漏

什么是内存泄漏

程序的运行需要内存。只要程序提出要求，操作系统或者运行时（runtime）就必须共给内存。

对于持续运行的服务进程，必须及时释放不再使用的内存，否则内存占用的越来越高，轻则影响系统性能，重则导致进程崩溃。

本质上讲，内存泄漏就是由于疏忽或错误造成程序未能释放那些已经不再使用的内存，造成内存的浪费。

感谢掘金作者！！！

https://juejin.im/post/5bbeef03e51d450e7a252707

https://juejin.im/post/5d0706a6f265da1bc23f77a9