update

Author: webVueBlog

README.md

@@ -13,6 +13,22 @@ https://github.com/webVueBlog/Leetcode
 
 欢迎大家前来讨论，如果觉得对你的学习有一定的帮助，欢迎点个Star （此仓库每天都会准时更新）
 
+## 😘 阶段十三（347）
+
+<details open>
+<summary>展开查看</summary>
+
+- 341.[作用域链增强](./阶段十三/作用域链增强.js)
+- 342.[变量声明](./阶段十三/变量声明.js)
+- 343.[垃圾回收](./阶段十三/垃圾回收.js)
+- 344.[标记清理](./阶段十三/标记清理.js)
+- 345.[引用计数](./阶段十三/引用计数.js)
+- 346.[性能](./阶段十三/性能.js)
+- 347.[内存管理](./阶段十三/内存管理.js)
+
+</details>
+
+
 ## 🥰 阶段十二（340）
 
 <details open>

阶段十三/作用域链增强.js

@@ -0,0 +1,25 @@
+/**
+
+虽然执行上下文主要有全局上下文和函数上下文两种（eval()调用内部存在第三种上下文），但有其他方式来增强作用域链。
+
+在作用域链前端临时添加一个上下文
+
+通常在两种情况下会出现这个现象
+
+try/catch 语句的 catch 块 : 会创建一个新的变量对象，这个变量对象会包含要抛出的错误对象的声明。
+
+with 语句: 会向作用域链前端添加指定的对象
+
+都会在作用域链前端添加一个变量对象。
+
+function buildUrl() { 
+ let qs = "?debug=true"; 
+ with(location){ 
+ let url = href + qs; 
+ } 
+ return url; 
+}
+
+with 语句将 location 对象作为上下文
+
+*/

阶段十三/内存管理.js

@@ -0,0 +1,117 @@
+/**
+
+将内存占用量保持在一个较小的值可以让页面性能更好。
+
+优化内存占用的最佳手段就是保证在执行代码时只保存必要的数据。如果数据不再必要，那么把它设置为 null，从而释放其引用。
+
+这也可以叫作解除引用
+
+最适合全局变量和全局对象的属性。局部变量在超出作用域后会被自动解除引用
+
+
+function createPerson(name){ 
+ let localPerson = new Object(); 
+ localPerson.name = name; 
+ return localPerson; 
+} 
+let globalPerson = createPerson("Nicholas"); 
+// 解除 globalPerson 对值的引用
+globalPerson = null;
+
+
+1. 通过 const 和 let 声明提升性能
+2. 隐藏类和删除操作
+
+运行期间，V8 会将创建的对象与隐藏类关联起来，以跟踪它们的属性特征。能够共享相同隐藏类的对象性能会更好，V8 会针对这种情况进行优化，但不一定总能够做到。
+
+function Article() { 
+ this.title = 'Inauguration Ceremony Features Kazoo Band'; 
+} 
+let a1 = new Article(); 
+let a2 = new Article();
+
+V8 会在后台配置，让这两个类实例共享相同的隐藏类，因为这两个实例共享同一个构造函数和原型。
+
+
+解决方案就是避免 JavaScript 的“先创建再补充”（ready-fire-aim）式的动态属性赋值，并在构造函数中一次性声明所有属性
+
+function Article(opt_author) { 
+ this.title = 'Inauguration Ceremony Features Kazoo Band'; 
+ this.author = opt_author; 
+} 
+let a1 = new Article(); 
+let a2 = new Article('Jake');
+
+
+
+function Article() { 
+ this.title = 'Inauguration Ceremony Features Kazoo Band'; 
+ this.author = 'Jake'; 
+} 
+let a1 = new Article(); 
+let a2 = new Article(); 
+a1.author = null;
+
+
+3. 内存泄漏
+
+意外声明全局变量是最常见但也最容易修复的内存泄漏问题
+
+在 window 对象上创建的属性，只要 window 本身不被清理就不会消失。
+
+function setName() { 
+ name = 'Jake'; 
+}
+
+定时器也可能会悄悄地导致内存泄漏。
+
+let name = 'Jake'; 
+setInterval(() => { 
+ console.log(name); 
+}, 100);
+
+只要定时器一直运行，回调函数中引用的 name 就会一直占用内存。
+
+
+使用 JavaScript 闭包很容易在不知不觉间造成内存泄漏。
+
+let outer = function() { 
+ let name = 'Jake'; 
+ return function() { 
+ return name; 
+ }; 
+};
+
+
+4. 静态分配与对象池
+
+
+注意 静态分配是优化的一种极端形式。如果你的应用程序被垃圾回收严重地拖了后腿，可以利用它提升性能。但这种情况并不多见。大多数情况下，这都属于过早优化，因此不用考虑。
+
+对象更替的速度很快，从而会更频繁地安排垃圾回收。
+
+一个策略是使用对象池。
+
+由于没发生对象初始化，垃圾回收探测就不会发现有对象更替，因此垃圾回收程序就不会那么频繁地运行。
+
+// vectorPool 是已有的对象池
+let v1 = vectorPool.allocate(); 
+let v2 = vectorPool.allocate(); 
+let v3 = vectorPool.allocate(); 
+v1.x = 10; 
+v1.y = 5; 
+v2.x = -3; 
+v2.y = -6; 
+addVector(v1, v2, v3); 
+console.log([v3.x, v3.y]); // [7, -1] 
+vectorPool.free(v1); 
+vectorPool.free(v2); 
+vectorPool.free(v3); 
+// 如果对象有属性引用了其他对象
+// 则这里也需要把这些属性设置为 null 
+v1 = null; 
+v2 = null; 
+v3 = null;
+
+
+*/

阶段十三/变量声明.js

@@ -0,0 +1,171 @@
+/**
+
+ECMAScript 5.1  var
+
+ES6 let 和 const
+
+1. 使用 var 的函数作用域声明
+
+function add(num1, num2) { 
+ var sum = num1 + num2; 
+ return sum; 
+} 
+let result = add(10, 20); // 30 
+console.log(sum); // 报错：sum 在这里不是有效变量
+
+
+
+function add(num1, num2) { 
+sum = num1 + num2; 
+ return sum; 
+} 
+let result = add(10, 20); // 30 
+console.log(sum); // 30
+
+
+var 声明会被拿到函数或全局作用域的顶部，位于作用域中所有代码之前。这个现象叫作“提升”（hoisting）
+
+var name = "Jake"; 
+// 等价于：
+name = 'Jake'; 
+var name;
+
+
+function fn1() { 
+ var name = 'Jake'; 
+} 
+// 等价于：
+function fn2() { 
+ var name; 
+ name = 'Jake'; 
+}
+
+
+console.log(name); // undefined 
+var name = 'Jake'; 
+function() { 
+ console.log(name); // undefined 
+ var name = 'Jake'; 
+}
+
+
+2. 使用 let 的块级作用域声明
+
+if (true) { 
+ let a; 
+} 
+console.log(a); // ReferenceError: a 没有定义
+while (true) { 
+ let b; 
+}
+console.log(b); // ReferenceError: b 没有定义
+function foo() { 
+ let c; 
+} 
+console.log(c); // ReferenceError: c 没有定义
+ // 这没什么可奇怪的
+ // var 声明也会导致报错
+
+
+
+// 这不是对象字面量，而是一个独立的块
+// JavaScript 解释器会根据其中内容识别出它来
+{ 
+ let d; 
+}
+
+
+不能声明两次 会抛出 SyntaxError 。
+
+var a; 
+var a; 
+// 不会报错
+{ 
+ let b; 
+ let b; 
+} 
+// SyntaxError: 标识符 b 已经声明过了
+
+“暂时性死区”（temporal dead zone）
+
+3. 使用 const 的常量声明
+
+使用 const 声明的变量必须同时初始化为某个值。
+
+
+const a; // SyntaxError: 常量声明时没有初始化
+const b = 3; 
+console.log(b); // 3 
+b = 4; // TypeError: 给常量赋值
+
+
+if (true) { 
+ const a = 0; 
+} 
+console.log(a); // ReferenceError: a 没有定义
+
+
+while (true) { 
+ const b = 1; 
+} 
+console.log(b); // ReferenceError: b 没有定义
+function foo() { 
+ const c = 2; 
+} 
+console.log(c); // ReferenceError: c 没有定义
+{ 
+ const d = 3; 
+} 
+console.log(d); // ReferenceError: d 没有定义
+
+
+const o1 = {}; 
+o1 = {}; // TypeError: 给常量赋值
+const o2 = {}; 
+o2.name = 'Jake'; 
+console.log(o2.name); // 'Jake'
+
+如果想让整个对象都不能修改，可以使用 Object.freeze()
+
+
+const o3 = Object.freeze({}); 
+o3.name = 'Jake'; 
+console.log(o3.name); // undefined
+
+4. 标识符查找
+
+var color = 'blue'; 
+function getColor() { 
+ return color; 
+} 
+console.log(getColor()); // 'blue'
+
+
+var color = 'blue'; 
+function getColor() { 
+let color = 'red'; 
+ return color; 
+} 
+console.log(getColor()); // 'red'
+
+
+var color = 'blue'; 
+function getColor() { 
+let color = 'red'; 
+{ 
+let color = 'green'; 
+return color; 
+} 
+} 
+console.log(getColor()); // 'green'
+
+
+注意 标识符查找并非没有代价。访问局部变量比访问全局变量要快，因为不用切换作用域。不过，JavaScript 引擎在优化标识符查找上做了很多工作，将来这个差异可能就微不足道了。
+
+*/
+
+const o3 = Object.freeze({ age: 12 });
+o3.name = 'Jake';
+console.log(o3.name); // undefined
+delete o3.age
+console.log(o3.age) // 12

阶段十三/垃圾回收.js

@@ -0,0 +1,16 @@
+/**
+
+执行环境负责在代码执行时管理内存。
+
+通过 自动内存管理 实现 内存分配 和 闲置资源回收 。
+
+基本思路很简单：确定哪个变量不会再使用，然后释放它占用的内存。
+
+这个过程是周期性的，即垃圾回收程序每隔一定时间就会自动运行
+
+
+垃圾回收程序必须跟踪记录哪个变量还会使用，以及哪个变量不会再使用，以便回收内存。如何标记未使用的变量也许有不同的实现方式。
+
+用到过两种主要的标记策略：标记清理和引用计数。
+
+*/

阶段十三/引用计数.js

@@ -0,0 +1,21 @@
+/**
+
+垃圾回收策略是引用计数（reference counting）
+
+其思路是对每个值都记录它被引用的次数。
+
+声明变量并给它赋一个引用值时，这个值的引用数为 1。如果同一个值又被赋给另一个变量，那么引用数加 1。
+
+如果保存对该值引用的变量被其他值给覆盖了，那么引用数减 1。当一个值的引用数为 0 时，就说明没办法再访问到这个值了，因此可以安全地收回其内存了。垃圾回收程序下次运行的时候就会释放引用数为 0 的值的内存。
+
+
+循环引用
+
+function problem() { 
+ let objectA = new Object(); 
+ let objectB = new Object(); 
+ objectA.someOtherObject = objectB; 
+ objectB.anotherObject = objectA; 
+}
+
+*/

阶段十三/性能.js

@@ -0,0 +1,5 @@
+/**
+
+警告 在某些浏览器中是有可能（但不推荐）主动触发垃圾回收的。在 IE 中，window. CollectGarbage()方法会立即触发垃圾回收。在 Opera 7 及更高版本中，调用 window. opera.collect()也会启动垃圾回收程序。
+
+*/