JS>> js-leakage-patterns>> 返回
项目作者： zhansingsong

项目描述 ：
:dart:这是关于JavaScript内存泄露和CSS优化相关序列文章，相信你读完会有所收获的:airplane:
高级语言： HTML
项目地址: git://github.com/zhansingsong/js-leakage-patterns.git


这是关于 JavaScript 内存泄露和 CSS 优化相关序列文章（整理中……）。由于时间有限更新进度会有点慢，但会持续更新的。自己也在学习中，难免对某些知识点的理解不是很正确，所以才将文章放置 github 上，一是想与大家分享，二是方便持续更新，三是便于实时修正错误点。也希望看本文的各位同学能多提 issues，我会根据提的意见不断完善文章。最后希望各位能从文章中有所收获——->:tada: enjoy reading, enjoy life :whale:

序列文章链接

:no_entry:声明: 本资料仅供学习交流! 如需转载，请注明出处。" class="reference-link"> :no_entry:声明: 本资料仅供学习交流! 如需转载，请注明出处。

常见的 JavaScript 内存泄露

什么是内存泄露

内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，导致在释放该段内存之前就失去了对该段内存的控制，从而造成了内存的浪费。内存泄漏通常情况下只能由获得程序源代码的程序员才能分析出来。然而，有不少人习惯于把任何不需要的内存使用的增加描述为内存泄漏，即使严格意义上来说这是不准确的。
————wikipedia

⚠️ 注：下文中标注的 CG 是 Chrome 浏览器中 Devtools 的【Collect garbage】按钮缩写，表示回收垃圾操作。
cg

意外的全局变量

JavaScript 对未声明变量的处理方式：在全局对象上创建该变量的引用(即全局对象上的属性，不是变量，因为它能通过delete删除)。如果在浏览器中，全局对象就是window对象。

如果未声明的变量缓存大量的数据，会导致这些数据只有在窗口关闭或重新刷新页面时才能被释放。这样会造成意外的内存泄漏。

  1. function foo(arg) {
  2.   bar = 'this is a hidden global variable with a large of data';
  3. }

等同于：

  1. function foo(arg) {
  2.   window.bar = 'this is an explicit global variable with a large of data';
  3. }

另外，通过this创建意外的全局变量：

  1. function foo() {
  2.   this.variable = 'potential accidental global';
  3. }
  5. // 当在全局作用域中调用foo函数，此时this指向的是全局对象(window)，而不是'undefined'
  6. foo();

解决方法：

在 JavaScript 文件中添加'use strict'，开启严格模式，可以有效地避免上述问题。

  1. function foo(arg) {
  2.   'use strict'; // 在foo函数作用域内开启严格模式
  3.   bar = 'this is an explicit global variable with a large of data'; // 报错：因为bar还没有被声明
  4. }

如果需要在一个函数中使用全局变量，可以像如下代码所示，在window上明确声明：

  1. function foo(arg) {
  2.   window.bar = 'this is a explicit global variable with a large of data';
  3. }

这样不仅可读性高，而且后期维护也方便

谈到全局变量，需要注意那些用来临时存储大量数据的全局变量，确保在处理完这些数据后将其设置为 null 或重新赋值。全局变量也常用来做 cache，一般 cache 都是为了性能优化才用到的，为了性能，最好对 cache 的大小做个上限限制。因为 cache 是不能被回收的，越高 cache 会导致越高的内存消耗。

console.log

console.log：向 web 开发控制台打印一条消息，常用来在开发时调试分析。有时在开发时，需要打印一些对象信息，但发布时却忘记去掉console.log语句，这可能造成内存泄露。

在传递给console.log的对象是不能被垃圾回收 ♻️，因为在代码运行之后需要在开发工具能查看对象信息。所以最好不要在生产环境中console.log任何对象。

实例———>demos/log.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.   <meta charset="UTF-8">
  6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.   <title>Leaker</title>
  9. </head>
  11. <body>
  12.   <input type="button" value="click">
  13.   <script>
  14.     !function () {
  15.       function Leaker() {
  16.         this.init();
  17.       };
  18.       Leaker.prototype = {
  19.         init: function () {
  20.           this.name = (Array(100000)).join('*');
  21.           console.log("Leaking an object %o: %o", (new Date()), this);// this对象不能被回收
  22.         },
  24.         destroy: function () {
  25.           // do something....
  26.         }
  27.       };
  28.       document.querySelector('input').addEventListener('click', function () {
  29.         new Leaker();
  30.       }, false);
  31.     }()
  32.   </script>
  33. </body>
  35. </html>

这里结合 Chrome 的 Devtools–>Performance 做一些分析，操作步骤如下：

:warning:注：最好在隐藏窗口中进行分析工作，避免浏览器插件影响分析结果

  1. 开启【Performance】项的记录
  2. 执行一次 CG，创建基准参考线
  3. 连续单击【click】按钮三次，新建三个 Leaker 对象
  4. 执行一次 CG
  5. 停止记录

可以看出【JS Heap】线最后没有降回到基准参考线的位置，显然存在没有被回收的内存。如果将代码修改为：

  1. !(function() {
  2.   function Leaker() {
  3.     this.init();
  4.   }
  5.   Leaker.prototype = {
  6.     init: function() {
  7.       this.name = Array(100000).join('*');
  8.     },
  10.     destroy: function() {
  11.       // do something....
  12.     },
  13.   };
  14.   document.querySelector('input').addEventListener(
  15.     'click',
  16.     function() {
  17.       new Leaker();
  18.     },
  19.     false,
  20.   );
  21. })();

去掉console.log("Leaking an object %o: %o", (new Date()), this);语句。重复上述的操作步骤，分析结果如下：

从对比分析结果可知，console.log打印的对象是不会被垃圾回收器回收的。因此最好不要在页面中console.log任何大对象，这样可能会影响页面的整体性能，特别在生产环境中。除了console.log外，另外还有console.dir、console.error、console.warn等都存在类似的问题，这些细节需要特别的关注。

closures(闭包)

当一个函数 A 返回一个内联函数 B，即使函数 A 执行完，函数 B 也能访问函数 A 作用域内的变量，这就是一个闭包——————本质上闭包是将函数内部和外部连接起来的一座桥梁。

  1. function foo(message) {
  2.   function closure() {
  3.     console.log(message);
  4.   }
  5.   return closure;
  6. }
  8. // 使用
  9. var bar = foo('hello closure!');
  10. bar(); // 返回 'hello closure!'

在函数 foo 内创建的函数 closure 对象是不能被回收掉的，因为它被全局变量 bar 引用，处于一直可访问状态。通过执行bar()可以打印出hello closure!。如果想释放掉可以将bar = null即可。

由于闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存。过度使用闭包可能会导致内存占用过多。

实例———>demos/closures.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.   <meta charset="UTF-8">
  6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.   <title>Closure</title>
  9. </head>
  11. <body>
  12.   <p>不断单击【click】按钮</p>
  13.   <button id="click_button">Click</button>
  14.   <script>
  15.     function f() {
  16.       var str = Array(10000).join('#');
  17.       var foo = {
  18.         name: 'foo'
  19.       }
  20.       function unused() {
  21.         var message = 'it is only a test message';
  22.         str = 'unused: ' + str;
  23.       }
  24.       function getData() {
  25.         return 'data';
  26.       }
  27.       return getData;
  28.     }
  30.     var list = [];
  32.     document.querySelector('#click_button').addEventListener('click', function () {
  33.       list.push(f());
  34.     }, false);
  35.   </script>
  36. </body>
  38. </html>

这里结合 Chrome 的 Devtools->Memory 工具进行分析，操作步骤如下：

:warning:注：最好在隐藏窗口中进行分析工作，避免浏览器插件影响分析结果

  1. 选中【Record allocation timeline】选项
  2. 执行一次 CG
  3. 单击【start】按钮开始记录堆分析
  4. 连续单击【click】按钮十多次
  5. 停止记录堆分析

closure

上图中蓝色柱形条表示随着时间新分配的内存。选中其中某条蓝色柱形条，过滤出对应新分配的对象：

closure

查看对象的详细信息：

closure

从图可知，在返回的闭包作用链(Scopes)中携带有它所在函数的作用域，作用域中还包含一个 str 字段。而 str 字段并没有在返回 getData()中使用过。为什么会存在在作用域中，按理应该被 GC 回收掉， why:question:

原因是在相同作用域内创建的多个内部函数对象是共享同一个变量对象（variable object）。如果创建的内部函数没有被其他对象引用，不管内部函数是否引用外部函数的变量和函数，在外部函数执行完，对应变量对象便会被销毁。反之，如果内部函数中存在有对外部函数变量或函数的访问（可以不是被引用的内部函数），并且存在某个或多个内部函数被其他对象引用，那么就会形成闭包，外部函数的变量对象就会存在于闭包函数的作用域链中。这样确保了闭包函数有权访问外部函数的所有变量和函数。了解了问题产生的原因，便可以对症下药了。对代码做如下修改：

  1. function f() {
  2.   var str = Array(10000).join('#');
  3.   var foo = {
  4.     name: 'foo',
  5.   };
  6.   function unused() {
  7.     var message = 'it is only a test message';
  8.     // str = 'unused: ' + str; //删除该条语句
  9.   }
  10.   function getData() {
  11.     return 'data';
  12.   }
  13.   return getData;
  14. }
  16. var list = [];
  18. document.querySelector('#click_button').addEventListener(
  19.   'click',
  20.   function() {
  21.     list.push(f());
  22.   },
  23.   false,
  24. );

getData()和 unused()内部函数共享 f 函数对应的变量对象，因为 unused()内部函数访问了 f 作用域内 str 变量，所以 str 字段存在于 f 变量对象中。加上 getData()内部函数被返回，被其他对象引用，形成了闭包，因此对应的 f 变量对象存在于闭包函数的作用域链中。这里只要将函数 unused 中str = 'unused: ' + str;语句删除便可解决问题。

closure

查看一下闭包信息：

closure

DOM 泄露

在 JavaScript 中，DOM 操作是非常耗时的。因为 JavaScript/ECMAScript 引擎独立于渲染引擎，而 DOM 是位于渲染引擎，相互访问需要消耗一定的资源。如 Chrome 浏览器中 DOM 位于 WebCore，而 JavaScript/ECMAScript 位于 V8 中。假如将 JavaScript/ECMAScript、DOM 分别想象成两座孤岛，两岛之间通过一座收费桥连接，过桥需要交纳一定“过桥费”。JavaScript/ECMAScript 每次访问 DOM 时，都需要交纳“过桥费”。因此访问 DOM 次数越多，费用越高，页面性能就会受到很大影响。了解更多:information_source:

为了减少 DOM 访问次数，一般情况下，当需要多次访问同一个 DOM 方法或属性时，会将 DOM 引用缓存到一个局部变量中。但如果在执行某些删除、更新操作后，可能会忘记释放掉代码中对应的 DOM 引用，这样会造成 DOM 内存泄露。

实例———>demos/dom.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.   <title>Dom-Leakage</title>
  8. </head>
  9. <body>
  10.   <input type="button" value="remove" class="remove" style="display:none;">
  11.   <input type="button" value="add" class="add">
  13.   <div class="container">
  14.     <pre class="wrapper"></pre>
  15.   </div>
  16.   <script>
  17.     // 因为要多次用到pre.wrapper、div.container、input.remove、input.add节点，将其缓存到本地变量中，
  18.     var wrapper = document.querySelector('.wrapper');
  19.     var container = document.querySelector('.container');
  20.     var removeBtn = document.querySelector('.remove');
  21.     var addBtn = document.querySelector('.add');
  22.     var counter = 0;
  23.     var once = true;
  24.     // 方法
  25.     var hide = function(target){
  26.       target.style.display = 'none';
  27.     }
  28.     var show = function(target){
  29.       target.style.display = 'inline-block';
  30.     }
  31.     // 回调函数
  32.     var removeCallback = function(){
  33.       removeBtn.removeEventListener('click', removeCallback, false);
  34.       addBtn.removeEventListener('click', addCallback, false);
  35.       hide(addBtn);
  36.       hide(removeBtn);
  37.       container.removeChild(wrapper);
  38.     }
  39.     var addCallback = function(){
  40.       wrapper.appendChild(document.createTextNode('\t' + ++counter + '：a new line text\n'));
  41.       // 显示删除操作按钮
  42.       if(once){
  43.         show(removeBtn);
  44.         once = false;
  45.       }
  46.     }
  47.     // 绑定事件
  48.     removeBtn.addEventListener('click', removeCallback, false);
  49.     addBtn.addEventListener('click', addCallback, false);
  50.   </script>
  51. </body>
  52. </html>

这里结合 Chrome 浏览器的 Devtools–>Performance 做一些分析，操作步骤如下：

:warning:注：最好在隐藏窗口中进行分析工作，避免浏览器插件影响分析结果

  1. 开启【Performance】项的记录
  2. 执行一次 CG，创建基准参考线
  3. 连续单击【add】按钮 6 次，增加 6 个文本节点到 pre 元素中
  4. 单击【remove】按钮，删除刚增加 6 个文本节点和 pre 元元素
  5. 执行一次 CG
  6. 停止记录堆分析

dom

从分析结果图可知，虽然 6 次 add 操作增加 6 个 Node，但是 remove 操作并没有让 Nodes 节点数下降，即 remove 操作失败。尽管还主动执行了一次 CG 操作，Nodes 曲线也没有下降。因此可以断定内存泄露了！那问题来了，如何去查找问题的原因呢？这里可以通过 Chrome 浏览器的 Devtools–>Memory 进行诊断分析，执行如下操作步骤：

:warning:注：最好在隐藏窗口中进行分析工作，避免浏览器插件影响分析结果

  1. 选中【Take heap snapshot】选项
  2. 连续单击【add】按钮 6 次，增加 6 个文本节点到 pre 元素中
  3. 单击【Take snapshot】按钮，执行一次堆快照
  4. 单击【remove】按钮，删除刚增加 6 个文本节点和 pre 元元素
  5. 单击【Take snapshot】按钮，执行一次堆快照
  6. 选中生成的第二个快照报告，并将视图由”Summary”切换到”Comparison”对比模式，在[class filter]过滤输入框中输入关键字：Detached

dom

从分析结果图可知，导致整个 pre 元素和 6 个文本节点无法别回收的原因是：代码中存在全局变量wrapper对 pre 元素的引用。知道了产生的问题原因，便可对症下药了。对代码做如下就修改：

  1. // 因为要多次用到pre.wrapper、div.container、input.remove、input.add节点，将其缓存到本地变量中，
  2. var wrapper = document.querySelector('.wrapper');
  3. var container = document.querySelector('.container');
  4. var removeBtn = document.querySelector('.remove');
  5. var addBtn = document.querySelector('.add');
  6. var counter = 0;
  7. var once = true;
  8. // 方法
  9. var hide = function(target) {
  10.   target.style.display = 'none';
  11. };
  12. var show = function(target) {
  13.   target.style.display = 'inline-block';
  14. };
  15. // 回调函数
  16. var removeCallback = function() {
  17.   removeBtn.removeEventListener('click', removeCallback, false);
  18.   addBtn.removeEventListener('click', addCallback, false);
  19.   hide(addBtn);
  20.   hide(removeBtn);
  21.   container.removeChild(wrapper);
  23.   wrapper = null; //在执行删除操作时，将wrapper对pre节点的引用释放掉
  24. };
  25. var addCallback = function() {
  26.   wrapper.appendChild(
  27.     document.createTextNode('\t' + ++counter + '：a new line text\n'),
  28.   );
  29.   // 显示删除操作按钮
  30.   if (once) {
  31.     show(removeBtn);
  32.     once = false;
  33.   }
  34. };
  35. // 绑定事件
  36. removeBtn.addEventListener('click', removeCallback, false);
  37. addBtn.addEventListener('click', addCallback, false);

在执行删除操作时，将 wrapper 对 pre 节点的引用释放掉，即在删除逻辑中增加wrapper = null;语句。再次在 Devtools–>Performance 中重复上述操作：

dom

小试牛刀———>demos/dom_practice.html

再来看看网上的一个实例，代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.   <title>Practice</title>
  8. </head>
  9. <body>
  10.   <div id="refA"><ul><li><a href="#"></a></li><li><a href="#"></a></li><li><a href="#" id="refB"></a></li></ul></div>
  11.   <div></div>
  12.   <div></div>
  14.   <script>
  15.     var refA = document.getElementById('refA');
  16.     var refB = document.getElementById('refB');
  17.     document.body.removeChild(refA);
  19.     // #refA不能GC回收，因为存在变量refA对它的引用。将其对#refA引用释放，但还是无法回收#refA。
  20.     refA = null;
  22.     // 还存在变量refB对#refA的间接引用(refB引用了#refB，而#refB属于#refA)。将变量refB对#refB的引用释放，#refA就可以被GC回收。
  23.     refB = null;
  24.   </script>
  25. </body>
  26. </html>

整个过程如下图所演示：

有兴趣的同学可以使用 Chrome 的 Devtools 工具，验证一下分析结果，实践很重要~~~:high_brightness:

timers

在 JavaScript 常用setInterval()来实现一些动画效果。当然也可以使用链式setTimeout()调用模式来实现：

  1. setTimeout(function() {
  2.   // do something. . . .
  3.   setTimeout(arguments.callee, interval);
  4. }, interval);

如果在不需要setInterval()时，没有通过clearInterval()方法移除，那么setInterval()会不停地调用函数，直到调用clearInterval()或窗口关闭。如果链式setTimeout()调用模式没有给出终止逻辑，也会一直运行下去。因此再不需要重复定时器时，确保对定时器进行清除，避免占用系统资源。另外，在使用setInterval()和setTimeout()来实现动画时，无法确保定时器按照指定的时间间隔来执行动画。为了能在 JavaScript 中创建出平滑流畅的动画，浏览器为 JavaScript 动画添加了一个新 API-requestAnimationFrame()。关于 setInterval、setTimeout 与 requestAnimationFrame 实现动画上的区别 ➹ 猛击 😊

实例———>demos/timers.html

如下通过setInterval()实现一个 clock 的小实例，不过代码存在问题的，有兴趣的同学可以先尝试找一下问题的所在~😎
操作：

  • 单击【start】按钮开始 clock，同时 web 开发控制台会打印实时信息
  • 单击【stop】按钮停止 clock，同时 web 开发控制台会输出停止信息
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.   <title>setInterval</title>
  8. </head>
  9. <body>
  10.   <input type="button" value="start" class="start">
  11.   <input type="button" value="stop" class="stop">
  13.   <script>
  14.     var counter = 0;
  15.     var clock = {
  16.       start: function () {
  17.         setInterval(this.step.bind(null, ++counter), 1000);
  18.       },
  19.       step: function (flag) {
  20.         var date = new Date();
  21.         var h = date.getHours();
  22.         var m = date.getMinutes();
  23.         var s = date.getSeconds();
  24.         console.log("%d-----> %d:%d:%d", flag, h, m, s);
  25.       }
  26.     }
  27.     document.querySelector('.start').addEventListener('click', clock.start.bind(clock), false);
  28.     document.querySelector('.stop').addEventListener('click', function () {
  29.       console.log('----> stop <----');
  30.       clock = null;
  31.     }, false);
  32.   </script>
  33. </body>
  34. </html>

上述代码存在两个问题：

  1. 如果不断的单击【start】按钮，会断生成新的 clock。

  2. 单击【stop】按钮不能停止 clock。

输出结果:

针对暴露出的问题，对代码做如下修改：

  1. var counter = 0;
  2. var clock = {
  3.   timer: null,
  4.   start: function() {
  5.     // 解决第一个问题
  6.     if (this.timer) {
  7.       clearInterval(this.timer);
  8.     }
  9.     this.timer = setInterval(this.step.bind(null, ++counter), 1000);
  10.   },
  11.   step: function(flag) {
  12.     var date = new Date();
  13.     var h = date.getHours();
  14.     var m = date.getMinutes();
  15.     var s = date.getSeconds();
  16.     console.log('%d-----> %d:%d:%d', flag, h, m, s);
  17.   },
  18.   // 解决第二个问题
  19.   destroy: function() {
  20.     console.log('----> stop <----');
  21.     clearInterval(this.timer);
  22.     node = null;
  23.     counter = void 0;
  24.   },
  25. };
  26. document
  27.   .querySelector('.start')
  28.   .addEventListener('click', clock.start.bind(clock), false);
  29. document
  30.   .querySelector('.stop')
  31.   .addEventListener('click', clock.destroy.bind(clock), false);

EventListener

做移动开发时，需要对不同设备尺寸做适配。如在开发组件时，有时需要考虑处理横竖屏适配问题。一般做法，在横竖屏发生变化时，需要将组件销毁后再重新生成。而在组件中会对其进行相关事件绑定，如果在销毁组件时，没有将组件的事件解绑，在横竖屏发生变化时，就会不断地对组件进行事件绑定。这样会导致一些异常，甚至可能会导致页面崩掉。

实例———>demos/callbacks.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.   <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.   <title>callbacks</title>
  8. </head>
  9. <body>
  10.   <div class="container"></div>
  11.   <script>
  12.     var container = document.querySelector('.container');
  13.     var counter = 0;
  14.     var createHtml = function (n, counter) {
  15.       var template = `${(new Array(n)).join(`<div>${counter}: this is a new data <input type="button" value="remove"></div>`)}`
  16.       container.innerHTML = template;
  17.     }
  19.     var resizeCallback = function (init) {
  20.       createHtml(10, ++counter);
  21.       // 事件委托
  22.       container.addEventListener('click', function (event){
  23.         var target = event.target;
  24.           if(target.tagName === 'INPUT'){
  25.               container.removeChild(target.parentElement)
  26.           }
  27.       }, false);
  28.     }
  29.     window.addEventListener('resize', resizeCallback, false);
  30.     resizeCallback(true);
  31.   </script>
  32. </body>
  33. </html>

页面是存在问题的，这里结合 Devtools–>Performance 分析一下问题所在，操作步骤如下：

:warning:注：最好在隐藏窗口中进行分析工作，避免浏览器插件影响分析结果

  1. 开启 Performance 项的记录
  2. 执行一次 CG，创建基准参考线
  3. 对窗口大小进行调整
  4. 执行一次 CG
  5. 停止记录

callbacks

如分析结果所示，在窗口大小变化时，会不断地对container添加代理事件。

同一个元素节点注册了多个相同的 EventListener，那么重复的实例会被抛弃。这么做不会让得 EventListener 被重复调用，也不需要用 removeEventListener 手动清除多余的 EventListener，因为重复的都被自动抛弃了。而这条规则只是针对于命名函数。对于匿名函数，浏览器会将其看做不同的 EventListener，所以只要将匿名的 EventListener，命名一下就可以解决问题：

  1. var container = document.querySelector('.container');
  2. var counter = 0;
  3. var createHtml = function(n, counter) {
  4.   var template = `${new Array(n).join(
  5.     `<div>${counter}: this is a new data <input type="button" value="remove"></div>`,
  6.   )}`;
  7.   container.innerHTML = template;
  8. };
  9. //
  10. var clickCallback = function(event) {
  11.   var target = event.target;
  12.   if (target.tagName === 'INPUT') {
  13.     container.removeChild(target.parentElement);
  14.   }
  15. };
  16. var resizeCallback = function(init) {
  17.   createHtml(10, ++counter);
  18.   // 事件委托
  19.   container.addEventListener('click', clickCallback, false);
  20. };
  21. window.addEventListener('resize', resizeCallback, false);
  22. resizeCallback(true);

在 Devtools–>Performance 中再重复上述操作，分析结果如下：
callback

在开发中，开发者很少关注事件解绑，因为浏览器已经为我们处理得很好了。不过在使用第三方库时，需要特别注意，因为一般第三方库都实现了自己的事件绑定，如果在使用过程中，在需要销毁事件绑定时，没有调用所解绑方法，就可能造成事件绑定数量的不断增加。如下链接是我在项目中使用 jquery，遇见到类似问题：jQuery 中忘记解绑注册的事件，造成内存泄露 ➹ 猛击 😊

总结

本文主要介绍了几种常见的内存泄露。在开发过程，需要我们特别留意一下本文所涉及到的几种内存泄露问题。因为这些随时可能发生在我们日常开发中，如果我们对它们不了解是很难发现它们的存在。可能在它们将问题影响程度放大时，才会引起我们的关注。不过那时可能就晚了，因为产品可能已经上线，接着就会严重影响产品的质量和用户体验，甚至可能让我们承受大量用户流失的损失。作为开发的我们必须把好这个关，让我们开发的产品带给用户最好的体验。

参考文章：