JavaScript世界诞生记

一、初期：无类型化语言：

0. null 我称之为"上帝类子" 。

宇宙大爆炸之后的状态，各种粒子的存在，但以光速运行（无质量），无法合成物质其中的"希格斯色子"，它自身没有质量，却可以降低其它粒子的速度，也就赋予了其它粒子质量。
javascript的作者,给null一个值
void * null=(void *)0x00;

1. 降速下来的是"原始粒子"：

 typeof struct {
    void * __proto__;
    (*(char *))toString();//函数指针
    ...
  } OriginParticle;
  OriginParticle *op=malloc(sizeof(OriginParticle));
  op->__proto__=null;

在Js的世界，它存在于内存，但不具备全局的名称。

2. 原始粒子的方法及属性：

.__proto__=null;
.constructor
.hasOwnProperty        .isPrototypeOf
.propertyIsEnumerable  .toLocaleString
.toString              .valueOf

3. 原型链规则：

一切对象，都会有一个隐藏指针__proto__,指向到某一对象，而该对象，也会有proto,最终都会递归指向到"原始粒子"，进而指向到null,由此形成的指针链为"原型链"。

4. 对象属性的查找规则：

1. 对象自身->__proto__指向的对象自身->__proto.__proto__指向的对象自身->原始粒子->null
2. 很有万事皆空的味道

5. 扁平对象(po)：

其__proto__直接指向到"原始粒子",po的创造方式:{}或{prop:value,..}

二、进化：具有类型化的语言：

我们要解决如何能创造出"具有类型化"对象，但此时并没有"类"！！！

1. "工厂对象"：

一个po，并给它加一些属性和方法（它的__proto__也指向到"原始粒子"）：

.apply    .arguments    .bind   .call
.caller   .length   .name

该对象表明一切具有"类"和"函数"特征的对象的共同属性

2. Function对象的三大特征：

创造一个名字叫Function对象,它是除了null和"原始粒子"以外，最重要的对象：

1. 让其__proto__指向"工厂对象"
2. 为其添加一个额外的指针prototype，也指向到"工厂对象"
3. 工厂对象的constructor指针，并指向到自身。

3. 函数：

由new Function()产生新的对象称为"函数或者类型"，函数具有以下特征：

1. 函数的__proto__由Function的prototype引导，指向到"工厂对象"。
2. 函数也具有prototype指针，但并不指到"工厂对象"上，而是会指向到一个新的po对象上，称为"该函数的原型对象"。
3. 它的propertype.constructor指向到函数自身。
   注：我们称Function为函数类型，new Function()产生的对象为函数或类型，所以Function对应的Java类型，为Class

4. 函数的字面量方式：

1）function 函数名称(形参){}
2）函数名称=function(形参){}

3. (形参)=>{}

5. 由new Function()带来的生态系统：

function String(),function Date()...,并允许我们自定义function Human(){}。

6. 具有类型的对象特征：

1. 由new 函数名()创造
2. __proto__指向“函数原型对象”（这是与po最大的不同）
3. constructor指向函数自身

7. new 函数时发生了什么：

1）创造一个po对象
2）挂载在函数定义时由this指向的属性和方法
3）其proto指向到它自身的"函数原型对象"（函数的prototype指引）

4. 其constructor指向到"函数"自身

8. 解决Object是什么的问题：

1）由new Function()产生的函数（所以具备函数所有的特征）
2）它的prototype为"上帝粒子"，即以"上帝粒子"为"Object函数的原型对象"，所以其new出的对象为po
3）它是函数(new Function()的产物)，所以它的proto指向到"工厂对象"，它的constructor指向到Function

9. "原始粒子"的奇怪指针：

1）constructor 指向Object
2）proto并不指向到构造Object.prototype，这点说明了，只是强行将constructor指向到Object,而不是由Object构造出该对象。

10. 解释Function中的指针：

1. prototype 指向到"工厂对象"，指引着一切"函数对象"的共同属性
2. proto 指向到"工厂对象"，它自身也是"函数（创造函数的函数）"

11. 最后闭环：

让对象上的方法指针指向到由new Function创造的函数上
"原始粒子".toString=function(){..};

三、typeof(a)的判断依据是什么：

1. a为指针时其为object(包括null)
2. a.proto为"工厂对象"，返回function
3. a.constructor为Array,返回array

四、a instanceof B的判断依据是什么：

1. 递归比较a.proto.isPrototypeOf(B)
2. 为什么a instanceof(Object)总为true:
   因为原型链始终指向"原始粒子"，而"原始粒子"是Object.prototype的指向，
   所以isPrototypeOf(Object)为ture