JavaScript与其框架

1. typeof（缺点：数组和 null 会被判定为 object）
2. instanceof（缺点：只能判断引用类型）
3. Object.prototype.toString.call()
4. constructor（缺点：对象原型改变时无法正确检测类型）

null 是一个表示” 无” 的对象，转为数值时为 0；undefined 是一个表示” 无” 的原始值，转为数值时为 NaN。
当声明的变量还未被初始化时，变量的默认值为 undefined。
null 用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象。

undefined 表示” 缺少值”，就是此处应该有一个值，但是还没有定义。典型用法是：

1. 变量被声明了，但没有赋值时，就等于 undefined。
2. 调用函数时，应该提供的参数没有提供，该参数等于 undefined。
3. 对象没有赋值的属性，该属性的值为 undefined。
4. 函数没有返回值时，默认返回 undefined。

null 表示” 没有对象”，即该处不应该有值。典型用法是：

1. 作为函数的参数，表示该函数的参数不是对象。
2. 作为对象原型链的终点。

1. 首先会判断两者类型是否相同，相同的话就比较两者的大小；
2. 类型不相同的话，就会进行类型转换；
3. 会先判断是否在对比 null 和 undefined，是的话就会返回 true
4. 判断两者类型是否为 string 和 number，是的话就会将字符串转换为 number
5. 判断其中一方是否为 boolean，是的话就会把 boolean 转为 number 再进行判断
6. 判断其中一方是否为 object 且另一方为 string、number 或者 symbol，是的话就会把 object 转为原始类型再进行判断

其他值转字符串

• Null 和 Undefined 类型 ，null 转换为 "null"，undefined 转换为 "undefined"，
• Boolean 类型，true 转换为 "true"，false 转换为 "false"。
• Number 类型的值直接转换，不过那些极小和极大的数字会使用指数形式。
• Symbol 类型的值直接转换，但是只允许显式强制类型转换，使用隐式强制类型转换会产生错误。
• 对普通对象来说，除非自行定义 toString () 方法，否则会调用 toString ()（Object.prototype.toString ()）来返回内部属性 [[Class]] 的值，如 "[object Object]"。如果对象有自己的 toString () 方法，字符串化时就会调用该方法并使用其返回值。

其他值转数字

• Undefined 类型的值转换为 NaN。
• Null 类型的值转换为 0。
• Boolean 类型的值，true 转换为 1，false 转换为 0。
• String 类型的值转换如同使用 Number () 函数进行转换，如果包含非数字值则转换为 NaN，空字符串为 0。
• Symbol 类型的值不能转换为数字，会报错。
• 对象（包括数组）会首先被转换为相应的基本类型值，如果返回的是非数字的基本类型值，则再遵循以上规则将其强制转换为数字。

为了将值转换为相应的基本类型值，抽象操作 ToPrimitive 会首先（通过内部操作 DefaultValue）检查该值是否有 valueOf () 方法。如果有并且返回基本类型值，就使用该值进行强制类型转换。如果没有就使用 toString () 的返回值（如果存在）来进行强制类型转换。

如果 valueOf () 和 toString () 均不返回基本类型值，会产生 TypeError 错误。

其他值转布尔值
以下这些是假值：

• undefined
• null
• false
• +0、-0 和 NaN
• ""

涉及隐式转换

1. NaN>=NaN,false
2. 0>=0，true
3. []==false -> []==0 -> ''0 -> 00 ,true

includes 内部使用 Number.isNaN 对 NaN 进行检测，而 indexOf 无法检测 NaN

Set：不能出现重复的原始值和引用值
Map：键值对的集合，类似一个字典表
WeakSet：成员都是对象且弱引用，可以被垃圾回收机制回收从而防止内存泄漏，可以保存 DOM 节点
WeakMap：只接受对象作为键名（null 除外）且是弱引用，值任意，键名所指向的对象可以被垃圾回收机制回收，此时键名无效不能遍历，方法只有 get、set、has、delete

1. var 和 let 声明变量，const 声明常量且必须初始化赋值
2. var 是函数作用域，let、const 是块级作用域，所以 let 和 const 无法存在 window 上
3. var 存在变量提升，在 var 之前打印变量返回 undefined，而 let 和 const 不存在变量提升会报错（暂时性死区）
4. var 可以重复声明，let 和 const 不行

JS 引擎在读取变量时，先找到变量绑定的内存地址，然后找到地址所指向的内存空间，最后读取其中内容，当变量改变时，JS 引擎不会用新值覆盖之前的旧值的内存空间，而是重新分配一个新的内存空间来存储新值，并将新的内存地址与变量进行绑定，JS 引擎会在何时的时机进行 GC，回收旧的内存空间
const 定义常量时，变量名与内存地址之间建立一种不可变的绑定关系，阻隔变量地址改变，当 const 定义的变量重新赋值时，JS 引擎会抛出异常

1. 在内存中创建一个新对象。
2. 将新对象内部的 proto 赋值为构造函数的 prototype 属性。
3. 将构造函数内部的 this 被赋值为新对象（即 this 指向新对象）。
4. 执行构造函数内部的代码（给新对象添加属性）。
5. 如果构造函数返回非空对象，则返回该对象。否则返回 this。

1. 原型链继承
2. 构造函数继承
3. 组合继承
4. 寄生组合继承
5. class 继承

具体原理、优缺点、实现可搜索相关贴子或教材

1. 没有 this，call ()、apply ()、bind () 等方法不能改变箭头函数中 this 的指向
2. 没有 prototype，故不能作为构造函数
3. 没有 arguments 对象
4. 箭头函数不能用作 Generator 函数，不能使用 yeild 关键字

try catch 捕获函数，在特定条件下 throw error

[1,NaN,NaN]
parseInt(value,index)
parseInt(1,0)、parseInt(2,1)、parseInt(3,2)

高阶函数是指传入参数为函数（数组的 map、reduce、forEach）或输出参数为函数（手写 add）

1
2
3
4
5
6
7
8
9

var b = 10;
(function b() {
   // 内部作用域，会先去查找是有已有变量b的声明，有就直接赋值20，确实有了呀。发现了具名函数 function b(){}，拿此b做赋值；
   // IIFE的函数无法进行赋值（内部机制，类似const定义的常量），所以无效。
  // （这里说的“内部机制”，想搞清楚，需要去查阅一些资料，弄明白IIFE在JS引擎的工作方式，堆栈存储IIFE的方式等）
    b = 20;
    console.log(b); // [Function b]
    console.log(window.b); // 10，不是20
})();

严格模式下，会报错 "Uncaught TypeError: Assignment to constant variable."

call 更好一些，因为 apply 多了一次将数组解构的操作

规则：

• 变量必须声明后再使用
• 函数的参数不能有同名属性，否则报错
• 不能使用 with 语句
• 不能对只读属性赋值，否则报错
• 不能使用前缀 0 表示八进制数，否则报错
• 不能删除不可删除的属性，否则报错
• 不能删除变量 delete prop，会报错，只能删除属性 delete global [prop]
• eval 不会在它的外层作用域引入变量
• eval 和 arguments 不能被重新赋值
• arguments 不会自动反映函数参数的变化
• 不能使用 arguments.callee
• 不能使用 arguments.caller
• 禁止 this 指向全局对象
• 不能使用 fn.caller 和 fn.arguments 获取函数调用的堆栈
• 增加了保留字（比如 protected、static 和 interface）

目的：

• 消除 Javascript 语法的一些不合理、不严谨之处，减少一些怪异行为；
• 消除代码运行的一些不安全之处，保证代码运行的安全；
• 提高编译器效率，增加运行速度；
• 为未来新版本的 Javascript 做好铺垫。

内存泄漏是指，应当被回收的对象没有被正常回收，变成常驻老生代的对象，导致内存占用越来越高。内存泄漏会导致应用程序速度变慢、高延时、崩溃等问题。

内存生命周期包括

1. 分配：按需分配内存。
2. 使用：读写已分配的内存。
3. 释放：释放不再需要的内存。

常见原因

1. 全局变量没有手动回收。
2. 函数变量闭包
3. 使用 JavaScript 对象来做缓存，且不设置过期策略和对象大小控制。
4. 定时器未解绑
5. 事件监听未销毁

V8 中有两个垃圾收集器。主要的 GC 使用 Mark-Compact 垃圾回收算法，从整个堆中收集垃圾。小型 GC 使用 Scavenger 垃圾回收算法，收集新生代垃圾。两种不同的算法应对不同的场景：

• 使用 Scavenger 算法主要处理存活周期短的对象中的可访问对象。
• 使用 Mark-Compact 算法主要处理存活周期长的对象中的不可访问的对象。

因为新生代中存活的可访问对象占少数，老生代中的不可访问对象占少数，所以这两种回收算法配合使用十分高效。

1. 分代垃圾收集
   在 V8 中，所有的 JavaScript 对象都通过堆来分配。V8 将其管理的堆分成两代：新生代和老生代。其中新生代又可细分为两个子代（Nursery、Intermediate）。即新生代中的对象为存活时间较短的对象，老生代中的对象为存活时间较长或常驻内存的对象。

2. Mark-Compact 算法（Major GC）
Mark-Compact 算法可以看作是 Mark-Sweep（标记清除）算法和 Cheney 复制算法的结合。该算法主要分为三个阶段：标记、清除、整理。

（1）标记（Mark）：标记是找所有可访问对象的过程。GC 会从一组已知的对象指针（称为根集，包括执行堆栈和全局对象等）中，进行递归标记可访问对象。
（2）清除（Sweep）：清除是将不可访问的对象留下的内存空间，添加到空闲链表（free list）的过程。未来为新对象分配内存时，可以从空闲链表中进行再分配。
（3）整理（Compact）：整理是将可访问对象，往内存一端移动的过程。主要解决标记清除阶段后，内存空间出现较多内存碎片时，可能导致无法分配大对象，而提前触发垃圾回收的问题。
3. Scavenger 算法（Minor GC）
V8 对新生代内存空间采用了 Scavenger 算法，该算法使用了 semi-space（半空间） 的设计：将堆一分为二，始终只使用一半的空间：From-Space 为使用空间，To-Space 为空闲空间。

新生代在 From-Space 中分配对象；在垃圾回收阶段，检查并按需复制 From-Space 中的可访问对象到 To-Space 或老生代，并释放 From-Space 中的不可访问对象占用的内存空间；最后 From-Space 和 To-Space 角色互换。

CommonJS 加载模块是同步的，适用 nodeJs，因为本地加载很快，拷贝输出，可修改引用值，运行时
AMD 规范则是异步步加载模块，允许指定回调函数，适用浏览器，网络请求不一定很快，引用输出，只读，编译时

函数的变量访问基于函数目前所处的环境，优先访问函数作用域也就是代码块中的变量，若没有则沿作用域链向上单向访问直到 window/global

1. 作为普通函数执行时，this 指向 window。
2. 当函数作为对象的方法被调用时，this 就会指向该对象。
3. 构造器调用，this 指向返回的这个对象。
4. 箭头函数 箭头函数的 this 绑定看的是 this 所在函数定义在哪个对象下，就绑定哪个对象。如果有嵌套的情况，则 this 绑定到最近的一层对象上。
5. 基于 Function.prototype 上的 apply 、 call 和 bind 调用模式，这三个方法都可以显示的指定调用函数的 this 指向。apply 接收参数的是数组，call 接受参数列表，bind 方法通过传入一个对象，返回一个 this 绑定了传入对象的新函数。这个函数的 this 指向除了使用 new 时会被改变，其他情况下都不会改变。若为空默认是指向全局对象 window。

JS 是单线程的，为了防止一个函数执行时间过长阻塞后面的代码，所以会先将同步代码压入执行栈中，依次执行，将异步代码推入异步队列，异步队列又分为宏任务队列和微任务队列，因为宏任务队列的执行时间较长，所以微任务队列要优先于宏任务队列
在浏览器环境中，有 JS 引擎线程和渲染线程，且两个线程互斥。 Node 环境中，只有 JS 线程。 不同环境执行机制有差异，不同任务进入不同 Event Queue 队列。 当主程结束，先执行准备好微任务，然后再执行准备好的宏任务，一个轮询结束。

浏览器中的事件环（Event Loop)

事件环的运行机制是，先会执行栈中的内容，栈中的内容执行后执行微任务，微任务清空后再执行宏任务，先取出一个宏任务，再去执行微任务，然后在取宏任务清微任务这样不停的循环。

eventLoop 是由 JS 的宿主环境（浏览器）来实现的；

事件循环可以简单的描述为以下四个步骤:

1. 函数入栈，当 Stack 中执行到异步任务的时候，就将他丢给 WebAPIs, 接着执行同步任务，直到 Stack 为空；
2. 此期间 WebAPIs 完成这个事件，把回调函数放入队列中等待执行（微任务放到微任务队列，宏任务放到宏任务队列）
3. 执行栈为空时，Event Loop 把微任务队列执行清空；
4. 微任务队列清空后，进入宏任务队列，取队列的第一项任务放入 Stack (栈）中执行，执行完成后，查看微任务队列是否有任务，有的话，清空微任务队列。重复 4，继续从宏任务中取任务执行，执行完成之后，继续清空微任务，如此反复循环，直至清空所有的任务。
   

Node 是基于 V8 引擎的运行在服务端的 JavaScript 运行环境，在处理高并发、I/O 密集 (文件操作、网络操作、数据库操作等) 场景有明显的优势。虽然用到也是 V8 引擎，但由于服务目的和环境不同，导致了它的 API 与原生 JS 有些区别，其 Event Loop 还要处理一些 I/O，比如新的网络连接等，所以 Node 的 Event Loop (事件环机制) 与浏览器的是不太一样。

相关API
浏览器：
宏任务：setTimeout、setInterval、requestAnimationFrame
微任务：promise.then（async/await）、MutationObserver
Node：
宏任务：setTimeout、setInterval、setImmediate、I/O
微任务：promise.then（async/await）、process.nextTick

区别
node 环境下定时器时依次一起执行的，而浏览器是一个个分开的，有单独的线程处理
浏览器的微任务执行是在每个宏任务之后，而 node 中则是在按阶段执行，一个阶段一轮回

Promise.all 或者 web worker

dom 树构建完成时执行 DOMContentLoaded，然后页面挂载时执行 Window.onLoad。

layer：最近相对定位父级元素
clint：浏览器可视窗口（不包括控制台、菜单、滚动条、工具栏）
offset：浏览器可视窗口（包括上面这些）
scroll：目前可视窗口 + 滚动条离顶部或左边隐藏的部分
page：document 对象
screen：屏幕