ECMAScript 核心概念

Object.create()方法创建一个新对象，
使用现有的对象来提供新创建的对象的__proto__。

这里 b.__proto__ == a
所以虽然b是个空对象，但会从原型上一直找值。
b.num == b.__proto__.num == 2

 ——《你不知道的javascript·上卷》P144

分析一下如果 foo 不直接存在于 myObject 中而是存在于原型链上层时 myObject.foo = "bar" 会出现的三种情况。

1. 如果在[[Prototype]]链上层存在名为foo的普通数据访问属性(参见第3章)并且没有被标记为只读(writable:false)，
那就会直接在 myObject 中添加一个名为 foo 的新属性，它是屏蔽属性。 


2. 如果在[[Prototype]]链上层存在foo，但是它被标记为只读(writable:false)，那么无法修改已有属性或者在 myObject 上创建屏蔽属性。
如果运行在严格模式下，代码会抛出一个错误。否则，这条赋值语句会被忽略。总之，不会发生屏蔽。 


3. 如果在[[Prototype]]链上层存在foo并且它是一个setter(参见第3章)，那就一定会调用这个 setter。
foo 不会被添加到(或者说屏蔽于)myObject，也不会重新定义 foo 这 个 setter。 


大多数开发者都认为如果向 [[Prototype]] 链上层已经存在的属性([[Put]])赋值，就一 定会触发屏蔽，但是如你所见，
三种情况中只有一种(第一种)是这样的。

如果你希望在第二种和第三种情况下也屏蔽 foo，那就不能使用 = 操作符来赋值，而是使用 Object.defineProperty(..)
(参见第 3 章)来向 myObject 添加 foo。 

 ——《你不知道的javascript·上卷》P161

尽管 myObject.a++ 看起来应该(通过委托)查找并增加 anotherObject.a 属性，
但是别忘 了 ++ 操作相当于 myObject.a = myObject.a + 1。
因此 ++ 操作首先会通过 [[Prototype]] 查找属性 a 并从 anotherObject.a 获取当前属性值 2，
然后给这个值加 1，接着用 [[Put]] 将值 3 赋给 myObject 中新建的屏蔽属性 a 。

b.num为2，后置++运算符是先用后加，这时b.num++返回还是2

b.num 在执行 ++ 操作之后，这时的b为{num:3}，不影响a.

function cloneDeep(source) {
const types = [Number, String, Boolean];

function clone(source, uniqueMap) {
if (!source) {
return;
}

let uniqueTarget = uniqueMap.get(source);
if (uniqueTarget) {
return uniqueTarget;
}

let curTarget;

// normalizing primitives if someone did new String('aaa'), or new Number('444');
types.forEach(function(type) {
if (source instanceof type) {
curTarget = type(source);
uniqueMap.set(source, curTarget);
// 在 forEach 回调函数里面的 return 并不能让外面的 clone 函数 return
// return curTarget;
}
});
// 如果是上面的情况，就返回结果
if(curTarget) return curTarget

if (Object.prototype.toString.call(source) === "[object Array]") {
curTarget = [];
uniqueMap.set(source, curTarget);
source.forEach(function(child, index, array) {
curTarget[index] = clone(child, uniqueMap);
});
} else if (typeof source == "object") {
// DOM
if (source.nodeType && typeof source.cloneNode == "function") {
curTarget = source.cloneNode(true);
uniqueMap.set(source, curTarget);
} else {
// Date
if (source instanceof Date) {
curTarget = new Date(source);
uniqueMap.set(source, curTarget);
} else {
// it is an object literal
curTarget = {};
uniqueMap.set(source, curTarget);
for (let key in source) {
// 这里一定要用上 Object.prototype.hasOwnProperty.call
if (Object.prototype.hasOwnProperty.call(source, key)) {
curTarget[key] = clone(source[key], uniqueMap);
}
}
}
}
} else {
curTarget = source;
uniqueMap.set(source, curTarget);
}

return curTarget;
}
return clone(source, new Map());
}

头

域

该算法有个限制：无法处理循环引用的事例。
在下面的例子中，两个对象被创建，并互相引用，形成了一个循环。
它们被调用之后会离开函数作用域，所以它们已经没有用了，可以被回收了。
然而，引用计数算法考虑到它们互相都有至少一次引用，所以它们不会被回收。

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

return "azerty";
}

f();

实例

标记阶段

清除阶段

补充逻辑

解决了循环引用的问题

足够简单

需要额外补充逻辑以解决内存碎片化问题

标记阶段的遍历所消耗的时间与对象的数量和规模成正比，
清除阶段的耗时跟堆的容量也成正比，
即标记清除算法的执行效率随着数据量的增长而下降

浏览器每隔一段时间执行一次 GC 逻辑，这种工作方式会增加浏览器的负荷

可能引起深层次问题的“坏”代码

使用代码检测工具
扫描原生JS代码

用编译型语言取代原生JS

VO === this === global

VO === AO,
<arguments> object and <formal parameters> are added

AO

function add(num) {
var num;
console.log(num); //1
}
add(1);