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

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
}

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

function func() {
 let obj1 = {};
 let obj2 = {};
 obj1.a = obj2; // obj1 引用 obj2
 obj2.a = obj1; // obj2 引用 obj1
}

obj1 = null;
obj2 = null;

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

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

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

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
}

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 回收。
}

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

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；等待垃圾回收。

// 在循环中最好也别使用函数表达式。
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是使用垃圾回收的语言，也就是说执行环境负责在代码执行时管理内存。在C和C++等语言中，跟踪内存使用对开发者来说是很大的负担，也是很多问题的来源。JavaScript为开发者卸下了这个负担，通过自动内存管理实现内存分配和闲置资源回收。基本思路很简单：确定哪个变量不会再使用，然后释放它占用的内存。这个过程是周期性的，即垃圾回收程序每隔一定时间（或者说在代码执行过程中某个预定的收集时间）就会自动运行。垃圾回收过程是一个近似且不完美的方案，因为某块内存是否还有用，属于不可判定的问题。意味着算法是解决不了的。

　　我们以函数中局部变量的正常生命周期为例。函数中的局部变量会在函数执行时存在。此时，栈（或者堆）内存会分配空间以保存相应的值。函数在内部使用了变量，然后退出。此时，就不再需要那个局部变量了，它占用的内存可以释放，供以后使用。这种情况下显然不再需要局部变量了，但并不是所有时候都会这么明显。垃圾回收程序必须跟踪记录哪个变量还会使用，以及哪个变量不会再使用，以便回收内存。如何标记未使用的变量也许有不同的实现方式。不过，在浏览器的发展史上，用到过两种主要的标记策略：标记清理和引用计数。

节选自JavaScript高级程序设计（第四版）第四章

1、引用计数（reference counting）

　　另一种不太常见的垃圾回收策略是引用计数。引用计数的含义是跟踪记录每个值被引用的次数。当声明了一个变量并将一个引用类型赋值给该变量时，则这个值的引用次数就是1。相反，如果包含对这个值引用的变量又取得了另外一个值，则这个值的引用次数就减1。当这个引用次数变成0时，则说明没有办法再访问这个值了，因而就可以将其所占的内存空间给收回来。这样，垃圾收集器下次再运行时，它就会释放那些引用次数为0的值所占的内存。

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

举个 A:

比如对象A有一个属性指向对象B，而对象B也有有一个属性指向对象A，这样相互引用.

function func() {
    let obj1 = {};
    let obj2 = {};
    obj1.a = obj2; // obj1 引用 obj2
    obj2.a = obj1; // obj2 引用 obj1
}

　　在这个例子中，objA和objB通过各自的属性相互引用；也就是说这两个对象的引用次数都是2。在采用引用计数的策略中，由于函数执行之后，这两个对象都离开了作用域，函数执行完成之后，objA和objB还将会继续存在，因为他们的引用次数永远不会是0。这样的相互引用如果说很大量的存在就会导致大量的内存泄露。

解决：手动解除引用

obj1.a = null;
obj2.a = null;

举个 B：涉及COM对象的循环引用问题：

let element = document.getElementById('some_element')
let myObject = new Object()
myObject.element = element
element.someObject = myObject

　　这个例子在一个DOM对象（element）和一个原生JavaScript对象（myObject）之间制造了循环引用。myObject变量有一个名为element的属性指向DOM对象element，而element对象有一个someObject属性指回myObject对象.由于存在循环引用，因此DOM元素的内存永远不会被回收，即使它已经被从页面上删除了也是如此。

　　为避免类似的循环引用问题，应该在确保不使用的情况下切断原生JavaScript对象与DOM元素之间的连接。比如，通过以下代码可以清除前面例子中建立的循环引用：

myObject.element = null
element.someObject = null

把变量设置为null实际上会切段变量与其之前引用值之间的关系。当下次垃圾回收程序运行时，这些值就会被删除，内存也会被回收。

注意⚠️：为了补救这点，IE9把BOM和DOM对象都改成了JavaScript对象，这同时也避免了由于存在两套垃圾回收算法而导致的问题，还消除了常见的内存泄漏现象。

2、标记清除（mark-and-sweep）

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

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

　　标记清除也会遇到循环引用的问题。IE中有一部分对象并不是原生JavaScript对象。例如，其BOM和DOM中的对象就是使用C++以COM（Component Object Model，组件对象）对象的形式实现的，而COM对象的垃圾回收器就是采用的引用计数的策略。因此，即使IE的Javascript引擎使用标记清除的策略来实现的，但JavaScript访问的COM对象依然是基于引用计数的策略的。说白了，只要IE中涉及COM对象，就会存在循环引用的问题。

　　解决：手工断开js对象和DOM之间的链接。赋值为null。IE9把DOM和BOM转换成真正的JS对象了，所以避免了这个问题。

3、避免垃圾回收

通过上面内容了解了，浏览器虽然可以自动化执行垃圾回收，但如果项目比较大代码复杂，回收执行代价较大，某些情况甚至不能识别回收

1.数组array优化

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

2. 对象尽量复用

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

3.循环优化

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

4、避免内存泄漏

1.意外的全局变量

function fn(arg) {
    m = "this is a hidden global variable"
}

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

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

function fn() {
    this.variable = "potential accidental global"
}
// fn 调用自己，this 指向了全局对象（window）
fn()

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

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

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

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

所以要用完记住清除定时器鸭，也尽量别在定时器里引用dom对象。

3.闭包

function fn() {
    let m = document.createElement('xx')
    m.onClick = () => {
        // Even if it a empty function
    }
}

闭包可以维持函数内局部变量，使其得不到释放。

上例定义事件回调时，由于是函数内定义函数，并且内部函数 -> 事件回调引用外部函数，形成了闭包

解决办法：

// 1. 将事件处理函数定义在外面
function fn() {
    let m = document.createElement('xx')
    m.onClick = onClickFn()
}
// 2. 定义事件处理函数的外部函数中，删除对dom对象的引用
function fn() {
    let m = document.createElement('xx')
    m.onClick = () => {
        // Even if it a empty function
    }
    m = null
}

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

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

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

let 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元素还在内存里面。

最后最后：

明天港性能，有空可以来看看蛙，下班10点半，到家11点半，大半夜写的文章呢。

公众号：小何成长，佛系更文，都是自己曾经踩过的坑或者是学到的东西

有兴趣的小伙伴欢迎关注我哦，我是：何小玍。 大家一起进步鸭

TML文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
<center>


    <h2>发起HTTP get请求</h2>
    <form action="myServlet" method="get">
        <p>账号: <input type="text" name="name" /></p>
        <p>密码: <input type="text" name="passWord" /></p>
        <input type="submit" value="提交" />
    </form>




</center>
</html>

注意action="myServlet"要和servlet3.0的注解路径一样

servlet文件