原文在https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management.基本保持了平译,并在一些地方做了概念解释。(转载请注明出处)
介绍
高级语言，比如C，有底层的内存管理原语如malloc()和free()。但是对于Javascript来说，变量(string、object等等)被创建的时候分配内存，等变量不再被使用的时候，内存被"自动"释放。这个自动释放的过程叫做"垃圾回收"。“自动”这个词常使人困惑并且给了javascript(以及其他的高级语言)开发者他们不需要关心内存管理的印象。这是错误的。
内存生命周期
忽略具体的变成语言，内存的生命周期通常是这样的:
- 分配你需要的内存
- 使用他们(读、写操作)
- 当他们不再需要的时候释放他们
第二部分在所有的语言里都是明显的。第一和第三部分在低级语言里是明显的，但是在高级语言如JavaScript里是非常隐秘的。
JavaScript的内存分配
变量的初始化
为了不让程序的书写者操心内存分配问题，JavaScript随着变量的声明自动分配了内存。
var n = 123; //为1个数字分配了内存
var s = 'azerty';//为一个字符串分配了内存
var o = {
a:1,
b:null
};//为对象和里边的键值分配了内存
//(和对象一样),为数组和里边的元素分配了内存
var a = [1,null,'abra'];
function f(a){
return a + 2;
}//为一个函数分配了内存(函数是可调用对象)
//函数表达式也作为1个对象被分配了内存
//译者注:函数的表达式指的是下面的匿名函数的定义部分,JavaScript的函数可以作为函数的参数传入，因为他是一种特殊的对象
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 可能不会再为s2分配内存, 而仅仅让s2记录0-3这个区间
var a = ['ouais ouais', 'nan nan'];
var a2 = ['generation', 'nan nan'];
var a3 = a.concat(a2);
// 新的数组s3有4个元素,连接了a和a2
使用内存
使用内存基本上就是读写已分配的内存。比如读写变量的值，对象的属性，又或者给函数传递参数(译者:这里是说变量作为参数传递到函数的行为，就是使用这个变量内存的过程)。
当内存不再需要的时候释放
这个阶段会产生许多内存管理的问题。最难的问题是找到什么时候“已分配的内存不再需要”，这要求开发者去检测什么地方的内存不再需要，然后释放它们。
高级语言嵌入了一个叫做“垃圾回收”的功能，它的作用是追踪内存分配，当发现一块已分配的内存不再需要的时候，自动释放它。这是一个近似的过程，因为“判断一段内存是否还需要保留”是不可判定的(undecidable .can't be solved by an algorithm.这里可以理解为，分配的内存还用不用只有程序员主观的知道，如果他忘了，会导致内存泄漏，如果程序员手贱，释放的早了，再访问这块内存就会导致内存访问错误。语言的垃圾回收机制更像是一个第三者，虽然他很聪明，算法很强大，很能揣测程序意图，但是毕竟不是本人)。
引用
垃圾回收算法的主要理论依据是一个叫“引用”的概念。在内存管理的上下文中，如果一个对象有权利访问另一个对象(的内存，无论是显式还是隐式)，会让前者去引用后者。比如，Javascript对象有对他的原型隐式的引用，和对它属性显式的引用。
在内存管理的上下文中，“对象”的概念比通常的JavaScript的对象(Object)更为宽泛，甚至包含函数作用域，或者全局的词法作用域。
基于引用计数的垃圾回收
这是最简单的垃圾回收算法。这种算法将“一个内存中对象不再被需要”简化为"一个内存对象不再被别的对象引用"。如果一个对象被引用的数量为0，这个对象就被认为应该被回收了。(译者注:大多数此类算法都要求被管理的所有对象都有一个类似referenceCount的属性，标识自己被引用了多少次)。
例子:
var o = {
a:{
b:2
}
};
//2个对象被创建出来，1给被引用为对象的属性，然后外部的对象被变量o引用。显然他们都不会被回收
var o2 = o;//变量o2又引用了o引用的对象
o = 1;//现在变量o不再引用之前的对象，之前的对象只被o2引用了
var oa = o2.a;//现在作为对象属性的对象，又被变量oa引用了
o2 = 'yo';//现在最初被o引用的对象已经再被引用了，可以被回收，但是它的a属性还被oa引用，所以还不能被释放
oa = null;//现在作为a属性的对象也不再被引用了，最初被o引用的对象可以被回收释放了。
限制:循环引用
当引用出现循环，这种算法就会出现限制。下面的例子里，2个对象被创建出来，并且彼此被另一个引用，导致循环引用。函数执行完成后，他们会离开函数作用域，不再起作用了，可以被释放了。但是，引用计数算法认为他们2个都被引用了一次(函数接收后，变量o,o2会解掉对对象的引用)，不能被回收。
function f() {
var o = {};
var o2 = {};
o.a = o2; // o引用的对象的属性a 引用 o2
o2.a = o; // o2引用的对象的属性a 引用 o
return 'azerty';
}
f();
真实的例子
IE6和IE7使用引用计数管理DOM对象，所以循环引用是常见的导致内存泄漏的错误。
var div;
window.onload = function() {
div = document.getElementById('myDivElement');
div.circularReference = div;
div.lotsOfData = new Array(10000).join('*');
};
这个例子里，dom元素"myDivElement"被自己的circularReference属性所引用(div.circularReference = div;)。如果这个属性没有明确的移除或者置为null,即使myDivElement这个元素从DOM树里移除了，引用计数垃圾收集器还将总是拥有至少一个这个元素的引用，并且一直存在于内存中。如果DOM元素持有大量数据(比如这个例子里的lotsOfData属性)，这个数据消耗的内存将不会被释放回收。
基于标记-清除的垃圾回收
这个算法将"一个内存中对象不再被需要"简化为"一个内存对象不可达"。(译者注:原文是an object is unreachable。内存中的对象，如果程序无法通过一些线索,如引用关系找到它，它就没有存在的意义,是不可达的)。这种算法假定知道一组叫做根的对象，周期性的从这些“根”开始，查找到所有被根引用的对象，然后从这些对象开始，递归的查找下去。因此，从根开始查找的过程中，垃圾收集器将会找到所有可达的内存对象和不可达的内存对象。
这个算法比上一个要好，因为“一个被0引用”的内存对象可以推导出这个内存对象不可达，相反，出现循环引用的时候，反推却不成立。
截止2012年，所有的现代浏览器都搭载了标记-清除垃圾回收器。过去几年里，JavaScript 的垃圾回收领域(分代/增量/并发/并行垃圾回收)技术的更新实现了这种算法的进步，但是对垃圾回收算法本身:什么时候"一个内存对象不再需要"这个概念的处理，并没有多大进步。(原文:but not improvements over the garbage collection algorithm itself nor its reduction of the definition of when "an object is not needed anymore).
循环引用不再是问题
第一个例子里，函数结束后，2个对象不再被由全局对象可达的对象所引用，因此，他们被垃圾回收器认为是不可达的。
限制:内存对象需要被显式的设置为不可达
即使这被标注为一个限制，但是在实践中很少遇到，这也是为什么很少有人会经常关注垃圾收集的原因(说的是,在当前标记清除的技术下，程序员们不再关注垃圾回收这个问题了)。